test(arbToGno): mock contract for native bridges and tokens

Author: madhurMongia

contracts/src/test/ArbToGnosis/VeaInboxArbToGnosisMock.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+
+/// @custom:authors: [@madhurMongia]
+/// @custom:reviewers: []
+/// @custom:auditors: []
+/// @custom:bounties: []
+/// @custom:deployments: []
+
+pragma solidity 0.8.24;
+
+import "../../arbitrumToGnosis/VeaInboxArbToGnosis.sol";
+import "../../canonical/arbitrum/IArbSys.sol";
+import "../../interfaces/routers/IRouterToGnosis.sol";
+
+contract VeaInboxArbToGnosisMock is VeaInboxArbToGnosis {
+    IArbSys public immutable mockArbSys;
+
+    constructor(
+        uint256 _epochPeriod,
+        address _routerArbToGnosis,
+        IArbSys _mockArbSys
+    ) VeaInboxArbToGnosis(_epochPeriod, _routerArbToGnosis) {
+        mockArbSys = _mockArbSys;
+    }
+
+    // Override sendSnapshot to use the mock ArbSys
+    function sendSnapshot(uint256 _epoch, uint256 _gasLimit, Claim memory _claim) external override {
+        unchecked {
+            require(_epoch < block.timestamp / epochPeriod, "Can only send past epoch snapshot.");
+        }
+
+        bytes memory data = abi.encodeCall(IRouterToGnosis.route, (_epoch, snapshots[_epoch], _gasLimit, _claim));
+
+        // Use the mock ArbSys instead of the constant ARB_SYS
+        bytes32 ticketID = bytes32(mockArbSys.sendTxToL1(routerArbToGnosis, data));
+
+        emit SnapshotSent(_epoch, ticketID);
+    }
+}

contracts/src/test/bridge-mocks/arbitrum/ArbSysMockWithBridge.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+/// @custom:authors: [@madhurMongia]
+/// @custom:reviewers: []
+/// @custom:auditors: []
+/// @custom:bounties: []
+/// @custom:deployments: []
+
+pragma solidity 0.8.24;
+
+import "../../../canonical/arbitrum/IArbSys.sol";
+import "./BridgeMock.sol";
+
+contract ArbSysMockWithBridge is IArbSys {
+    BridgeMock public immutable bridge;
+
+    constructor(BridgeMock _bridge) {
+        bridge = _bridge;
+    }
+
+    function sendTxToL1(
+        address destination,
+        bytes calldata calldataForL1
+    ) external payable returns (uint256 _withdrawal_ID) {
+        return bridge.executeL1Message(destination, calldataForL1);
+    }
+}

contracts/src/test/bridge-mocks/arbitrum/BridgeMock.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-/// @custom:authors: [@hrishibhat]
+/// @custom:authors: [@hrishibhat,@madhurMongia]
 /// @custom:reviewers: []
 /// @custom:auditors: []
 /// @custom:bounties: []
@@ -27,4 +27,17 @@ contract BridgeMock is IBridge {
         if (index == 0) return sequencerInbox;
         return address(0);
     }
+
+    function executeL1Message(address destination, bytes calldata data) external returns (uint256) {
+        // Simulate the bridge calling the destination contract
+        (bool success, bytes memory returnData) = destination.call(data);
+
+        if (!success) {
+            assembly {
+                revert(add(returnData, 32), mload(returnData))
+            }
+        }
+
+        return 0;
+    }
 }

contracts/src/test/bridge-mocks/gnosis/MockAMB.sol

@@ -5,7 +5,7 @@ pragma solidity 0.8.24;
 import "../../../canonical/gnosis-chain/IAMB.sol";
 
 contract MockAMB is IAMB {
-    event MockedEvent(bytes32 indexed messageId, bytes encodedData);
+    event MockedEvent(bytes32 indexed messageId, bytes encodedData, bytes _data);
 
     address public messageSender;
     uint256 public maxGasPerTx;
@@ -34,8 +34,14 @@ contract MockAMB is IAMB {
         messageSender = _sender;
         messageId = _messageId;
         transactionHash = _messageId;
-        messageSourceChainId = bytes32(uint256(1337));
-        (bool status, ) = _contract.call{gas: _gas}(_data);
+        messageSourceChainId = bytes32(uint256(31337));
+        (bool status, bytes memory returnData) = _contract.call{gas: _gas}(_data);
+
+        if (!status) {
+            assembly {
+                revert(add(returnData, 32), mload(returnData))
+            }
+        }
         messageSender = address(0);
         messageId = bytes32(0);
         transactionHash = bytes32(0);
@@ -64,7 +70,7 @@ contract MockAMB is IAMB {
         uint256 _dataType
     ) internal returns (bytes32) {
         require(messageId == bytes32(0));
-        bytes32 bridgeId = keccak256(abi.encodePacked(uint16(1337), address(this))) &
+        bytes32 bridgeId = keccak256(abi.encodePacked(uint16(31337), address(this))) &
             0x00000000ffffffffffffffffffffffffffffffffffffffff0000000000000000;
 
         bytes32 _messageId = bytes32(uint256(0x11223344 << 224)) | bridgeId | bytes32(uint256(nonce));
@@ -77,12 +83,12 @@ contract MockAMB is IAMB {
             uint8(2),
             uint8(2),
             uint8(_dataType),
-            uint16(1337),
-            uint16(1338),
+            uint16(31337),
+            uint16(31337),
             _data
         );
 
-        emit MockedEvent(_messageId, eventData);
+        emit MockedEvent(_messageId, eventData, _data);
         return _messageId;
     }
 

contracts/src/test/tokens/gnosis/MockWETH.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+
+/// @custom:authors: [@madhurMongia]
+/// @custom:reviewers: []
+/// @custom:auditors: []
+/// @custom:bounties: []
+/// @custom:deployments: []
+
+pragma solidity ^0.8.0;
+
+contract MockWETH {
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8 public decimals = 18;
+
+    event Approval(address indexed src, address indexed guy, uint wad);
+    event Transfer(address indexed src, address indexed dst, uint wad);
+    event Deposit(address indexed dst, uint wad);
+    event Withdrawal(address indexed src, uint wad);
+
+    mapping(address => uint) public balanceOf;
+    mapping(address => mapping(address => uint)) public allowance;
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint wad) public {
+        require(balanceOf[msg.sender] >= wad, "WETH: insufficient balance");
+        balanceOf[msg.sender] -= wad;
+        payable(msg.sender).transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function totalSupply() public view returns (uint) {
+        return address(this).balance;
+    }
+
+    function approve(address guy, uint wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(address src, address dst, uint wad) public returns (bool) {
+        require(balanceOf[src] >= wad, "WETH: insufficient balance");
+
+        if (src != msg.sender && allowance[src][msg.sender] != type(uint).max) {
+            require(allowance[src][msg.sender] >= wad, "WETH: insufficient allowance");
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        emit Transfer(src, dst, wad);
+
+        return true;
+    }
+
+    // This function is added for convenience in testing
+    function mintMock(address to, uint256 amount) public {
+        balanceOf[to] += amount;
+        emit Transfer(address(0), to, amount);
+    }
+
+    function burn(uint wad) public {
+        require(balanceOf[msg.sender] >= wad, "WETH: insufficient balance");
+        balanceOf[msg.sender] -= wad;
+        emit Transfer(msg.sender, address(0), wad);
+    }
+}