refactor: better separation between v2, v1 ethereum and v1 xdai interfaces and libraries

Author: jaybuidl

contracts/deploy/00-home-chain-arbitration.ts

@@ -76,7 +76,7 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
     log: true,
   });
 
-  const sortitionSumTreeLibrary = await deploy("SortitionSumTreeFactory", {
+  const sortitionSumTreeLibrary = await deploy("SortitionSumTreeFactoryV2", {
     from: deployer,
     log: true,
   });
@@ -88,7 +88,7 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
   const klerosCore = await deploy("KlerosCore", {
     from: deployer,
     libraries: {
-      SortitionSumTreeFactory: sortitionSumTreeLibrary.address,
+      SortitionSumTreeFactoryV2: sortitionSumTreeLibrary.address,
     },
     args: [
       deployer,

contracts/src/arbitration/KlerosCore.sol

@@ -13,15 +13,15 @@ pragma solidity ^0.8;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./IArbitrator.sol";
 import "./IDisputeKit.sol";
-import {SortitionSumTreeFactory} from "../data-structures/SortitionSumTreeFactory.sol";
+import {SortitionSumTreeFactoryV2} from "../libraries/SortitionSumTreeFactoryV2.sol";
 
 /**
  *  @title KlerosCore
  *  Core arbitrator contract for Kleros v2.
  *  Note that this contract trusts the token and the dispute kit contracts.
  */
 contract KlerosCore is IArbitrator {
-    using SortitionSumTreeFactory for SortitionSumTreeFactory.SortitionSumTrees; // Use library functions for sortition sum trees.
+    using SortitionSumTreeFactoryV2 for SortitionSumTreeFactoryV2.SortitionSumTrees; // Use library functions for sortition sum trees.
 
     // ************************************* //
     // *         Enums / Structs           * //
@@ -120,7 +120,7 @@ contract KlerosCore is IArbitrator {
     uint256[] public disputesKitIDsThatNeedFreezing; // The disputeKitIDs that need switching to Freezing phase.
     Dispute[] public disputes; // The disputes.
     mapping(address => Juror) internal jurors; // The jurors.
-    SortitionSumTreeFactory.SortitionSumTrees internal sortitionSumTrees; // The sortition sum trees.
+    SortitionSumTreeFactoryV2.SortitionSumTrees internal sortitionSumTrees; // The sortition sum trees.
     mapping(uint256 => DelayedStake) public delayedStakes; // Stores the stakes that were changed during Freezing phase, to update them when the phase is switched to Staking.
 
     uint256 public delayedStakeWriteIndex; // The index of the last `delayedStake` item that was written to the array. 0 index is skipped.
@@ -1003,7 +1003,7 @@ contract KlerosCore is IArbitrator {
         bytes32 _key,
         uint256 _nodeIndex
     ) public view returns (uint256 K, uint256 length, bytes32 ID) {
-        SortitionSumTreeFactory.SortitionSumTree storage tree = sortitionSumTrees.sortitionSumTrees[_key];
+        SortitionSumTreeFactoryV2.SortitionSumTree storage tree = sortitionSumTrees.sortitionSumTrees[_key];
         K = tree.K;
         length = tree.nodes.length;
         ID = tree.nodeIndexesToIDs[_nodeIndex];

contracts/src/kleros-v1/ITokenController.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+
+/**
+ * @authors: [@ferittuncer, @hbarcelos, @clesaege]
+ * @reviewers: [@remedcu]
+ * @auditors: []
+ * @bounties: []
+ * @deployments: []
+ */
+pragma solidity ^0.8;
+
+import "./IArbitratorV1.sol";
+
+/**
+ * @title IArbitrable
+ * Arbitrable interface compliant with ERC-792.
+ * When developing arbitrable contracts, we need to:
+ * - Define the action taken when a ruling is received by the contract.
+ * - Allow dispute creation. For this a function must call arbitrator.createDispute{value: _fee}(_choices,_extraData);
+ */
+interface IArbitrableV1 {
+    /**
+     * @dev To be raised when a ruling is given.
+     * @param _arbitrator The arbitrator giving the ruling.
+     * @param _disputeID ID of the dispute in the Arbitrator contract.
+     * @param _ruling The ruling which was given.
+     */
+    event Ruling(IArbitratorV1 indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);
+
+    /**
+     * @dev Give a ruling for a dispute. Must be called by the arbitrator.
+     * The purpose of this function is to ensure that the address calling it has the right to rule on the contract.
+     * @param _disputeID ID of the dispute in the Arbitrator contract.
+     * @param _ruling Ruling given by the arbitrator. Note that 0 is reserved for "Not able/wanting to make a decision".
+     */
+    function rule(uint256 _disputeID, uint256 _ruling) external;
+}

contracts/src/kleros-v1/interfaces/IArbitrableV1.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+
+/**
+ * @authors: [@ferittuncer, @hbarcelos, @clesaege]
+ * @reviewers: [@remedcu]
+ * @auditors: []
+ * @bounties: []
+ * @deployments: []
+ */
+
+pragma solidity ^0.8.0;
+
+import "./IArbitrableV1.sol";
+
+/**
+ * @title Arbitrator
+ * Arbitrator abstract contract  compliant with ERC-792.
+ * When developing arbitrator contracts we need to:
+ * - Define the functions for dispute creation (createDispute) and appeal (appeal). Don't forget to store the arbitrated contract and the disputeID (which should be unique, may nbDisputes).
+ * - Define the functions for cost display (arbitrationCost and appealCost).
+ * - Allow giving rulings. For this a function must call arbitrable.rule(disputeID, ruling).
+ */
+interface IArbitratorV1 {
+    enum DisputeStatus {
+        Waiting,
+        Appealable,
+        Solved
+    }
+
+    /**
+     * @dev To be emitted when a dispute is created.
+     * @param _disputeID ID of the dispute.
+     * @param _arbitrable The contract which created the dispute.
+     */
+    event DisputeCreation(uint256 indexed _disputeID, IArbitrableV1 indexed _arbitrable);
+
+    /**
+     * @dev To be emitted when a dispute can be appealed.
+     * @param _disputeID ID of the dispute.
+     * @param _arbitrable The contract which created the dispute.
+     */
+    event AppealPossible(uint256 indexed _disputeID, IArbitrableV1 indexed _arbitrable);
+
+    /**
+     * @dev To be emitted when the current ruling is appealed.
+     * @param _disputeID ID of the dispute.
+     * @param _arbitrable The contract which created the dispute.
+     */
+    event AppealDecision(uint256 indexed _disputeID, IArbitrableV1 indexed _arbitrable);
+
+    /**
+     * @dev Create a dispute. Must be called by the arbitrable contract.
+     * Must be paid at least arbitrationCost(_extraData).
+     * @param _choices Amount of choices the arbitrator can make in this dispute.
+     * @param _extraData Can be used to give additional info on the dispute to be created.
+     * @return disputeID ID of the dispute created.
+     */
+    function createDispute(uint256 _choices, bytes calldata _extraData) external payable returns (uint256 disputeID);
+
+    /**
+     * @dev Compute the cost of arbitration. It is recommended not to increase it often, as it can be highly time and gas consuming for the arbitrated contracts to cope with fee augmentation.
+     * @param _extraData Can be used to give additional info on the dispute to be created.
+     * @return cost Amount to be paid.
+     */
+    function arbitrationCost(bytes calldata _extraData) external view returns (uint256 cost);
+
+    /**
+     * @dev Appeal a ruling. Note that it has to be called before the arbitrator contract calls rule.
+     * @param _disputeID ID of the dispute to be appealed.
+     * @param _extraData Can be used to give extra info on the appeal.
+     */
+    function appeal(uint256 _disputeID, bytes calldata _extraData) external payable;
+
+    /**
+     * @dev Compute the cost of appeal. It is recommended not to increase it often, as it can be higly time and gas consuming for the arbitrated contracts to cope with fee augmentation.
+     * @param _disputeID ID of the dispute to be appealed.
+     * @param _extraData Can be used to give additional info on the dispute to be created.
+     * @return cost Amount to be paid.
+     */
+    function appealCost(uint256 _disputeID, bytes calldata _extraData) external view returns (uint256 cost);
+
+    /**
+     * @dev Compute the start and end of the dispute's current or next appeal period, if possible. If not known or appeal is impossible: should return (0, 0).
+     * @param _disputeID ID of the dispute.
+     * @return start The start of the period.
+     * @return end The end of the period.
+     */
+    function appealPeriod(uint256 _disputeID) external view returns (uint256 start, uint256 end);
+
+    /**
+     * @dev Return the status of a dispute.
+     * @param _disputeID ID of the dispute to rule.
+     * @return status The status of the dispute.
+     */
+    function disputeStatus(uint256 _disputeID) external view returns (DisputeStatus status);
+
+    /**
+     * @dev Return the current ruling of a dispute. This is useful for parties to know if they should appeal.
+     * @param _disputeID ID of the dispute.
+     * @return ruling The ruling which has been given or the one which will be given if there is no appeal.
+     */
+    function currentRuling(uint256 _disputeID) external view returns (uint256 ruling);
+}

contracts/src/kleros-v1/interfaces/IArbitratorV1.sol

@@ -2,9 +2,9 @@
 
 pragma solidity ^0.8;
 
-import "../arbitration/IArbitrator.sol";
+import "./IArbitratorV1.sol";
 
-interface IKlerosLiquid is IArbitrator {
+interface IKlerosLiquid is IArbitratorV1 {
     enum Period {
         evidence, // Evidence can be submitted. This is also when drawing has to take place.
         commit, // Jurors commit a hashed vote. This is skipped for courts without hidden votes.
@@ -49,7 +49,9 @@ interface IKlerosLiquid is IArbitrator {
         uint256 lockedTokens; // The juror's total amount of tokens locked in disputes.
     }
 
-    function courts(uint256 _index)
+    function courts(
+        uint256 _index
+    )
         external
         view
         returns (
@@ -75,28 +77,18 @@ interface IKlerosLiquid is IArbitrator {
 
     function changeSubcourtTimesPerPeriod(uint96 _subcourtID, uint256[4] calldata _timesPerPeriod) external;
 
-    function executeGovernorProposal(
-        address _destination,
-        uint256 _amount,
-        bytes calldata _data
-    ) external;
+    function executeGovernorProposal(address _destination, uint256 _amount, bytes calldata _data) external;
 
     // Getters
     function getVote(
         uint256 _disputeID,
         uint256 _appeal,
         uint256 _voteID
-    )
-        external
-        view
-        returns (
-            address account,
-            bytes32 commit,
-            uint256 choice,
-            bool voted
-        );
+    ) external view returns (address account, bytes32 commit, uint256 choice, bool voted);
 
-    function getDispute(uint256 _disputeID)
+    function getDispute(
+        uint256 _disputeID
+    )
         external
         view
         returns (
@@ -108,8 +100,7 @@ interface IKlerosLiquid is IArbitrator {
             uint256[] memory penaltiesInEachRound
         );
 
-    function getSubcourt(uint96 _subcourtID)
-        external
-        view
-        returns (uint256[] memory children, uint256[4] memory timesPerPeriod);
+    function getSubcourt(
+        uint96 _subcourtID
+    ) external view returns (uint256[] memory children, uint256[4] memory timesPerPeriod);
 }

contracts/src/kleros-v1/IKlerosLiquid.sol renamed to contracts/src/kleros-v1/interfaces/IKlerosLiquid.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/**
+ * @dev The token controller contract must implement these functions. See https://github.com/Giveth/minime/blob/master/contracts/TokenController.sol
+ */
+interface ITokenController {
+    /**
+     * @notice Called when `_owner` sends ether to the MiniMe Token contract
+     * @param _owner The address that sent the ether to create tokens
+     * @return True if the ether is accepted, false if it throws
+     */
+    function proxyPayment(address _owner) external payable returns (bool);
+
+    /**
+     * @notice Notifies the controller about a token transfer allowing the controller to react if desired
+     * @param _from The origin of the transfer
+     * @param _to The destination of the transfer
+     * @param _amount The amount of the transfer
+     * @return False if the controller does not authorize the transfer
+     */
+    function onTransfer(address _from, address _to, uint256 _amount) external returns (bool);
+
+    /**
+     * @notice Notifies the controller about an approval allowing the controller to react if desired
+     * @param _owner The address that calls `approve()`
+     * @param _spender The spender in the `approve()` call
+     * @param _amount The amount in the `approve()` call
+     * @return False if the controller does not authorize the approval
+     */
+    function onApprove(address _owner, address _spender, uint256 _amount) external returns (bool);
+}