feat: notary for multiple native bridges

Author: ameeshaagrawal

src/accumulators/ArbitrumL1Accum.sol

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity 0.8.7;
 
-import "./BaseAccum.sol";
-import "../interfaces/INotary.sol";
-import "../interfaces/native-bridge/IArbSys.sol";
+import "../BaseAccum.sol";
+import "../../interfaces/INotary.sol";
 
-contract ArbitrumL2Accum is BaseAccum {
+abstract contract NativeBridgeAccum is BaseAccum {
     address public remoteNotary;
     uint256 public immutable _chainSlug;
 
-    IArbSys constant arbsys = IArbSys(address(100));
-
-    event L2ToL1TxCreated(uint256 indexed withdrawalId);
     event UpdatedNotary(address notary_);
 
     constructor(
@@ -23,12 +19,11 @@ contract ArbitrumL2Accum is BaseAccum {
         _chainSlug = chainSlug_;
     }
 
-    function setRemoteNotary(address notary_) external onlyOwner {
-        remoteNotary = notary_;
-        emit UpdatedNotary(notary_);
-    }
+    function sendL2Message(uint256[] calldata bridgeParams, bytes memory data)
+        internal
+        virtual;
 
-    function sealPacket(uint256[] calldata)
+    function sealPacket(uint256[] calldata bridgeParams)
         external
         payable
         override
@@ -41,33 +36,21 @@ contract ArbitrumL2Accum is BaseAccum {
     {
         uint256 packetId = _sealedPackets++;
         bytes32 root = _roots[packetId];
-
         if (root == bytes32(0)) revert NoPendingPacket();
+
         bytes memory data = abi.encodeWithSelector(
             INotary.attest.selector,
             _getPacketId(packetId),
             root,
             bytes("")
         );
 
-        uint256 withdrawalId = arbsys.sendTxToL1(remoteNotary, data);
+        sendL2Message(bridgeParams, data);
 
-        emit L2ToL1TxCreated(withdrawalId);
         emit PacketComplete(root, packetId);
         return (root, packetId, remoteChainSlug);
     }
 
-    function _getPacketId(uint256 packetCount_)
-        internal
-        view
-        returns (uint256 packetId)
-    {
-        packetId =
-            (_chainSlug << 224) |
-            (uint256(uint160(address(this))) << 64) |
-            packetCount_;
-    }
-
     function addPackedMessage(bytes32 packedMessage)
         external
         override
@@ -79,4 +62,20 @@ contract ArbitrumL2Accum is BaseAccum {
 
         emit MessageAdded(packedMessage, packetId, packedMessage);
     }
+
+    function setRemoteNotary(address notary_) external onlyOwner {
+        remoteNotary = notary_;
+        emit UpdatedNotary(notary_);
+    }
+
+    function _getPacketId(uint256 packetCount_)
+        internal
+        view
+        returns (uint256 packetId)
+    {
+        packetId =
+            (_chainSlug << 224) |
+            (uint256(uint160(address(this))) << 64) |
+            packetCount_;
+    }
 }

src/accumulators/ArbitrumL2Accum.sol renamed to src/accumulators/native-bridge/NativeBridgeAccum.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.7;
+
+import "../NativeBridgeAccum.sol";
+import "../../../interfaces/native-bridge/IInbox.sol";
+
+contract ArbitrumL1Accum is NativeBridgeAccum {
+    address public remoteRefundAddress;
+    address public callValueRefundAddress;
+    IInbox public inbox;
+
+    event RetryableTicketCreated(uint256 indexed ticketId);
+    event UpdatedInboxAddress(address inbox_);
+    event UpdatedRefundAddresses(
+        address remoteRefundAddress_,
+        address callValueRefundAddress_
+    );
+
+    constructor(
+        address socket_,
+        address notary_,
+        address inbox_,
+        uint32 remoteChainSlug_,
+        uint32 chainSlug_
+    ) NativeBridgeAccum(socket_, notary_, remoteChainSlug_, chainSlug_) {
+        inbox = IInbox(inbox_);
+        remoteRefundAddress = msg.sender;
+        callValueRefundAddress = msg.sender;
+    }
+
+    function sendL2Message(uint256[] calldata bridgeParams, bytes memory data)
+        internal
+        override
+    {
+        // to avoid stack too deep
+        address callValueRefund = callValueRefundAddress;
+        address remoteRefund = remoteRefundAddress;
+
+        uint256 ticketID = inbox.createRetryableTicket{value: msg.value}(
+            remoteNotary,
+            0, // no value needed for attest
+            bridgeParams[0], // maxSubmissionCost
+            remoteRefund,
+            callValueRefund,
+            bridgeParams[1], // maxGas
+            bridgeParams[2], // gasPriceBid
+            data
+        );
+        emit RetryableTicketCreated(ticketID);
+    }
+
+    function updateRefundAddresses(
+        address remoteRefundAddress_,
+        address callValueRefundAddress_
+    ) external onlyOwner {
+        remoteRefundAddress = remoteRefundAddress_;
+        callValueRefundAddress = callValueRefundAddress_;
+
+        emit UpdatedRefundAddresses(
+            remoteRefundAddress_,
+            callValueRefundAddress_
+        );
+    }
+
+    function updateInboxAddresses(address inbox_) external onlyOwner {
+        inbox = IInbox(inbox_);
+
+        emit UpdatedInboxAddress(inbox_);
+    }
+}

src/accumulators/native-bridge/arbitrum/ArbitrumL1Accum.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.7;
+
+import "../NativeBridgeAccum.sol";
+import "../../../interfaces/INotary.sol";
+import "../../../interfaces/native-bridge/IArbSys.sol";
+
+contract ArbitrumL2Accum is NativeBridgeAccum {
+    IArbSys constant arbsys = IArbSys(address(100));
+    event L2ToL1TxCreated(uint256 indexed withdrawalId);
+
+    constructor(
+        address socket_,
+        address notary_,
+        uint32 remoteChainSlug_,
+        uint32 chainSlug_
+    ) NativeBridgeAccum(socket_, notary_, remoteChainSlug_, chainSlug_) {}
+
+    function sendL2Message(uint256[] calldata, bytes memory data)
+        internal
+        override
+    {
+        uint256 withdrawalId = arbsys.sendTxToL1(remoteNotary, data);
+        emit L2ToL1TxCreated(withdrawalId);
+    }
+}

src/accumulators/native-bridge/arbitrum/ArbitrumL2Accum.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.7;
+
+/**
+ * @title ICrossDomainMessenger
+ */
+interface ICrossDomainMessenger {
+    /**********
+     * Events *
+     **********/
+
+    event SentMessage(
+        address indexed target,
+        address sender,
+        bytes message,
+        uint256 messageNonce,
+        uint256 gasLimit
+    );
+    event RelayedMessage(bytes32 indexed msgHash);
+    event FailedRelayedMessage(bytes32 indexed msgHash);
+
+    /*************
+     * Variables *
+     *************/
+
+    function xDomainMessageSender() external view returns (address);
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Sends a cross domain message to the target messenger.
+     * @param _target Target contract address.
+     * @param _message Message to send to the target.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function sendMessage(
+        address _target,
+        bytes calldata _message,
+        uint32 _gasLimit
+    ) external;
+}

src/interfaces/native-bridge/ICrossDomainMessenger.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.7;
+
+/**
+ * @title IFxMessageProcessor
+ * @notice Defines the interface to process message
+ */
+interface IFxMessageProcessor {
+    /**
+     * @notice Process the cross-chain message from a FxChild contract through the Ethereum/Polygon StateSender
+     * @param stateId The id of the cross-chain message created in the Ethereum/Polygon StateSender
+     * @param rootMessageSender The address that initially sent this message on Ethereum
+     * @param data The data from the abi-encoded cross-chain message
+     **/
+    function processMessageFromRoot(
+        uint256 stateId,
+        address rootMessageSender,
+        bytes calldata data
+    ) external;
+}