feat(FastBridge): unhappy path introducing a ticketID

Author: jaybuidl

contracts/deploy/02-home-chain.ts

@@ -42,7 +42,7 @@ const deployHomeGateway: DeployFunction = async (hre: HardhatRuntimeEnvironment)
     .getContractAt("FastBridgeSenderToEthereum", fastBridgeSender.address)
     .then((contract) => contract.fastSender());
   if (fastSender === ethers.constants.AddressZero) {
-    await execute("FastBridgeSenderToEthereum", { from: deployer, log: true }, "setFastSender", homeGateway.address);
+    await execute("FastBridgeSenderToEthereum", { from: deployer, log: true }, "changeFastSender", homeGateway.address);
   }
 };
 

contracts/src/bridge/FastBridgeReceiverOnEthereum.sol

@@ -23,18 +23,24 @@ contract FastBridgeReceiverOnEthereum is SafeBridgeReceiverOnEthereum, IFastBrid
     // ************************************* //
 
     struct Claim {
+        bytes32 messageHash;
         address bridger;
         uint256 claimedAt;
         uint256 claimDeposit;
-        bool relayed;
+        bool verified;
     }
 
     struct Challenge {
         address challenger;
         uint256 challengedAt;
         uint256 challengeDeposit;
+    }
+
+    struct Ticket {
+        Claim claim;
+        Challenge challenge;
         bool relayed;
-    }    
+    }
 
     // ************************************* //
     // *             Storage               * //
@@ -43,129 +49,135 @@ contract FastBridgeReceiverOnEthereum is SafeBridgeReceiverOnEthereum, IFastBrid
     uint256 public override claimDeposit;
     uint256 public override challengeDeposit;
     uint256 public override challengeDuration;
-    uint256 public override safeBridgeTimeout;
-    mapping(bytes32 => Claim) public claims; // The claims by message hash.
-    mapping(bytes32 => Challenge) public challenges; // The challenges by message hash.
+    mapping(uint256 => Ticket) public tickets; // The tickets by ticketID.
 
     // ************************************* //
     // *              Events               * //
     // ************************************* //
 
-    event ClaimReceived(bytes32 indexed messageHash, uint256 claimedAt);
-    event ClaimChallenged(bytes32 indexed _messageHash, uint256 challengedAt);
+    event ClaimReceived(uint256 indexed _ticketID, bytes32 indexed messageHash, uint256 claimedAt);
+    event ClaimChallenged(uint256 indexed _ticketID, bytes32 indexed _messageHash, uint256 challengedAt);
 
     constructor(
         address _governor,
         address _safeBridgeSender,
         address _inbox,
         uint256 _claimDeposit,
         uint256 _challengeDeposit,
-        uint256 _challengeDuration,
-        uint256 _safeBridgeTimeout
+        uint256 _challengeDuration
     ) SafeBridgeReceiverOnEthereum(_governor, _safeBridgeSender, _inbox) {
         claimDeposit = _claimDeposit;
         challengeDeposit = _challengeDeposit;
         challengeDuration = _challengeDuration;
-        safeBridgeTimeout - _safeBridgeTimeout;
     }
 
     // ************************************* //
     // *         State Modifiers           * //
     // ************************************* //
 
-    function claim(bytes32 _messageHash) external payable override {
+    function claim(uint256 _ticketID, bytes32 _messageHash) external payable override {
         require(msg.value >= claimDeposit, "Not enough claim deposit");
-        require(claims[_messageHash].bridger == address(0), "Claimed already made");
+        require(tickets[_ticketID].claim.bridger == address(0), "Claim already made");
 
-        claims[_messageHash] = Claim({
+        tickets[_ticketID].claim = Claim({
+            messageHash: _messageHash,
             bridger: msg.sender,
             claimedAt: block.timestamp,
             claimDeposit: msg.value,
-            relayed: false
+            verified: false
         });
 
-        emit ClaimReceived(_messageHash, block.timestamp);
+        emit ClaimReceived(_ticketID, _messageHash, block.timestamp);
     }
 
-    function challenge(bytes32 _messageHash) external payable override {
-        Claim memory claim = claims[_messageHash];
-        require(claim.bridger != address(0), "Claim does not exist");        
-        require(block.timestamp - claim.claimedAt <  challengeDuration, "Challenge period over");
+    function challenge(uint256 _ticketID) external payable override {
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.claim.bridger != address(0), "Claim does not exist");
+        require(block.timestamp - ticket.claim.claimedAt < challengeDuration, "Challenge period over");
         require(msg.value >= challengeDeposit, "Not enough challenge deposit");
-        require(challenges[_messageHash].challenger == address(0), "Claim already challenged");
+        require(ticket.challenge.challenger == address(0), "Claim already challenged");
 
-        challenges[_messageHash] = Challenge({
+        ticket.challenge = Challenge({
             challenger: msg.sender,
             challengedAt: block.timestamp,
-            challengeDeposit: msg.value,
-            relayed: false
+            challengeDeposit: msg.value
         });
 
-        emit ClaimChallenged(_messageHash, block.timestamp);
+        emit ClaimChallenged(_ticketID, ticket.claim.messageHash, block.timestamp);
     }
 
-    function verifyAndRelay(bytes32 _messageHash, bytes memory _encodedData) external override {
-        require(keccak256(_encodedData) == _messageHash, "Invalid hash");
-
-        Claim storage claim = claims[_messageHash];
-        require(claim.bridger != address(0), "Claim does not exist");
-        require(claim.claimedAt + challengeDuration < block.timestamp, "Challenge period not over");
-        require(claim.relayed == false, "Message already relayed");
-        require(challenges[_messageHash].challenger == address(0), "Claim is challenged");
-
-        // Decode the receiver address from the data encoded by the IFastBridgeSender
-        (address receiver, bytes memory data) = abi.decode(_encodedData, (address, bytes));
-        (bool success, ) = address(receiver).call(data);
-        require(success, "Failed to call contract");
-
-        claim.relayed = true;
+    function verifyAndRelay(
+        uint256 _ticketID,
+        bytes32 _messageHash,
+        bytes memory _messageData
+    ) external override {
+        require(_verify(_messageHash, _ticketID, _messageData), "Invalid hash");
+
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.claim.bridger != address(0), "Claim does not exist");
+        require(ticket.claim.claimedAt + challengeDuration < block.timestamp, "Challenge period not over");
+        require(ticket.challenge.challenger == address(0), "Claim is challenged");
+        require(ticket.relayed == false, "Message already relayed");
+
+        ticket.relayed = true;
+        require(_relay(_messageData), "Failed to call contract"); // Checks-Effects-Interaction
     }
 
-    function verifyAndRelaySafe(bytes32 _messageHash, bytes memory _encodedData) external override {
+    function verifyAndRelaySafe(
+        uint256 _ticketID,
+        bytes32 _messageHash,
+        bytes memory _messageData
+    ) external override {
         require(isSentBySafeBridge(), "Access not allowed: SafeBridgeSender only.");
+        require(_verify(_messageHash, _ticketID, _messageData), "Invalid hash");
 
-        Challenge storage challenge = challenges[_messageHash];
-        Claim storage claim = claims[_messageHash];
-        require(claim.relayed != true, "Claim already relayed");
-        require(challenge.relayed != true, "Challenge already relayed");
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.relayed == false, "Message already relayed");
 
-        // Decode the receiver address from the data encoded by the SafeBridgeSenderToEthereum
-        (address receiver, bytes memory data) = abi.decode(_encodedData, (address, bytes));
-        (bool success, ) = address(receiver).call(data);
-        require(success, "Failed to call contract");
+        // Claim assessment if any
+        if (ticket.claim.bridger != address(0) && ticket.claim.messageHash == _messageHash) {
+            ticket.claim.verified = true;
+        }
 
-        challenge.relayed == true;
+        ticket.relayed = true;
+        require(_relay(_messageData), "Failed to call contract"); // Checks-Effects-Interaction
     }
 
-    function withdrawClaimDeposit(bytes32 _messageHash) external override {
-        Claim storage claim = claims[_messageHash];
-        require(claim.bridger != address(0), "Claim does not exist");
-        require(claim.relayed == true, "Claim not relayed yet");
-
-        uint256 amount = claim.claimDeposit;
-        claim.claimDeposit = 0;
-        payable(claim.bridger).send(amount);
+    function withdrawClaimDeposit(uint256 _ticketID) external override {
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.relayed == true, "Message not relayed yet");
+        require(ticket.claim.bridger != address(0), "Claim does not exist");
+        require(ticket.claim.verified == true, "Claim not verified: deposit forfeited");
+
+        uint256 amount = ticket.claim.claimDeposit + ticket.challenge.challengeDeposit;
+        ticket.claim.claimDeposit = 0;
+        ticket.challenge.challengeDeposit = 0;
+        payable(ticket.claim.bridger).send(amount); // Use of send to prevent reverting fallback. User is responsibility for accepting ETH.
+        // Checks-Effects-Interaction
     }
 
-    function withdrawChallengeDeposit(bytes32 _messageHash) external override {
-        Challenge storage challenge = challenges[_messageHash];
-        require(challenge.challenger != address(0), "Challenge does not exist");
-        require(challenge.relayed == true || block.timestamp > challenge.challengedAt + safeBridgeTimeout, "Challenge not relayed or timed out");
-
-        uint256 amount = challenge.challengeDeposit + claims[_messageHash].claimDeposit;
-        challenge.challengeDeposit = 0;
-        payable(challenge.challenger).send(amount);
+    function withdrawChallengeDeposit(uint256 _ticketID) external override {
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.relayed == true, "Message not relayed");
+        require(ticket.challenge.challenger != address(0), "Challenge does not exist");
+        require(ticket.claim.verified == false, "Claim verified: deposit forfeited");
+
+        uint256 amount = ticket.claim.claimDeposit + ticket.challenge.challengeDeposit;
+        ticket.claim.claimDeposit = 0;
+        ticket.challenge.challengeDeposit = 0;
+        payable(ticket.challenge.challenger).send(amount); // Use of send to prevent reverting fallback. User is responsibility for accepting ETH.
+        // Checks-Effects-Interaction
     }
 
     // ************************************* //
     // *           Public Views            * //
     // ************************************* //
 
-    function challengePeriod(bytes32 _messageHash) public view returns (uint256 start, uint256 end) {
-        Claim storage claim = claims[_messageHash];
-        require(claim.bridger != address(0), "Claim does not exist");
+    function challengePeriod(uint256 _ticketID) public view returns (uint256 start, uint256 end) {
+        Ticket memory ticket = tickets[_ticketID];
+        require(ticket.claim.bridger != address(0), "Claim does not exist");
 
-        start = claim.claimedAt;
+        start = ticket.claim.claimedAt;
         end = start + challengeDuration;
         return (start, end);
     }
@@ -174,19 +186,33 @@ contract FastBridgeReceiverOnEthereum is SafeBridgeReceiverOnEthereum, IFastBrid
     // *      Governance      * //
     // ************************ //
 
-    function setClaimDeposit(uint256 _claimDeposit) external onlyByGovernor {
+    function changeClaimDeposit(uint256 _claimDeposit) external onlyByGovernor {
         claimDeposit = _claimDeposit;
     }
 
-    function setChallengeDeposit(uint256 _challengeDeposit) external onlyByGovernor {
+    function changeChallengeDeposit(uint256 _challengeDeposit) external onlyByGovernor {
         challengeDeposit = _challengeDeposit;
     }
 
-    function setChallengePeriodDuration(uint256 _challengeDuration) external onlyByGovernor {
+    function changeChallengePeriodDuration(uint256 _challengeDuration) external onlyByGovernor {
         challengeDuration = _challengeDuration;
     }
 
-    function setSafeBridgeTimeout(uint256 _safeBridgeTimeout) external onlyByGovernor {
-        safeBridgeTimeout = _safeBridgeTimeout;
+    // ************************ //
+    // *       Internal       * //
+    // ************************ //
+
+    function _verify(
+        bytes32 _expectedHash,
+        uint256 _ticketID,
+        bytes memory _messageData
+    ) internal pure returns (bool) {
+        return _expectedHash == keccak256(abi.encode(_ticketID, _messageData));
+    }
+
+    function _relay(bytes memory _messageData) internal returns (bool success) {
+        // Decode the receiver address from the data encoded by the IFastBridgeSender
+        (address receiver, bytes memory data) = abi.decode(_messageData, (address, bytes));
+        (success, ) = address(receiver).call(data);
     }
 }

contracts/src/bridge/FastBridgeSenderToEthereum.sol

@@ -26,6 +26,7 @@ contract FastBridgeSenderToEthereum is SafeBridgeSenderToEthereum, IFastBridgeSe
     address public governor;
     IFastBridgeReceiver public fastBridgeReceiver;
     address public fastSender;
+    uint256 public currentTicketID = 1; // Zero means not set, start at 1.
 
     // ************************************* //
     // *              Events               * //
@@ -35,7 +36,7 @@ contract FastBridgeSenderToEthereum is SafeBridgeSenderToEthereum, IFastBridgeSe
      * The bridgers need to watch for these events and
      * relay the messageHash on the FastBridgeReceiverOnEthereum.
      */
-    event OutgoingMessage(address indexed target, bytes32 indexed messageHash, bytes message);
+    event OutgoingMessage(uint256 indexed ticketID, address indexed target, bytes32 indexed messageHash, bytes message);
 
     // ************************************* //
     // *        Function Modifiers         * //
@@ -61,14 +62,14 @@ contract FastBridgeSenderToEthereum is SafeBridgeSenderToEthereum, IFastBridgeSe
      *
      * @param _receiver The L1 contract address who will receive the calldata
      * @param _calldata The receiving domain encoded message data.
+     * @return ticketID The identifier to provide to sendSafeFallback()
      */
-    function sendFast(address _receiver, bytes memory _calldata) external override {
+    function sendFast(address _receiver, bytes memory _calldata) external override returns (uint256 ticketID) {
         require(msg.sender == fastSender, "Access not allowed: Fast Sender only.");
 
-        // Encode the receiver address with the function signature + arguments i.e calldata
-        bytes memory messageData = abi.encode(_receiver, _calldata);
-
-        emit OutgoingMessage(_receiver, keccak256(messageData), messageData);
+        ticketID = currentTicketID++;
+        (bytes32 messageHash, bytes memory messageData) = _encode(ticketID, _receiver, _calldata);
+        emit OutgoingMessage(ticketID, _receiver, messageHash, messageData);
     }
 
     /**
@@ -80,15 +81,20 @@ contract FastBridgeSenderToEthereum is SafeBridgeSenderToEthereum, IFastBridgeSe
      * It may require some ETH (or whichever native token) to pay for the bridging cost,
      * depending on the underlying safe bridge.
      *
+     * @param _ticketID The ticketID as provided by `sendFast()` if any.
      * @param _receiver The L1 contract address who will receive the calldata
      * @param _calldata The receiving domain encoded message data.
      */
-    function sendSafeFallback(address _receiver, bytes memory _calldata) external payable override {
-        bytes memory messageData = abi.encode(_receiver, _calldata);
+    function sendSafeFallback(
+        uint256 _ticketID,
+        address _receiver,
+        bytes memory _calldata
+    ) external payable override {
+        (bytes32 messageHash, bytes memory messageData) = _encode(_ticketID, _receiver, _calldata);
 
         // Safe Bridge message envelope
         bytes4 methodSelector = IFastBridgeReceiver.verifyAndRelaySafe.selector;
-        bytes memory safeMessageData = abi.encodeWithSelector(methodSelector, keccak256(messageData), messageData);
+        bytes memory safeMessageData = abi.encodeWithSelector(methodSelector, _ticketID, messageHash, messageData);
 
         // TODO: how much ETH should be provided for bridging? add an ISafeBridgeSender.bridgingCost() if needed
         _sendSafe(address(fastBridgeReceiver), safeMessageData);
@@ -98,8 +104,24 @@ contract FastBridgeSenderToEthereum is SafeBridgeSenderToEthereum, IFastBridgeSe
     // *      Governance      * //
     // ************************ //
 
-    function setFastSender(address _fastSender) external onlyByGovernor {
+    function changeFastSender(address _fastSender) external onlyByGovernor {
         require(fastSender == address(0));
         fastSender = _fastSender;
     }
+
+    // ************************ //
+    // *       Internal       * //
+    // ************************ //
+
+    function _encode(
+        uint256 _ticketID,
+        address _receiver,
+        bytes memory _calldata
+    ) internal pure returns (bytes32 messageHash, bytes memory messageData) {
+        // Encode the receiver address with the function signature + arguments i.e calldata
+        messageData = abi.encode(_receiver, _calldata);
+
+        // Compute the hash over the message header (ticketID) and body (data).
+        messageHash = keccak256(abi.encode(_ticketID, messageData));
+    }
 }