feat(ctb): add basic weth tests (#10235)

packages/contracts-bedrock/test/dispute/WETH98.t.sol

@@ -4,16 +4,31 @@ import { Test } from "forge-std/Test.sol";
 import { WETH98 } from "src/dispute/weth/WETH98.sol";
 
 contract WETH98_Test is Test {
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
     WETH98 public weth;
     address alice;
+    address bob;
 
     function setUp() public {
         weth = new WETH98();
         alice = makeAddr("alice");
+        bob = makeAddr("bob");
         deal(alice, 1 ether);
     }
 
+    function test_getName_succeeds() public view {
+        assertEq(weth.name(), "Wrapped Ether");
+        assertEq(weth.symbol(), "WETH");
+        assertEq(weth.decimals(), 18);
+    }
+
     function test_receive_succeeds() public {
+        vm.expectEmit(address(weth));
+        emit Deposit(alice, 1 ether);
         vm.prank(alice);
         (bool success,) = address(weth).call{ value: 1 ether }("");
         assertTrue(success);
@@ -21,15 +36,107 @@ contract WETH98_Test is Test {
     }
 
     function test_fallback_succeeds() public {
+        vm.expectEmit(address(weth));
+        emit Deposit(alice, 1 ether);
         vm.prank(alice);
         (bool success,) = address(weth).call{ value: 1 ether }(hex"1234");
         assertTrue(success);
         assertEq(weth.balanceOf(alice), 1 ether);
     }
 
-    function test_getName_succeeds() public view {
-        assertEq(weth.name(), "Wrapped Ether");
-        assertEq(weth.symbol(), "WETH");
-        assertEq(weth.decimals(), 18);
+    function test_deposit_succeeds() public {
+        vm.expectEmit(address(weth));
+        emit Deposit(alice, 1 ether);
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        assertEq(weth.balanceOf(alice), 1 ether);
+    }
+
+    function test_withdraw_succeeds() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.expectEmit(address(weth));
+        emit Withdrawal(alice, 1 ether);
+        vm.prank(alice);
+        weth.withdraw(1 ether);
+        assertEq(weth.balanceOf(alice), 0);
+    }
+
+    function test_withdraw_partialWithdrawal_succeeds() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.expectEmit(address(weth));
+        emit Withdrawal(alice, 1 ether / 2);
+        vm.prank(alice);
+        weth.withdraw(1 ether / 2);
+        assertEq(weth.balanceOf(alice), 1 ether / 2);
+    }
+
+    function test_withdraw_tooLargeWithdrawal_fails() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.expectRevert();
+        vm.prank(alice);
+        weth.withdraw(1 ether + 1);
+    }
+
+    function test_transfer_succeeds() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.expectEmit(address(weth));
+        emit Transfer(alice, bob, 1 ether);
+        vm.prank(alice);
+        weth.transfer(bob, 1 ether);
+        assertEq(weth.balanceOf(alice), 0);
+        assertEq(weth.balanceOf(bob), 1 ether);
+    }
+
+    function test_transfer_tooLarge_fails() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.expectRevert();
+        vm.prank(alice);
+        weth.transfer(bob, 1 ether + 1);
+    }
+
+    function test_approve_succeeds() public {
+        vm.prank(alice);
+        vm.expectEmit(address(weth));
+        emit Approval(alice, bob, 1 ether);
+        weth.approve(bob, 1 ether);
+        assertEq(weth.allowance(alice, bob), 1 ether);
+    }
+
+    function test_transferFrom_succeeds() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.prank(alice);
+        weth.approve(bob, 1 ether);
+        vm.expectEmit(address(weth));
+        emit Transfer(alice, bob, 1 ether);
+        vm.prank(bob);
+        weth.transferFrom(alice, bob, 1 ether);
+        assertEq(weth.balanceOf(alice), 0);
+        assertEq(weth.balanceOf(bob), 1 ether);
+    }
+
+    function test_transferFrom_tooLittleApproval_fails() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.prank(alice);
+        weth.approve(bob, 1 ether);
+        vm.expectRevert();
+        vm.prank(bob);
+        weth.transferFrom(alice, bob, 1 ether + 1);
+    }
+
+    function test_transferFrom_tooLittleBalance_fails() public {
+        vm.prank(alice);
+        weth.deposit{ value: 1 ether }();
+        vm.prank(alice);
+        weth.approve(bob, 2 ether);
+        vm.expectRevert();
+        vm.prank(bob);
+        weth.transferFrom(alice, bob, 1 ether + 1);
     }
 }