Test MessageRelayer

test/MessageRelayer/DepositRecipientScenarios.t.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {GenericRecipient} from "./GenericRecipient.t.sol";
+import {InitialState} from "./InitialState.t.sol";
+import {IMessageRelayer} from "src/protocol/IMessageRelayer.sol";
+
+// This is a concrete class because if we are not using the MessageRelayer,
+// we do not need to investigate any other properties of the message
+contract DepositRecipientIsNotMessageRelayer is InitialState {
+    function setUp() public override {
+        super.setUp();
+        // bypass the relayer and send the message directly to the recipient
+        // do not bother changing the default message encoding (to a `receiveMessage` function)
+        // because the recipient handles any message
+        ethDeposit.to = address(to);
+    }
+
+    function test_DepositRecipientIsNotMessageRelayer_relayMessage_shouldInvokeRecipient() public {
+        vm.expectEmit();
+        emit GenericRecipient.FunctionCalled();
+        _relayMessage();
+    }
+
+    function test_DepositRecipientIsNotMessageRelayer_relayMessage_shouldNotInvokeReceiveMessage() public {
+        vm.expectCall(address(messageRelayer), ethDeposit.data, 0);
+        _relayMessage();
+    }
+}
+
+abstract contract DepositRecipientIsMessageRelayer is InitialState {
+    function test_DepositRecipientIsMessageRelayer_relayMessage_shouldInvokeReceiveMessage() public {
+        vm.expectCall(address(messageRelayer), ethDeposit.data);
+        _relayMessage();
+    }
+
+    function test_DepositRecipientIsMessageRelayer_claimDeposit_shouldInvokeReceiveMessage() public {
+        vm.expectCall(address(messageRelayer), ethDeposit.data);
+        messageRelayer.ethBridge().claimDeposit(ethDeposit, height, proof);
+    }
+}

test/MessageRelayer/GenericRecipient.t.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+contract GenericRecipient {
+    bool private callWillSucceed = true;
+
+    error CallFailed();
+
+    event FunctionCalled();
+
+    function setSuccess(bool _callWillSucceed) external {
+        callWillSucceed = _callWillSucceed;
+    }
+
+    fallback() external payable {
+        _simulateFunctionCall();
+    }
+
+    receive() external payable {
+        _simulateFunctionCall();
+    }
+
+    function _simulateFunctionCall() internal {
+        require(callWillSucceed, CallFailed());
+        emit FunctionCalled();
+    }
+}

test/MessageRelayer/InitialState.t.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "forge-std/Test.sol";
+
+import {ETHBridge} from "src/protocol/ETHBridge.sol";
+import {IETHBridge} from "src/protocol/IETHBridge.sol";
+
+import {GenericRecipient} from "./GenericRecipient.t.sol";
+import {IMessageRelayer} from "src/protocol/IMessageRelayer.sol";
+import {MessageRelayer} from "src/protocol/taiko_alethia/MessageRelayer.sol";
+import {MockSignalService} from "test/mocks/MockSignalService.sol";
+
+abstract contract InitialState is Test {
+    MessageRelayer messageRelayer;
+
+    // Default message parameters
+    IETHBridge.ETHDeposit ethDeposit;
+    uint256 height = 0;
+    bytes proof = "0x";
+    GenericRecipient to;
+    uint256 amount = 2 ether;
+    uint256 tip = 0.1 ether;
+    GenericRecipient relayerSelectedTipRecipient;
+    GenericRecipient userSelectedTipRecipient;
+    uint256 gasLimit = 0;
+    bytes data = "0x";
+
+    function setUp() public virtual {
+        MockSignalService signalService = new MockSignalService();
+        address trustedCommitmentPublisher = _randomAddress("trustedCommitmentPublisher");
+        address counterpart = _randomAddress("counterpart");
+        to = new GenericRecipient();
+        relayerSelectedTipRecipient = new GenericRecipient();
+        userSelectedTipRecipient = new GenericRecipient();
+        ETHBridge bridge = new ETHBridge(address(signalService), trustedCommitmentPublisher, counterpart);
+        vm.deal(address(bridge), amount);
+
+        messageRelayer = new MessageRelayer(address(bridge));
+
+        ethDeposit = IETHBridge.ETHDeposit({
+            nonce: 0,
+            from: _randomAddress("from"),
+            to: address(messageRelayer),
+            amount: 2 ether,
+            data: "",
+            context: "",
+            canceler: address(0)
+        });
+        _encodeReceiveCall();
+    }
+
+    function _encodeReceiveCall() internal {
+        ethDeposit.data = abi.encodeCall(
+            IMessageRelayer.receiveMessage, (address(to), tip, address(userSelectedTipRecipient), gasLimit, data)
+        );
+    }
+
+    function _relayMessage() internal {
+        messageRelayer.relayMessage(ethDeposit, height, proof, address(relayerSelectedTipRecipient));
+    }
+
+    function _randomAddress(string memory name) internal pure returns (address) {
+        return address(uint160(uint256(keccak256(abi.encode(_domainSeparator(), name)))));
+    }
+
+    function _domainSeparator() internal pure returns (bytes32) {
+        return keccak256("MessageRelayer");
+    }
+}

test/MessageRelayer/TipRecipientScenarios.t.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {DepositRecipientIsMessageRelayer} from "./DepositRecipientScenarios.t.sol";
+import {GenericRecipient} from "./GenericRecipient.t.sol";
+
+import {InitialState} from "./InitialState.t.sol";
+import {IETHBridge} from "src/protocol/IETHBridge.sol";
+
+contract UserSetValidTipRecipient is DepositRecipientIsMessageRelayer {
+    function test_UserSetValidTipRecipient_relayMessage_shouldTipUserSelectedRecipient() public {
+        uint256 balanceBefore = address(userSelectedTipRecipient).balance;
+        _relayMessage();
+        assertEq(address(userSelectedTipRecipient).balance, balanceBefore + tip, "tip recipient balance mismatch");
+    }
+
+    function test_UserSetValidTipRecipient_relayMessage_shouldNotTipRelayerSelectedRecipient() public {
+        uint256 balanceBefore = address(relayerSelectedTipRecipient).balance;
+        _relayMessage();
+        assertEq(address(relayerSelectedTipRecipient).balance, balanceBefore, "incorrect tip recipient paid");
+    }
+}
+
+contract UserSetZeroTipRecipient is DepositRecipientIsMessageRelayer {
+    function setUp() public override {
+        super.setUp();
+        userSelectedTipRecipient = GenericRecipient(payable(0));
+        _encodeReceiveCall();
+    }
+
+    function test_UserSetZeroTipRecipient_relayMessage_shouldTipRelayerSelectedRecipient() public {
+        uint256 balanceBefore = address(relayerSelectedTipRecipient).balance;
+        _relayMessage();
+        assertEq(address(relayerSelectedTipRecipient).balance, balanceBefore + tip, "tip recipient balance mismatch");
+    }
+}
+
+// We bypass the `DepositRecipientIsMessageRelayer` because it seems vm.expectCall requires the call to succeed
+contract UserSetInvalidTipRecipient is InitialState {
+    function setUp() public override {
+        super.setUp();
+        userSelectedTipRecipient.setSuccess(false);
+    }
+
+    function test_UserSetInvalidTipRecipient_relayMessage_shouldRevert() public {
+        vm.expectRevert(IETHBridge.FailedClaim.selector);
+        _relayMessage();
+    }
+}

test/mocks/MockSignalService.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ISignalService} from "src/protocol/ISignalService.sol";
+
+contract MockSignalService is ISignalService {
+    error NotImplemented();
+
+    function sendSignal(bytes32) external pure returns (bytes32) {
+        revert NotImplemented();
+    }
+
+    function isSignalStored(bytes32, address) external pure returns (bool) {
+        revert NotImplemented();
+    }
+
+    // verification always succeeds
+    function verifySignal(
+        uint256, /* height */
+        address, /* commitmentPublisher */
+        address, /* sender */
+        bytes32, /* value */
+        bytes memory /* proof */
+    ) external view {}
+}