Merge pull request #552 from hats-finance/hat-arbitrator-deployment-s…

…cript

HATArbitrator deployment script

config.js

@@ -128,10 +128,26 @@ module.exports = {
             ],
             "rewardToken": "HATToken"
         }],
+        "hatArbitratorConf": {
+            "expertCommittee": "0x0000000000000000000000000000000000000001",
+            "token": "0x0000000000000000000000000000000000000002",
+            "bondsNeededToStartDispute": "1000000000000000000000",
+            "minBondAmount": "100000000000000000000",
+            "resolutionChallengePeriod": 60 * 60 * 24 * 7,
+            "submitClaimRequestReviewPeriod": 60 * 60 * 24 * 90,
+        },
+        "hatKlerosConnectorConf": {
+            "klerosArbitrator": "0x0000000000000000000000000000000000000003",
+            "arbitratorExtraData": "0x85",
+            "metaEvidence": "ipfs/X",
+            "winnerMultiplier": 3000,
+            "loserMultiplier": 7000
+        },
         "hatVaultsRegistryConf": {
             "bountyGovernanceHAT": "1000",
             "bountyHackerHATVested": "500",
-            "swapToken": "HATToken"
+            "swapToken": "HATToken",
+            "useKleros": false
         },
         "hatVaultsNFTConf": {
             "merkleTreeIPFSRef": "",

deploy/005_deploy_hatarbitrator.js

@@ -0,0 +1,51 @@
+const { network } = require("hardhat");
+const CONFIG = require("../config.js");
+
+const func = async function (hre) {
+    const config = CONFIG[network.name];
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy, execute, read } = deployments;
+
+    const { deployer } = await getNamedAccounts();
+
+    await deploy('HATArbitrator', {
+        from: deployer,
+        args: [
+            config.hatArbitratorConf.expertCommittee,
+            config.hatArbitratorConf.token,
+            config.hatArbitratorConf.bondsNeededToStartDispute,
+            config.hatArbitratorConf.minBondAmount,
+            config.hatArbitratorConf.resolutionChallengePeriod,
+            config.hatArbitratorConf.submitClaimRequestReviewPeriod
+        ],
+        log: true,
+    });
+
+    await deploy('HATKlerosConnector', {
+        from: deployer,
+        args: [
+            config.hatKlerosConnectorConf.klerosArbitrator,
+            config.hatKlerosConnectorConf.arbitratorExtraData,
+            (await deployments.get('HATArbitrator')).address,
+            config.hatKlerosConnectorConf.metaEvidence,
+            config.hatKlerosConnectorConf.winnerMultiplier,
+            config.hatKlerosConnectorConf.loserMultiplier
+        ],
+        log: true,
+    });
+
+    if((await read('HATArbitrator', {}, 'court')) !== (await deployments.get('HATKlerosConnector')).address) {
+        await execute('HATArbitrator', { from: deployer, log: true }, 'setCourt', (await deployments.get('HATKlerosConnector')).address);
+    }
+
+    if ((await read('HATArbitrator', {}, 'owner')) !== (await deployments.get('HATTimelockController')).address) {
+        await execute('HATArbitrator', { from: deployer, log: true }, 'transferOwnership', (await deployments.get('HATTimelockController')).address);
+    }
+
+    if ((await read('HATKlerosConnector', {}, 'owner')) !== (await deployments.get('HATTimelockController')).address) {
+        await execute('HATKlerosConnector', { from: deployer, log: true }, 'transferOwnership', (await deployments.get('HATTimelockController')).address);
+    }
+};
+
+module.exports = func;
+func.tags = ['HATArbitrator'];

deploy/008_deploy_hatvaultsregistry.js → deploy/009_deploy_hatvaultsregistry.js

@@ -11,6 +11,7 @@ const func = async function (hre) {
     let bountyGovernanceHAT = config.hatVaultsRegistryConf.bountyGovernanceHAT;
     let bountyHackerHATVested = config.hatVaultsRegistryConf.bountyHackerHATVested;
     let swapToken = config.hatVaultsRegistryConf.swapToken;
+    let useKleros = config.hatVaultsRegistryConf.useKleros;
     if (!swapToken || swapToken === "HATToken") {
         swapToken = (await deployments.get('HATToken')).address;  
     }
@@ -21,7 +22,7 @@ const func = async function (hre) {
             (await deployments.get('HATVault')).address,
             (await deployments.get('HATClaimsManager')).address,
             (await deployments.get('HATTimelockController')).address,
-            (await deployments.get('HATGovernanceArbitrator')).address,
+            useKleros ? (await deployments.get('HATArbitrator')).address : (await deployments.get('HATGovernanceArbitrator')).address,
             swapToken,
             bountyGovernanceHAT,
             bountyHackerHATVested,

deploy/011_verify_deployment.js → deploy/013_verify_deployment.js

@@ -178,6 +178,72 @@ const func = async function (hre) {
         "Arbitrator owner is the HATTimelockController"
     );
 
+    // Verify HATArbitrator
+    verify(
+        await read('HATArbitrator', {}, 'owner') === (await deployments.get('HATTimelockController')).address,
+        "Arbitrator owner is the HATTimelockController"
+    );
+
+    verify(
+        await read('HATArbitrator', {}, 'court') === (await deployments.get('HATKlerosConnector')).address,
+        "Arbitrator court is the HATKlerosConnector"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'expertCommittee')) === config.hatArbitratorConf.expertCommittee,
+        "HATArbitrator expert committee is correct (" + config.hatArbitratorConf.expertCommittee + ")"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'token')) === config.hatArbitratorConf.token,
+        "HATArbitrator token is correct (" + config.hatArbitratorConf.token + ")"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'bondsNeededToStartDispute')).toString() === config.hatArbitratorConf.bondsNeededToStartDispute.toString(),
+        "HATArbitrator bondsNeededToStartDispute is correct (" + config.hatArbitratorConf.bondsNeededToStartDispute + ")"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'minBondAmount')).toString() === config.hatArbitratorConf.minBondAmount.toString(),
+        "HATArbitrator minBondAmount is correct (" + config.hatArbitratorConf.minBondAmount + ")"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'resolutionChallengePeriod')).toString() === config.hatArbitratorConf.resolutionChallengePeriod.toString(),
+        "HATArbitrator resolutionChallengePeriod is correct (" + config.hatArbitratorConf.resolutionChallengePeriod + ")"
+    );
+
+    verify(
+        (await read('HATArbitrator', {}, 'submitClaimRequestReviewPeriod')).toString() === config.hatArbitratorConf.submitClaimRequestReviewPeriod.toString(),
+        "HATArbitrator submitClaimRequestReviewPeriod is correct (" + config.hatArbitratorConf.submitClaimRequestReviewPeriod + ")"
+    );
+
+    verify(
+        (await read('HATKlerosConnector', {}, 'klerosArbitrator')) === config.hatKlerosConnectorConf.klerosArbitrator,
+        "HATKlerosConnector kleros arbitrator is correct (" + config.hatKlerosConnectorConf.klerosArbitrator + ")"
+    );
+
+    verify(
+        (await read('HATKlerosConnector', {}, 'arbitratorExtraData')) === config.hatKlerosConnectorConf.arbitratorExtraData,
+        "HATKlerosConnector arbitratorExtraData is correct (" + config.hatKlerosConnectorConf.arbitratorExtraData + ")"
+    );
+
+    verify(
+        (await read('HATKlerosConnector', {}, 'hatArbitrator')) === (await deployments.get('HATArbitrator')).address,
+        "HATKlerosConnector hatArbitrator is HATArbitrator"
+    );
+
+    verify(
+        (await read('HATKlerosConnector', {}, 'winnerMultiplier')).toString() === config.hatKlerosConnectorConf.winnerMultiplier.toString(),
+        "HATKlerosConnector winnerMultiplier is correct (" + config.hatKlerosConnectorConf.winnerMultiplier + ")"
+    );
+
+    verify(
+        (await read('HATKlerosConnector', {}, 'loserMultiplier')).toString() === config.hatKlerosConnectorConf.loserMultiplier.toString(),
+        "HATKlerosConnector loserMultiplier is correct (" + config.hatKlerosConnectorConf.loserMultiplier + ")"
+    );
+
     // Verify Reward Controller
 
     // TODO: Verify reward controllers
@@ -187,6 +253,7 @@ const func = async function (hre) {
     let bountyGovernanceHAT = config["hatVaultsRegistryConf"]["bountyGovernanceHAT"];
     let bountyHackerHATVested = config["hatVaultsRegistryConf"]["bountyHackerHATVested"];
     let swapToken = config["hatVaultsRegistryConf"]["swapToken"];
+    let useKleros = config["hatVaultsRegistryConf"]["useKleros"];
     if (!swapToken || swapToken === "HATToken") {
         swapToken = (await deployments.get('HATToken')).address;  
     }
@@ -197,8 +264,8 @@ const func = async function (hre) {
     );
 
     verify(
-        await read('HATVaultsRegistry', {}, 'defaultArbitrator') === (await deployments.get('HATGovernanceArbitrator')).address,
-        "HATVaultsRegistry default arbitrator is the Arbitrator"
+        await read('HATVaultsRegistry', {}, 'defaultArbitrator') === (await deployments.get(useKleros ? 'HATArbitrator' : 'HATGovernanceArbitrator')).address,
+        "HATVaultsRegistry default arbitrator is the HATArbitrator"
     );
 
     verify(