feat(arbitrum): add gateway contracts

Author: shalzz

contracts/src/bridge/arbitrum/L1Bridge.sol

@@ -39,7 +39,7 @@ contract L1Bridge {
         uint256 _maxGas,
         uint256 _gasPriceBid
     ) external payable returns (uint256) {
-        (uint256 baseSubmissionCost, ) = arbRetryableTx.getSubmissionPrice(_calldata.length);
+        uint256 baseSubmissionCost = getSubmissionPrice(_calldata.length);
 
         uint256 ticketID = inbox.createRetryableTicket{value: msg.value}(
             l2Target,
@@ -55,4 +55,9 @@ contract L1Bridge {
         emit RetryableTicketCreated(ticketID);
         return ticketID;
     }
+
+    function getSubmissionPrice(uint256 _calldatasize) public view returns (uint256) {
+        (uint256 submissionCost, ) = arbRetryableTx.getSubmissionPrice(_calldatasize);
+        return submissionCost;
+    }
 }

contracts/src/bridge/arbitrum/L2Bridge.sol

@@ -20,7 +20,7 @@ contract L2Bridge {
      * @param _calldata The L1 encoded message data.
      * @return Unique id to track the message request/transaction.
      */
-    function sendCrossDomainMessage(bytes memory _calldata) external payable returns (uint256) {
+    function sendCrossDomainMessage(bytes memory _calldata) external returns (uint256) {
         uint256 withdrawalId = arbsys.sendTxToL1(l1Target, _calldata);
 
         emit L2ToL1TxCreated(withdrawalId);

contracts/src/gateway/arbitrum/ForeignGateway.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../../arbitration/IArbitrable.sol";
+import "../../arbitration/IArbitrator.sol";
+import "../../bridge/arbitrum/L1Bridge.sol";
+
+import "./HomeGateway.sol";
+
+contract ForeignGateway is IArbitrator {
+    // L1 bridge with the HomeGateway as the l2target
+    L1Bridge internal l1bridge;
+
+    // For now this is just a constant, but we'd probably need to
+    // implement the same arbitrationCost calculation code we'll have
+    // in the V2 court.
+    uint256 internal internalArbitrationCost;
+
+    constructor(uint256 _arbitrationCost, L1Bridge _l1bridge) {
+        internalArbitrationCost = _arbitrationCost;
+        l1bridge = _l1bridge;
+    }
+
+    function createDispute(uint256 _choices, bytes calldata _extraData) external payable returns (uint256 disputeID) {
+        require(msg.value >= arbitrationCost(_extraData), "Not paid enough for arbitration");
+
+        bytes4 methodSelector = HomeGateway.relayCreateDispute.selector;
+        bytes memory data = abi.encodeWithSelector(methodSelector, msg.data);
+
+        uint256 bridgeCost = l1bridge.getSubmissionPrice(data.length);
+        // We only pay for the submissionPrice gas cost
+        // which is minimum gas cost required for submitting a
+        // arbitrum retryable ticket to the retry buffer for
+        // bridge to L2.
+        // For immediate inclusion a user/bot needs to pay (GasPrice x MaxGas)
+        // with the associated ticketId that is emitted by this function
+        // after the ticket is successfully submitted.
+        // For more details, see:
+        // https://developer.offchainlabs.com/docs/l1_l2_messages#retryable-tickets-contract-api
+        //
+        // We do NOT forward the arbitrationCost to the HomeGateway yet,
+        // only the calldata.
+        l1bridge.sendCrossDomainMessage{value: bridgeCost}(data, 0, 0);
+
+        disputeId = 0; // TODO: map to the actual disputeID we get from the V2 court
+        emit DisputeCreation(disputeId, IArbitrable(msg.sender));
+        return disputeId;
+    }
+
+    function arbitrationCost(bytes calldata _extraData) public view returns (uint256 cost) {
+        // Calculate the size of calldata that will be passed to the L2 bridge
+        // as that is a factor for the bridging cost.
+        // Calldata size of relayCreateDispute:
+        // relayCreateDispute methodId +
+        //      (createDispute methodId + uint256 _choices + bytes _extraData)
+        //   4      +      4            +   32             + dynamic
+        uint256 calldatasize = 40 + _extraData.length;
+
+        uint256 bridgeCost = l1bridge.getSubmissionPrice(calldatasize);
+        return bridgeCost + internalArbitrationCost;
+    }
+
+    /**
+     * Relay the rule call from the home gateway to the arbitrable.
+     *
+     * @param _data The calldata to relay
+     */
+    function relayRule(bytes memory _data) external {
+        address arbitrable = address(0); // see the TODO above about the disputeId
+
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, ) = arbitrable.call(_data);
+        require(success, "Failed to call contract");
+    }
+}

contracts/src/gateway/arbitrum/HomeGateway.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../../arbitration/IArbitrable.sol";
+import "../../arbitration/IArbitrator.sol";
+import "../../bridge/arbitrum/L2Bridge.sol";
+
+import "./ForeignGateway.sol";
+
+contract HomeGateway is IArbitrable {
+    // L2 bridge with the ForeignGateway as the l1target
+    L2Bridge internal l2bridge;
+    address public arbitrator;
+
+    constructor(address _arbitrator, L2Bridge _l2bridge) {
+        arbitrator = _arbitrator;
+        l2bridge = _l2bridge;
+    }
+
+    function rule(uint256, uint256) external {
+        require(msg.sender == arbitrator, "Only Arbitrator");
+
+        bytes4 methodSelector = ForeignGateway.relayRule.selector;
+        bytes memory data = abi.encodeWithSelector(methodSelector, msg.data);
+
+        l2bridge.sendCrossDomainMessage(data);
+    }
+
+    /**
+     * Relay the createDispute call from the foreign gateway to the arbitrator.
+     *
+     * // TODO: Implement the evidence redirection from the Evidence v2 standard.
+     * // TODO: Return the actual disputeId from the court to the ForeignGateway
+     *          for it to maintain it's internal mapping.
+     * @param _data The calldata to relay
+     */
+    function relayCreateDispute(bytes memory _data) external {
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, ) = arbitrator.call(_data);
+        require(success, "Failed to call contract");
+    }
+}