feat(gateway): implement disputeID mapping

Author: shalzz

contracts/src/gateway/IForeignGateway.sol

@@ -7,8 +7,6 @@ import "../arbitration/IArbitrator.sol";
 interface IForeignGateway is IArbitrator {
     /**
      * Relay the rule call from the home gateway to the arbitrable.
-     *
-     * @param _data The calldata to relay
      */
-    function relayRule(bytes memory _data) external;
+    function relayRule(bytes32 _disputeHash, uint256 _ruling) external;
 }

contracts/src/gateway/IHomeGateway.sol

@@ -7,8 +7,10 @@ import "../arbitration/IArbitrable.sol";
 interface IHomeGateway is IArbitrable {
     /**
      * Relay the createDispute call from the foreign gateway to the arbitrator.
-     *
-     * @param _data The calldata to relay
      */
-    function relayCreateDispute(bytes memory _data) external;
+    function relayCreateDispute(
+        bytes32 _disputeHash,
+        uint256 _choices,
+        bytes calldata _extraData
+    ) external;
 }

contracts/src/gateway/arbitrum/ArbitrumGateway.sol

@@ -12,23 +12,24 @@ contract ArbitrumGateway is IHomeGateway {
     // L2 bridge with the ForeignGateway as the l1target
 
     L2Bridge internal l2bridge;
-    address public arbitrator;
+    IArbitrator public arbitrator;
+    mapping(uint256 => bytes32) disputeIDtoHash;
 
     modifier onlyFromL1() {
         l2bridge.onlyAuthorized(msg.sender);
         _;
     }
 
-    constructor(address _arbitrator, L2Bridge _l2bridge) {
+    constructor(IArbitrator _arbitrator, L2Bridge _l2bridge) {
         arbitrator = _arbitrator;
         l2bridge = _l2bridge;
     }
 
-    function rule(uint256, uint256) external {
-        require(msg.sender == arbitrator, "Only Arbitrator");
+    function rule(uint256 _disputeID, uint256 _ruling) external {
+        require(msg.sender == address(arbitrator), "Only Arbitrator");
 
         bytes4 methodSelector = IForeignGateway.relayRule.selector;
-        bytes memory data = abi.encodeWithSelector(methodSelector, msg.data);
+        bytes memory data = abi.encodeWithSelector(methodSelector, disputeIDtoHash[_disputeID], _ruling);
 
         l2bridge.sendCrossDomainMessage(data);
     }
@@ -37,13 +38,13 @@ contract ArbitrumGateway is IHomeGateway {
      * 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 onlyFromL1 {
-        // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = arbitrator.call(_data);
-        require(success, "Failed to call contract");
+    function relayCreateDispute(
+        bytes32 _disputeHash,
+        uint256 _choices,
+        bytes calldata _extraData
+    ) external onlyFromL1 {
+        uint256 disputeID = arbitrator.createDispute(_choices, _extraData);
+        disputeIDtoHash[disputeID] = _disputeHash;
     }
 }

contracts/src/gateway/arbitrum/EthereumGateway.sol

@@ -11,12 +11,20 @@ import "../IForeignGateway.sol";
 contract EthereumGateway is IForeignGateway {
     // L1 bridge with the HomeGateway as the l2target
     L1Bridge internal l1bridge;
+    uint256 localDisputeID;
+    uint256 chainID;
 
     // 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;
 
+    struct Dispute {
+        uint256 id;
+        address arbitrable;
+    }
+    mapping(bytes32 => Dispute) disputeHashtoDisputeData;
+
     modifier onlyFromL2() {
         l1bridge.onlyAuthorized(msg.sender);
         _;
@@ -25,13 +33,31 @@ contract EthereumGateway is IForeignGateway {
     constructor(uint256 _arbitrationCost, L1Bridge _l1bridge) {
         internalArbitrationCost = _arbitrationCost;
         l1bridge = _l1bridge;
+        uint256 id;
+        assembly {
+            id := chainid()
+        }
+        chainID = id;
     }
 
     function createDispute(uint256 _choices, bytes calldata _extraData) external payable returns (uint256 disputeID) {
         require(msg.value >= arbitrationCost(_extraData), "Not paid enough for arbitration");
 
+        disputeID = localDisputeID++;
+        bytes32 disputeHash = keccak256(
+            abi.encodePacked(
+                chainID,
+                blockhash(block.number - 1),
+                "createDispute",
+                disputeID,
+                arbitrationCost(_extraData),
+                _extraData
+            )
+        );
+        disputeHashtoDisputeData[disputeHash] = Dispute({id: disputeID, arbitrable: msg.sender});
+
         bytes4 methodSelector = IHomeGateway.relayCreateDispute.selector;
-        bytes memory data = abi.encodeWithSelector(methodSelector, msg.data);
+        bytes memory data = abi.encodeWithSelector(methodSelector, disputeHash, _choices, _extraData);
 
         uint256 bridgeCost = l1bridge.getSubmissionPrice(data.length);
         // We only pay for the submissionPrice gas cost
@@ -44,13 +70,11 @@ contract EthereumGateway is IForeignGateway {
         // 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,
+        // We do NOT forward the arbitrationCost ETH funds 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) {
@@ -68,14 +92,11 @@ contract EthereumGateway is IForeignGateway {
 
     /**
      * Relay the rule call from the home gateway to the arbitrable.
-     *
-     * @param _data The calldata to relay
      */
-    function relayRule(bytes memory _data) external onlyFromL2 {
-        address arbitrable = address(0); // see the TODO above about the disputeId
+    function relayRule(bytes32 _disputeHash, uint256 _ruling) external onlyFromL2 {
+        Dispute memory dispute = disputeHashtoDisputeData[_disputeHash];
 
-        // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = arbitrable.call(_data);
-        require(success, "Failed to call contract");
+        IArbitrable arbitrable = IArbitrable(dispute.arbitrable);
+        arbitrable.rule(dispute.id, _ruling);
     }
 }