feat: Host fuzz tests

.gas-snapshot

@@ -1,40 +1,60 @@
 GnosisSafeTest:test_gnosis_receive() (gas: 16106)
-OrderOriginPermit2Test:test_fillPermit2() (gas: 174723)
-OrderOriginPermit2Test:test_fillPermit2_multi() (gas: 510586)
-OrderOriginPermit2Test:test_initiatePermit2() (gas: 187081)
-OrderOriginPermit2Test:test_initiatePermit2_multi() (gas: 470943)
-OrdersTest:test_fill_ERC20() (gas: 76273)
-OrdersTest:test_fill_ETH() (gas: 73740)
-OrdersTest:test_fill_both() (gas: 179143)
-OrdersTest:test_fill_multiETH() (gas: 141885)
-OrdersTest:test_fill_underflowETH() (gas: 120789)
-OrdersTest:test_initiate_ERC20() (gas: 90588)
-OrdersTest:test_initiate_ETH() (gas: 53217)
-OrdersTest:test_initiate_both() (gas: 130158)
-OrdersTest:test_initiate_multiERC20() (gas: 186451)
-OrdersTest:test_initiate_multiETH() (gas: 86339)
-OrdersTest:test_orderExpired() (gas: 32846)
-OrdersTest:test_sweepERC20() (gas: 62965)
-OrdersTest:test_sweepETH() (gas: 90833)
-OrdersTest:test_underflowETH() (gas: 69404)
-PassagePermit2Test:test_disallowedEnterPermit2() (gas: 1130187)
-PassagePermit2Test:test_enterTokenPermit2() (gas: 150794)
-PassageTest:test_configureEnter() (gas: 141651)
-PassageTest:test_disallowedEnter() (gas: 58928)
+OrderOriginPermit2Test:test_fillPermit2() (gas: 174849)
+OrderOriginPermit2Test:test_fillPermit2_multi() (gas: 510712)
+OrderOriginPermit2Test:test_initiatePermit2() (gas: 187207)
+OrderOriginPermit2Test:test_initiatePermit2_multi() (gas: 471069)
+OrdersTest:test_fill_ERC20() (gas: 76399)
+OrdersTest:test_fill_ETH() (gas: 73682)
+OrdersTest:test_fill_both() (gas: 179085)
+OrdersTest:test_fill_multiETH() (gas: 141643)
+OrdersTest:test_fill_underflowETH() (gas: 120697)
+OrdersTest:test_initiate_ERC20() (gas: 90714)
+OrdersTest:test_initiate_ETH() (gas: 53343)
+OrdersTest:test_initiate_both() (gas: 130284)
+OrdersTest:test_initiate_multiERC20() (gas: 186577)
+OrdersTest:test_initiate_multiETH() (gas: 86465)
+OrdersTest:test_orderExpired() (gas: 32938)
+OrdersTest:test_sweepERC20() (gas: 63091)
+OrdersTest:test_sweepETH() (gas: 90901)
+OrdersTest:test_underflowETH() (gas: 69496)
+PassageFuzzTest:test_disallowedEnter(address,address,uint256) (runs: 266, μ: 19249, ~: 19249)
+PassageFuzzTest:test_enter(uint256,address,uint256) (runs: 264, μ: 20920, ~: 20920)
+PassageFuzzTest:test_enterToken(uint256,address,uint256) (runs: 264, μ: 66342, ~: 66342)
+PassageFuzzTest:test_enterToken_defaultChain(address,uint256) (runs: 262, μ: 67125, ~: 67125)
+PassageFuzzTest:test_enter_defaultChain(address,uint56) (runs: 267, μ: 21804, ~: 21804)
+PassageFuzzTest:test_fallback(uint256,bytes) (runs: 264, μ: 21921, ~: 21921)
+PassageFuzzTest:test_onlyTokenAdmin(address,address,bool,address,uint256) (runs: 267, μ: 16507, ~: 16507)
+PassageFuzzTest:test_receive(uint256) (runs: 264, μ: 20719, ~: 20719)
+PassageFuzzTest:test_withdraw(address,uint256) (runs: 262, μ: 67480, ~: 67501)
+PassagePermit2Test:test_disallowedEnterPermit2() (gas: 1130279)
+PassagePermit2Test:test_enterTokenPermit2() (gas: 150920)
+PassageTest:test_configureEnter() (gas: 141961)
+PassageTest:test_disallowedEnter() (gas: 59020)
 PassageTest:test_enter() (gas: 26523)
-PassageTest:test_enterToken() (gas: 66880)
-PassageTest:test_enterToken_defaultChain() (gas: 65384)
+PassageTest:test_enterToken() (gas: 67006)
+PassageTest:test_enterToken_defaultChain() (gas: 65510)
 PassageTest:test_enter_defaultChain() (gas: 24949)
-PassageTest:test_fallback() (gas: 22784)
-PassageTest:test_onlyTokenAdmin() (gas: 19145)
-PassageTest:test_receive() (gas: 22222)
+PassageTest:test_fallback() (gas: 22528)
+PassageTest:test_onlyTokenAdmin() (gas: 19237)
+PassageTest:test_receive() (gas: 22035)
 PassageTest:test_setUp() (gas: 23289)
-PassageTest:test_withdraw() (gas: 64486)
-RollupPassagePermit2Test:test_exitTokenPermit2() (gas: 135717)
+PassageTest:test_withdraw() (gas: 64612)
+RollupPassagePermit2Test:test_exitTokenPermit2() (gas: 135843)
 RollupPassageTest:test_exit() (gas: 23114)
-RollupPassageTest:test_exitToken() (gas: 53266)
-RollupPassageTest:test_fallback() (gas: 20910)
-RollupPassageTest:test_receive() (gas: 20393)
+RollupPassageTest:test_exitToken() (gas: 53367)
+RollupPassageTest:test_fallback() (gas: 20654)
+RollupPassageTest:test_receive() (gas: 20206)
+TransactFuzzTest:test_configureGas(uint256,uint256) (runs: 267, μ: 27723, ~: 27867)
+TransactFuzzTest:test_enterTransact_defaultChain_emitsEnter(uint256,address,address,bytes,uint256,uint256,uint256,uint256) (runs: 260, μ: 70502, ~: 70928)
+TransactFuzzTest:test_enterTransact_emitsEnter(uint256,address,bytes,uint256,uint256,uint256,uint256) (runs: 261, μ: 70250, ~: 70379)
+TransactFuzzTest:test_enterTransact_emitsTransact(uint256,address,bytes,uint256,uint256,uint256,uint256) (runs: 261, μ: 70528, ~: 70634)
+TransactFuzzTest:test_onlyGasAdmin(address,uint256,uint256) (runs: 267, μ: 12907, ~: 12907)
+TransactFuzzTest:test_transact(uint256,address,address,bytes,uint256,uint256,uint256) (runs: 261, μ: 51025, ~: 51391)
+TransactFuzzTest:test_transactWithValue_defaultChain_emitsEnter(address,bytes,uint256,uint256,uint256,uint256) (runs: 261, μ: 71793, ~: 72071)
+TransactFuzzTest:test_transactWithValue_defaultChain_emitsTransact(address,bytes,uint256,uint256,uint256,uint256) (runs: 261, μ: 72160, ~: 72413)
+TransactFuzzTest:test_transactWithValue_defaultChain_emitsTransact(uint256,address,address,bytes,uint256,uint256,uint256,uint256) (runs: 260, μ: 70765, ~: 71159)
+TransactFuzzTest:test_transact_defaultChain(address,address,bytes,uint256,uint256,uint256) (runs: 262, μ: 52898, ~: 53103)
+TransactFuzzTest:test_transact_perTransactGasLimit(uint256,address,bytes,uint256,uint256,uint256) (runs: 262, μ: 15980, ~: 15980)
 TransactTest:test_configureGas() (gas: 27486)
 TransactTest:test_enterTransact() (gas: 127464)
 TransactTest:test_onlyGasAdmin() (gas: 9895)
@@ -43,6 +63,12 @@ TransactTest:test_transact() (gas: 107567)
 TransactTest:test_transact_defaultChain() (gas: 106574)
 TransactTest:test_transact_globalGasLimit() (gas: 117828)
 TransactTest:test_transact_perTransactGasLimit() (gas: 34574)
+ZenithFuzzTest:test_addSequencer(uint256,(uint256,uint256,uint256,address,bytes32),bytes) (runs: 256, μ: 90812, ~: 90812)
+ZenithFuzzTest:test_badSignature((uint256,uint256,uint256,address,bytes32),(uint256,uint256,uint256,address,bytes32),bytes) (runs: 256, μ: 40335, ~: 40334)
+ZenithFuzzTest:test_incorrectHostBlock((uint256,uint256,uint256,address,bytes32),bytes) (runs: 267, μ: 22120, ~: 22115)
+ZenithFuzzTest:test_notSequencer(uint256,(uint256,uint256,uint256,address,bytes32),bytes) (runs: 256, μ: 32184, ~: 32183)
+ZenithFuzzTest:test_notSequencerAdmin(address,address) (runs: 267, μ: 14423, ~: 14423)
+ZenithFuzzTest:test_submitBlock((uint256,uint256,uint256,address,bytes32),bytes) (runs: 256, μ: 61351, ~: 61351)
 ZenithTest:test_addSequencer() (gas: 98616)
 ZenithTest:test_badSignature() (gas: 46355)
 ZenithTest:test_incorrectHostBlock() (gas: 42276)

test/fuzz-host/PassageFuzz.t.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity 0.8.26;
+
+// test contracts
+import {Passage} from "../../src/passage/Passage.sol";
+import {RollupPassage} from "../../src/passage/RollupPassage.sol";
+// utils
+import {TestERC20} from "../Helpers.t.sol";
+import {SignetStdTest} from "../SignetStdTest.t.sol";
+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 {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+contract PassageFuzzTest is SignetStdTest {
+    using Address for address payable;
+
+    Passage public target;
+    address configuredToken;
+
+    event Enter(uint256 indexed rollupChainId, address indexed rollupRecipient, uint256 amount);
+
+    event EnterToken(
+        uint256 indexed rollupChainId, address indexed rollupRecipient, address indexed token, uint256 amount
+    );
+
+    event EnterConfigured(address indexed token, bool indexed canEnter);
+
+    event Withdrawal(address indexed token, address indexed recipient, uint256 amount);
+
+    function setUp() public virtual {
+        // deploy target
+        target = HOST_PASSAGE;
+
+        // setup token
+        configuredToken = address(HOST_WETH);
+        // mint WETH by sending ETH
+        payable(configuredToken).sendValue(10000 ether);
+        TestERC20(configuredToken).approve(address(target), 10000 ether);
+    }
+
+    // only the token admin can add or remove new tokens from Passage
+    function test_onlyTokenAdmin(address caller, address token, bool canEnter, address recipient, uint256 amount)
+        public
+    {
+        vm.assume(caller != TOKEN_ADMIN);
+        vm.startPrank(caller);
+
+        vm.expectRevert(Passage.OnlyTokenAdmin.selector);
+        target.configureEnter(token, canEnter);
+
+        vm.expectRevert(Passage.OnlyTokenAdmin.selector);
+        target.withdraw(token, recipient, amount);
+    }
+
+    function test_disallowedEnter(address recipient, address newToken, uint256 amount) public {
+        vm.assume(amount > 0);
+        vm.assume(target.canEnter(newToken) == false);
+        vm.mockCall(
+            newToken,
+            abi.encodeWithSelector(IERC20.transferFrom.selector, address(this), address(target), amount),
+            abi.encode(true)
+        );
+        vm.expectRevert(abi.encodeWithSelector(Passage.DisallowedEnter.selector, newToken));
+        target.enterToken(recipient, newToken, amount);
+    }
+
+    function test_receive(uint256 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        vm.expectEmit();
+        emit Enter(target.defaultRollupChainId(), address(this), amount);
+        payable(address(target)).sendValue(amount);
+    }
+
+    function test_fallback(uint256 amount, bytes memory data) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        vm.expectEmit();
+        emit Enter(target.defaultRollupChainId(), address(this), amount);
+        payable(address(target)).functionCallWithValue(data, amount);
+    }
+
+    function test_enter(uint256 rollupChainId, address recipient, uint256 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        vm.expectEmit();
+        emit Enter(rollupChainId, recipient, amount);
+        target.enter{value: amount}(rollupChainId, recipient);
+    }
+
+    function test_enter_defaultChain(address recipient, uint56 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        vm.expectEmit();
+        emit Enter(target.defaultRollupChainId(), recipient, amount);
+        target.enter{value: amount}(recipient);
+    }
+
+    function test_enterToken(uint256 rollupChainId, address recipient, uint256 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        // mint WETH of the amount
+        payable(configuredToken).sendValue(amount);
+        TestERC20(configuredToken).approve(address(target), amount);
+
+        vm.expectEmit();
+        emit EnterToken(rollupChainId, recipient, configuredToken, amount);
+        vm.expectCall(
+            configuredToken, abi.encodeWithSelector(ERC20.transferFrom.selector, address(this), address(target), amount)
+        );
+        target.enterToken(rollupChainId, recipient, configuredToken, amount);
+    }
+
+    function test_enterToken_defaultChain(address recipient, uint256 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        // mint WETH of the amount
+        payable(configuredToken).sendValue(amount);
+        TestERC20(configuredToken).approve(address(target), amount);
+
+        vm.expectEmit();
+        emit EnterToken(target.defaultRollupChainId(), recipient, configuredToken, amount);
+        vm.expectCall(
+            configuredToken, abi.encodeWithSelector(ERC20.transferFrom.selector, address(this), address(target), amount)
+        );
+        target.enterToken(recipient, configuredToken, amount);
+    }
+
+    function test_withdraw(address recipient, uint256 amount) public {
+        vm.assume(amount > 0 && amount < payable(address(this)).balance);
+        payable(configuredToken).sendValue(amount);
+        IERC20(configuredToken).transfer(address(target), amount);
+
+        vm.startPrank(TOKEN_ADMIN);
+        vm.expectEmit();
+        emit Withdrawal(configuredToken, recipient, amount);
+        vm.expectCall(configuredToken, abi.encodeWithSelector(ERC20.transfer.selector, recipient, amount));
+        target.withdraw(configuredToken, recipient, amount);
+    }
+}