feat(gateway): implement cross-chain evidence standard

Author: shalzz

contracts/src/gateway/IForeignEvidence.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IForeignEvidence {
+    function disputeID(uint256 _foreignDisputeID) external view returns (uint256);
+
+    function homeChainID(uint256 _disputeID) external view returns (uint256);
+
+    function homeBridge(uint256 _disputeID) external view returns (address);
+}

contracts/src/gateway/IForeignGateway.sol

@@ -5,6 +5,10 @@ pragma solidity ^0.8.0;
 import "../arbitration/IArbitrator.sol";
 
 interface IForeignGateway is IArbitrator {
+    function chainID() external view returns (uint256);
+
+    function foreignDisputeHashToID(bytes32 _disputeHash) external view returns (uint256);
+
     /**
      * Relay the rule call from the home gateway to the arbitrable.
      */

contracts/src/gateway/IHomeEvidence.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../evidence/IEvidence.sol";
+
+interface IHomeEvidence is IEvidence {
+    function homeToForeignDisputeID(uint256 _homeDisputeID) external view returns (uint256);
+
+    function foreignChainID(uint256 _homeDisputeID) external view returns (uint256);
+
+    function foreignBridge(uint256 _homeDisputeID) external view returns (address);
+}

contracts/src/gateway/IHomeGateway.sol

@@ -5,6 +5,10 @@ pragma solidity ^0.8.0;
 import "../arbitration/IArbitrable.sol";
 
 interface IHomeGateway is IArbitrable {
+    function chainID() external view returns (uint256);
+
+    function homeDisputeHashToID(bytes32 _disputeHash) external view returns (uint256);
+
     /**
      * Relay the createDispute call from the foreign gateway to the arbitrator.
      */

contracts/src/gateway/arbitrum/ArbitrumGateway.sol

@@ -8,21 +8,40 @@ import "../../bridge/arbitrum/L2Bridge.sol";
 import "../IHomeGateway.sol";
 import "../IForeignGateway.sol";
 
-contract ArbitrumGateway is IHomeGateway {
-    // L2 bridge with the ForeignGateway as the l1target
+import "../IHomeEvidence.sol";
 
+contract ArbitrumGateway is IHomeGateway, IHomeEvidence {
+    // L2 bridge with the ForeignGateway as the l1target
     L2Bridge internal l2bridge;
+
+    mapping(uint256 => bytes32) public disputeIDtoHash;
+    mapping(bytes32 => uint256) public disputeHashtoID;
+
+    IForeignGateway public foreignGateway;
     IArbitrator public arbitrator;
-    mapping(uint256 => bytes32) disputeIDtoHash;
+    uint256 public chainID;
 
     modifier onlyFromL1() {
         l2bridge.onlyAuthorized(msg.sender);
         _;
     }
 
-    constructor(IArbitrator _arbitrator, L2Bridge _l2bridge) {
+    constructor(
+        IArbitrator _arbitrator,
+        L2Bridge _l2bridge,
+        IForeignGateway _foreignGateway
+    ) {
         arbitrator = _arbitrator;
         l2bridge = _l2bridge;
+        foreignGateway = _foreignGateway;
+
+        uint256 id;
+        assembly {
+            id := chainid()
+        }
+        chainID = id;
+
+        emit MetaEvidence(0, "BRIDGE");
     }
 
     function rule(uint256 _disputeID, uint256 _ruling) external {
@@ -36,8 +55,6 @@ 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.
      */
     function relayCreateDispute(
         bytes32 _disputeHash,
@@ -46,5 +63,27 @@ contract ArbitrumGateway is IHomeGateway {
     ) external onlyFromL1 {
         uint256 disputeID = arbitrator.createDispute(_choices, _extraData);
         disputeIDtoHash[disputeID] = _disputeHash;
+        disputeHashtoID[_disputeHash] = disputeID;
+
+        emit Dispute(arbitrator, disputeID, 0, 0);
+    }
+
+    function homeDisputeHashToID(bytes32 _disputeHash) external view returns (uint256) {
+        return disputeHashtoID[_disputeHash];
+    }
+
+    function homeToForeignDisputeID(uint256 _homeDisputeID) external view returns (uint256) {
+        bytes32 disputeHash = disputeIDtoHash[_homeDisputeID];
+        require(disputeHash != 0, "Dispute does not exist");
+
+        return foreignGateway.foreignDisputeHashToID(disputeHash);
+    }
+
+    function foreignChainID(uint256 _homeDisputeID) external view returns (uint256) {
+        return foreignGateway.chainID();
+    }
+
+    function foreignBridge(uint256 _homeDisputeID) external view returns (address) {
+        return address(foreignGateway);
     }
 }

contracts/src/gateway/arbitrum/EthereumGateway.sol

@@ -8,31 +8,42 @@ import "../../bridge/arbitrum/L1Bridge.sol";
 import "../IHomeGateway.sol";
 import "../IForeignGateway.sol";
 
-contract EthereumGateway is IForeignGateway {
+import "../IForeignEvidence.sol";
+
+contract EthereumGateway is IForeignGateway, IForeignEvidence {
     // L1 bridge with the HomeGateway as the l2target
     L1Bridge internal l1bridge;
-    uint256 localDisputeID;
-    uint256 chainID;
+    uint256 internal localDisputeID;
 
     // 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 {
+    struct DisputeData {
         uint256 id;
         address arbitrable;
     }
-    mapping(bytes32 => Dispute) disputeHashtoDisputeData;
+    mapping(uint256 => bytes32) public disputeIDtoHash;
+    mapping(bytes32 => DisputeData) public disputeHashtoDisputeData;
+
+    IHomeGateway public homeGateway;
+    uint256 public chainID;
 
     modifier onlyFromL2() {
         l1bridge.onlyAuthorized(msg.sender);
         _;
     }
 
-    constructor(uint256 _arbitrationCost, L1Bridge _l1bridge) {
+    constructor(
+        uint256 _arbitrationCost,
+        L1Bridge _l1bridge,
+        IHomeGateway _homeGateway
+    ) {
         internalArbitrationCost = _arbitrationCost;
         l1bridge = _l1bridge;
+        homeGateway = _homeGateway;
+
         uint256 id;
         assembly {
             id := chainid()
@@ -54,7 +65,8 @@ contract EthereumGateway is IForeignGateway {
                 _extraData
             )
         );
-        disputeHashtoDisputeData[disputeHash] = Dispute({id: disputeID, arbitrable: msg.sender});
+        disputeIDtoHash[disputeID] = disputeHash;
+        disputeHashtoDisputeData[disputeHash] = DisputeData({id: disputeID, arbitrable: msg.sender});
 
         bytes4 methodSelector = IHomeGateway.relayCreateDispute.selector;
         bytes memory data = abi.encodeWithSelector(methodSelector, disputeHash, _choices, _extraData);
@@ -94,9 +106,28 @@ contract EthereumGateway is IForeignGateway {
      * Relay the rule call from the home gateway to the arbitrable.
      */
     function relayRule(bytes32 _disputeHash, uint256 _ruling) external onlyFromL2 {
-        Dispute memory dispute = disputeHashtoDisputeData[_disputeHash];
+        DisputeData memory dispute = disputeHashtoDisputeData[_disputeHash];
 
         IArbitrable arbitrable = IArbitrable(dispute.arbitrable);
         arbitrable.rule(dispute.id, _ruling);
     }
+
+    function foreignDisputeHashToID(bytes32 _disputeHash) external view returns (uint256) {
+        return disputeHashtoDisputeData[_disputeHash].id;
+    }
+
+    function disputeID(uint256 _foreignDisputeID) external view returns (uint256) {
+        bytes32 disputeHash = disputeIDtoHash[_foreignDisputeID];
+        require(disputeHash != 0, "Dispute does not exist");
+
+        return homeGateway.homeDisputeHashToID(disputeHash);
+    }
+
+    function homeChainID(uint256 _disputeID) external view returns (uint256) {
+        return homeGateway.chainID();
+    }
+
+    function homeBridge(uint256 _disputeID) external view returns (address) {
+        return address(homeGateway);
+    }
 }