feat(gateway): add and use feeForJuror param by governor

shalzz · shalzz · commit 7a1188fe8a7c · 2022-01-24T12:07:21.000+05:30
diff --git a/contracts/src/gateway/BaseForeignGateway.sol b/contracts/src/gateway/BaseForeignGateway.sol
@@ -17,14 +17,15 @@ import "./interfaces/IHomeGateway.sol";
 import "./interfaces/IForeignGateway.sol";
 
 abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
+    // The global default minimum number of jurors in a dispute.
+    uint256 public constant MIN_JURORS = 3;
+
     // @dev Note the disputeID needs to start from one as
     // the KlerosV1 proxy governor depends on this implementation.
     uint256 internal localDisputeID = 1;
 
-    // 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;
+    // feeForJuror by subcourtID
+    uint256[] internal feeForJuror;
 
     struct DisputeData {
         uint256 id;
@@ -38,15 +39,26 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
 
     IHomeGateway public homeGateway;
     uint256 public chainID;
+    address public governor;
 
     modifier onlyFromL2() {
         onlyAuthorized();
         _;
     }
 
-    constructor(uint256 _arbitrationCost, IHomeGateway _homeGateway) {
-        internalArbitrationCost = _arbitrationCost;
+    modifier onlyByGovernor() {
+        require(governor == msg.sender, "Access not allowed: Governor only.");
+        _;
+    }
+
+    constructor(
+        address _governor,
+        IHomeGateway _homeGateway,
+        uint256[] memory _feeForJuror
+    ) {
+        governor = _governor;
         homeGateway = _homeGateway;
+        feeForJuror = _feeForJuror;
 
         uint256 id;
         assembly {
@@ -55,9 +67,20 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
         chainID = id;
     }
 
+    /** @dev Changes the `feeForJuror` property value of a specified subcourt.
+     *  @param _subcourtID The ID of the subcourt.
+     *  @param _feeForJuror The new value for the `feeForJuror` property value.
+     */
+    function changeSubcourtJurorFee(uint96 _subcourtID, uint256 _feeForJuror) external onlyByGovernor {
+        feeForJuror[_subcourtID] = _feeForJuror;
+    }
+
     function createDispute(uint256 _choices, bytes calldata _extraData) external payable returns (uint256 disputeID) {
         require(msg.value >= arbitrationCost(_extraData), "Not paid enough for arbitration");
 
+        (uint96 subcourtID, ) = extraDataToSubcourtIDMinJurors(_extraData);
+        uint256 nbVotes = msg.value / feeForJuror[subcourtID];
+
         disputeID = localDisputeID++;
         bytes32 disputeHash = keccak256(
             abi.encodePacked(
@@ -71,6 +94,7 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
             )
         );
         disputeIDtoHash[disputeID] = disputeHash;
+
         disputeHashtoDisputeData[disputeHash] = DisputeData({
             id: disputeID,
             arbitrable: msg.sender,
@@ -80,7 +104,13 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
         });
 
         bytes4 methodSelector = IHomeGateway.relayCreateDispute.selector;
-        bytes memory data = abi.encodeWithSelector(methodSelector, disputeHash, _choices, _extraData);
+        bytes memory data = abi.encodeWithSelector(
+            methodSelector,
+            disputeHash,
+            _choices,
+            _extraData,
+            nbVotes * feeForJuror[subcourtID] // we calculate the min amount required for nbVotes
+        );
 
         // We only pay for the submissionPrice gas cost
         // which is minimum gas cost required for submitting a
@@ -100,16 +130,19 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
     }
 
     function arbitrationCost(bytes calldata _extraData) public view returns (uint256 cost) {
+        (uint96 subcourtID, uint256 minJurors) = extraDataToSubcourtIDMinJurors(_extraData);
+
         // 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 + bytes32 disputeHash + uint256 _choices + bytes _extraData)
-        //   4      +      4            +   32                +   32             + dynamic
-        uint256 calldatasize = 82 + _extraData.length;
+        // relayCreateDispute methodId + bytes32 disputeHash + uint256 _choices + bytes _extraData + uint256 _arbitrationCost)
+        //                  4          +   32                +   32             + dynamic          +  32
+        uint256 calldatasize = 100 + _extraData.length;
 
         uint256 bridgeCost = getSubmissionPrice(calldatasize);
-        return bridgeCost + internalArbitrationCost;
+        uint256 arbCost = feeForJuror[subcourtID] * minJurors;
+
+        return bridgeCost + arbCost;
     }
 
     /**
@@ -157,4 +190,24 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway {
     function homeBridge(uint256 _disputeID) external view returns (address) {
         return address(homeGateway);
     }
+
+    function extraDataToSubcourtIDMinJurors(bytes memory _extraData)
+        internal
+        view
+        returns (uint96 subcourtID, uint256 minJurors)
+    {
+        // Note that here we ignore DisputeKitID
+        if (_extraData.length >= 64) {
+            assembly {
+                // solium-disable-line security/no-inline-assembly
+                subcourtID := mload(add(_extraData, 0x20))
+                minJurors := mload(add(_extraData, 0x40))
+            }
+            if (subcourtID >= feeForJuror.length) subcourtID = 0;
+            if (minJurors == 0) minJurors = MIN_JURORS;
+        } else {
+            subcourtID = 0;
+            minJurors = MIN_JURORS;
+        }
+    }
 }
diff --git a/contracts/src/gateway/BaseHomeGateway.sol b/contracts/src/gateway/BaseHomeGateway.sol
@@ -27,7 +27,7 @@ abstract contract BaseHomeGateway is IL2Bridge, IHomeGateway {
     struct RelayedData {
         uint256 choices;
         bytes extraData;
-        uint256 numOfJurors;
+        uint256 arbitrationCost;
         address forwarder;
     }
     mapping(bytes32 => RelayedData) public disputeHashtoRelayedData;
@@ -63,28 +63,33 @@ abstract contract BaseHomeGateway is IL2Bridge, IHomeGateway {
     }
 
     /**
-     * Relay the createDispute call from the foreign gateway to the arbitrator.
+     * @dev Relay the createDispute call from the foreign gateway to the arbitrator.
+     *
+     * @param _disputeHash disputeHash
+     * @param _choices number of ruling choices
+     * @param _extraData extraData
+     * @param _arbitrationCost We get the actual arbitrationCost paid by the
+     *          arbitrable here in case they paid more than the min arbitrationCost
      */
     function relayCreateDispute(
         bytes32 _disputeHash,
         uint256 _choices,
         bytes calldata _extraData,
-        uint256 _numOfJurors
+        uint256 _arbitrationCost
     ) external onlyFromL1 {
         RelayedData storage relayedData = disputeHashtoRelayedData[_disputeHash];
         relayedData.choices = _choices;
         relayedData.extraData = _extraData;
-        relayedData.numOfJurors = _numOfJurors;
+        relayedData.arbitrationCost = _arbitrationCost;
     }
 
     function forwardCreateDispute(bytes32 _disputeHash) external payable {
         RelayedData storage relayedData = disputeHashtoRelayedData[_disputeHash];
+        require(relayedData.forwarder == address(0), "Dispute already forwarded");
 
-        // TODO: Account for numOfJurors instead of just minJurors
-        uint256 cost = arbitrator.arbitrationCost(relayedData.extraData);
-        require(msg.value >= cost, "Not enough arbitration cost paid");
+        require(msg.value >= relayedData.arbitrationCost, "Not enough arbitration cost paid");
 
-        uint256 disputeID = arbitrator.createDispute{value: cost}(relayedData.choices, relayedData.extraData);
+        uint256 disputeID = arbitrator.createDispute{value: msg.value}(relayedData.choices, relayedData.extraData);
         disputeIDtoHash[disputeID] = _disputeHash;
         disputeHashtoID[_disputeHash] = disputeID;
         relayedData.forwarder = msg.sender;
diff --git a/contracts/src/gateway/arbitrum/EthereumGateway.sol b/contracts/src/gateway/arbitrum/EthereumGateway.sol
@@ -9,9 +9,10 @@ import "../BaseForeignGateway.sol";
 
 contract EthereumGateway is BaseForeignGateway, ArbL1Bridge {
     constructor(
-        uint256 _arbitrationCost,
+        address _governor,
         IHomeGateway _homeGateway,
+        uint256[] memory _feeForJuror,
         address _l2Target,
         address _inbox
-    ) BaseForeignGateway(_arbitrationCost, _homeGateway) ArbL1Bridge(_l2Target, _inbox) {}
+    ) BaseForeignGateway(_governor, _homeGateway, _feeForJuror) ArbL1Bridge(_l2Target, _inbox) {}
 }
diff --git a/contracts/src/gateway/xdai/EthereumGateway.sol b/contracts/src/gateway/xdai/EthereumGateway.sol
@@ -10,9 +10,10 @@ import "../BaseForeignGateway.sol";
 
 contract EthereumGateway is BaseForeignGateway, xDaiL1Bridge {
     constructor(
-        uint256 _arbitrationCost,
+        address _governor,
         IHomeGateway _homeGateway,
+        uint256[] memory _feeForJuror,
         address _l2Target,
         IAMB _amb
-    ) BaseForeignGateway(_arbitrationCost, _homeGateway) xDaiL1Bridge(_l2Target, _amb) {}
+    ) BaseForeignGateway(_governor, _homeGateway, _feeForJuror) xDaiL1Bridge(_l2Target, _amb) {}
 }
