WIP: refactor tests with SignetStd for easy local/fork testing

Author: anna-carroll

test/Helpers.t.sol

@@ -4,30 +4,28 @@ pragma solidity 0.8.26;
 // system contracts
 import {Zenith} from "../src/Zenith.sol";
 import {UsesPermit2} from "../src/UsesPermit2.sol";
+import {RollupOrders} from "../src/orders/RollupOrders.sol";
 // deps
-import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
-import {ERC20Burnable} from "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Burnable.sol";
 import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol";
 import {Test, console2} from "forge-std/Test.sol";
+import {SignetStdTest, TestERC20} from "./SignetStdTest.t.sol";
 
-contract TestERC20 is ERC20Burnable {
-    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
-
-    function mint(address recipient, uint256 amount) external {
-        _mint(recipient, amount);
-    }
-}
-
-contract Permit2Helpers is Test {
-    address permit2Contract;
-
+contract Permit2Helpers is SignetStdTest {
     /// @notice the address signing the Permit messages and its pk
     uint256 ownerKey = 123;
     address owner = vm.addr(ownerKey);
 
     // permit consts
     UsesPermit2.Witness witness;
 
+    // single permit
+    UsesPermit2.Permit2 singlePermit;
+    ISignatureTransfer.SignatureTransferDetails singleTransferDetails;
+
+    // batch permit
+    UsesPermit2.Permit2Batch batchPermit;
+    ISignatureTransfer.SignatureTransferDetails[] batchTransferDetails;
+
     bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
     uint256 private immutable _CACHED_CHAIN_ID;
 
@@ -50,18 +48,6 @@ contract Permit2Helpers is Test {
         _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME);
     }
 
-    function _setUpPermit2(address token, uint256 amount) internal {
-        vm.label(owner, "owner");
-
-        // setup permit2 contract
-        permit2Contract = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
-        vm.label(address(permit2Contract), "permit2");
-
-        // approve permit2
-        vm.prank(owner);
-        TestERC20(token).approve(address(permit2Contract), amount * 10000);
-    }
-
     /// @notice given a Permit and a Witness, produce a signature from the `owner`
     function signPermit(
         uint256 signingKey,
@@ -154,7 +140,7 @@ contract Permit2Helpers is Test {
 
     /// @notice Builds a domain separator using the current chainId and contract address.
     function _buildDomainSeparator(bytes32 typeHash, bytes32 nameHash) private view returns (bytes32) {
-        return keccak256(abi.encode(typeHash, nameHash, block.chainid, permit2Contract));
+        return keccak256(abi.encode(typeHash, nameHash, block.chainid, PERMIT2));
     }
 
     /// @notice Creates an EIP-712 typed data hash
@@ -187,22 +173,3 @@ interface IBatchPermit {
         bytes calldata /*signature*/
     ) external;
 }
-
-contract HelpersTest is Test {
-    Zenith public target;
-
-    function setUp() public {
-        vm.createSelectFork("https://rpc.holesky.ethpandaops.io");
-        target = new Zenith(0x29403F107781ea45Bf93710abf8df13F67f2008f);
-    }
-
-    function check_signature() public {
-        bytes32 hash = 0xdcd0af9a45fa82dcdd1e4f9ef703d8cd459b6950c0638154c67117e86facf9c1;
-        uint8 v = 28;
-        bytes32 r = 0xb89764d107f812dbbebb925711b320d336ff8d03f08570f051123df86334f3f5;
-        bytes32 s = 0x394cd592577ce6307154045607b9b18ecc1de0eb636e996981477c2d9b1a7675;
-        address signer = ecrecover(hash, v, r, s);
-        vm.label(signer, "recovered signer");
-        assertEq(signer, 0x5b0517Dc94c413a5871536872605522E54C85a03);
-    }
-}

test/Orders.t.sol

@@ -9,15 +9,17 @@ import {OrderOrigin} from "../src/orders/OrderOrigin.sol";
 import {TestERC20} from "./Helpers.t.sol";
 import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
 import {Test, console2} from "forge-std/Test.sol";
+import {SignetStdTest} from "./SignetStdTest.t.sol";
 
-contract OrdersTest is Test {
+contract OrdersTest is SignetStdTest {
     RollupOrders public target;
+
     IOrders.Input[] public inputs;
     IOrders.Output[] public outputs;
 
     address token;
     address token2;
-    uint32 chainId = 3;
+
     address recipient = address(0x123);
     uint256 amount = 200;
     uint256 deadline = block.timestamp;
@@ -29,23 +31,25 @@ contract OrdersTest is Test {
     event Sweep(address indexed recipient, address indexed token, uint256 amount);
 
     function setUp() public virtual {
-        target = new RollupOrders(address(0));
+        target = ROLLUP_ORDERS;
 
-        // setup token
-        token = address(new TestERC20("hi", "HI"));
+        // setup first token
+        token = address(ROLLUP_WBTC);
+        vm.prank(ROLLUP_MINTER);
         TestERC20(token).mint(address(this), amount * 10000);
         TestERC20(token).approve(address(target), amount * 10000);
 
         // setup second token
-        token2 = address(new TestERC20("bye", "BYE"));
+        token2 = address(ROLLUP_WETH);
+        vm.prank(ROLLUP_MINTER);
         TestERC20(token2).mint(address(this), amount * 10000);
         TestERC20(token2).approve(address(target), amount * 10000);
 
         // setup simple Order Inputs/Outputs
         IOrders.Input memory input = IOrders.Input(token, amount);
         inputs.push(input);
 
-        IOrders.Output memory output = IOrders.Output(token, amount, recipient, chainId);
+        IOrders.Output memory output = IOrders.Output(token, amount, recipient, ROLLUP_CHAIN_ID);
         outputs.push(output);
     }
 
@@ -143,9 +147,6 @@ contract OrdersTest is Test {
     }
 
     function test_sweepETH() public {
-        // set self as Builder
-        vm.coinbase(address(this));
-
         // initiate an ETH order
         inputs[0].token = address(0);
         target.initiate{value: amount}(deadline, inputs, outputs);
@@ -161,9 +162,6 @@ contract OrdersTest is Test {
     }
 
     function test_sweepERC20() public {
-        // set self as Builder
-        vm.coinbase(address(this));
-
         // send ERC20 to the contract
         TestERC20(token).transfer(address(target), amount);
 
@@ -194,7 +192,7 @@ contract OrdersTest is Test {
 
     function test_fill_both() public {
         // add ETH output
-        outputs.push(IOrders.Output(address(0), amount * 2, recipient, chainId));
+        outputs.push(IOrders.Output(address(0), amount * 2, recipient, ROLLUP_CHAIN_ID));
 
         // expect Outputs are filled, ERC20 is transferred
         vm.expectEmit();
@@ -211,7 +209,7 @@ contract OrdersTest is Test {
         // change first output to ETH
         outputs[0].token = address(0);
         // add second ETH oputput
-        outputs.push(IOrders.Output(address(0), amount * 2, recipient, chainId));
+        outputs.push(IOrders.Output(address(0), amount * 2, recipient, ROLLUP_CHAIN_ID));
 
         // expect Order event is initiated
         vm.expectEmit();
@@ -226,7 +224,7 @@ contract OrdersTest is Test {
         // change first output to ETH
         outputs[0].token = address(0);
         // add second ETH output
-        outputs.push(IOrders.Output(address(0), 1, recipient, chainId));
+        outputs.push(IOrders.Output(address(0), 1, recipient, ROLLUP_CHAIN_ID));
 
         // total ETH outputs should be `amount` + 1; function should underflow only sending `amount`
         vm.expectRevert();

test/Passage.t.sol

@@ -10,63 +10,47 @@ import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
 import {ERC20Burnable} from "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Burnable.sol";
 import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol";
 import {Test, console2} from "forge-std/Test.sol";
+import {SignetStdTest} from "./SignetStdTest.t.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 
-contract PassageTest is Test {
+contract PassageTest is SignetStdTest {
     using Address for address payable;
 
     Passage public target;
     address token;
     address newToken;
-    uint256 chainId = 3;
     address recipient = address(0x123);
     uint256 amount = 200;
 
-    address to = address(0x01);
-    bytes data = abi.encodeWithSelector(ERC20.transfer.selector, recipient, amount);
-    uint256 value = 100;
-    uint256 gas = 10_000_000;
-    uint256 maxFeePerGas = 50;
-
     event Enter(uint256 indexed rollupChainId, address indexed rollupRecipient, uint256 amount);
 
     event EnterToken(
         uint256 indexed rollupChainId, address indexed rollupRecipient, address indexed token, uint256 amount
     );
 
-    event Transact(
-        uint256 indexed rollupChainId,
-        address indexed sender,
-        address indexed to,
-        bytes data,
-        uint256 value,
-        uint256 gas,
-        uint256 maxFeePerGas
-    );
+    event EnterConfigured(address indexed token, bool indexed canEnter);
 
     event Withdrawal(address indexed token, address indexed recipient, uint256 amount);
 
-    event EnterConfigured(address indexed token, bool indexed canEnter);
-
     function setUp() public {
-        // deploy token one, configured at deploy time
-        token = address(new TestERC20("hi", "HI"));
-        TestERC20(token).mint(address(this), amount * 10000);
-
         // deploy target
-        address[] memory initialEnterTokens = new address[](1);
-        initialEnterTokens[0] = token;
-        target = new Passage(block.chainid + 1, address(this), initialEnterTokens, address(0));
+        target = HOST_PASSAGE;
+
+        // setup token
+        token = address(HOST_WETH);
+        // mint WETH by sending ETH
+        payable(token).sendValue(amount * 10000);
         TestERC20(token).approve(address(target), amount * 10000);
 
-        // deploy token two, don't configure
-        newToken = address(new TestERC20("bye", "BYE"));
+        // deploy new token that's not configured on Passage
+        newToken = address(new TestERC20("bye", "BYE", 18));
         TestERC20(newToken).mint(address(this), amount * 10000);
         TestERC20(newToken).approve(address(target), amount * 10000);
     }
 
     function test_setUp() public {
-        assertEq(target.defaultRollupChainId(), block.chainid + 1);
-        assertEq(target.tokenAdmin(), address(this));
+        assertEq(target.defaultRollupChainId(), ROLLUP_CHAIN_ID);
+        assertEq(target.tokenAdmin(), TOKEN_ADMIN);
         assertTrue(target.canEnter(token));
         assertFalse(target.canEnter(newToken));
     }
@@ -89,28 +73,32 @@ contract PassageTest is Test {
         // enter not allowed by default
         assertFalse(target.canEnter(newToken));
         vm.expectRevert(abi.encodeWithSelector(Passage.DisallowedEnter.selector, newToken));
-        target.enterToken(chainId, recipient, newToken, amount);
+        target.enterToken(ROLLUP_CHAIN_ID, recipient, newToken, amount);
 
         // allow enter
+        vm.startPrank(TOKEN_ADMIN);
         vm.expectEmit();
         emit EnterConfigured(newToken, true);
         target.configureEnter(newToken, true);
+        vm.stopPrank();
 
         // enter is allowed
         assertTrue(target.canEnter(newToken));
         vm.expectEmit();
-        emit EnterToken(chainId, recipient, newToken, amount);
-        target.enterToken(chainId, recipient, newToken, amount);
+        emit EnterToken(ROLLUP_CHAIN_ID, recipient, newToken, amount);
+        target.enterToken(ROLLUP_CHAIN_ID, recipient, newToken, amount);
 
         // disallow enter
+        vm.startPrank(TOKEN_ADMIN);
         vm.expectEmit();
         emit EnterConfigured(newToken, false);
         target.configureEnter(newToken, false);
+        vm.stopPrank();
 
         // enter not allowed again
         assertFalse(target.canEnter(newToken));
         vm.expectRevert(abi.encodeWithSelector(Passage.DisallowedEnter.selector, newToken));
-        target.enterToken(chainId, recipient, newToken, amount);
+        target.enterToken(ROLLUP_CHAIN_ID, recipient, newToken, amount);
     }
 
     function test_receive() public {
@@ -127,8 +115,8 @@ contract PassageTest is Test {
 
     function test_enter() public {
         vm.expectEmit();
-        emit Enter(chainId, recipient, amount);
-        target.enter{value: amount}(chainId, recipient);
+        emit Enter(ROLLUP_CHAIN_ID, recipient, amount);
+        target.enter{value: amount}(ROLLUP_CHAIN_ID, recipient);
     }
 
     function test_enter_defaultChain() public {
@@ -139,11 +127,11 @@ contract PassageTest is Test {
 
     function test_enterToken() public {
         vm.expectEmit();
-        emit EnterToken(chainId, recipient, token, amount);
+        emit EnterToken(ROLLUP_CHAIN_ID, recipient, token, amount);
         vm.expectCall(
             token, abi.encodeWithSelector(ERC20.transferFrom.selector, address(this), address(target), amount)
         );
-        target.enterToken(chainId, recipient, token, amount);
+        target.enterToken(ROLLUP_CHAIN_ID, recipient, token, amount);
     }
 
     function test_enterToken_defaultChain() public {
@@ -156,16 +144,17 @@ contract PassageTest is Test {
     }
 
     function test_withdraw() public {
-        TestERC20(token).mint(address(target), amount);
+        IERC20(token).transfer(address(target), amount);
 
+        vm.startPrank(TOKEN_ADMIN);
         vm.expectEmit();
         emit Withdrawal(token, recipient, amount);
         vm.expectCall(token, abi.encodeWithSelector(ERC20.transfer.selector, recipient, amount));
         target.withdraw(token, recipient, amount);
     }
 }
 
-contract RollupPassageTest is Test {
+contract RollupPassageTest is SignetStdTest {
     using Address for address payable;
 
     RollupPassage public target;
@@ -178,11 +167,12 @@ contract RollupPassageTest is Test {
     event ExitToken(address indexed hostRecipient, address indexed token, uint256 amount);
 
     function setUp() public virtual {
-        // deploy target
-        target = new RollupPassage(address(0));
+        // setup target
+        target = ROLLUP_PASSAGE;
 
-        // deploy token
-        token = address(new TestERC20("hi", "HI"));
+        // setup token
+        token = address(ROLLUP_WETH);
+        vm.prank(ROLLUP_MINTER);
         TestERC20(token).mint(address(this), amount * 10000);
         TestERC20(token).approve(address(target), amount * 10000);
     }