Reputation improvements

.circleci/config.yml

@@ -68,7 +68,18 @@ jobs:
             sudo apt-get install lsof
       - run:
           name: "Running reputation system unit tests"
-          command: npm run test:reputation
+          command: npm run test:reputation:1
+          environment:
+            NODE_OPTIONS: --max-old-space-size=6144
+      - run:
+          name: "Reset chains"
+          command: |
+            sudo apt-get update
+            sudo apt-get install lsof
+            npm run stop:blockchain:client && rm -rf ganache-chain-db*
+      - run:
+          name: "Running reputation system unit tests"
+          command: npm run test:reputation:2
           environment:
             NODE_OPTIONS: --max-old-space-size=6144
       - run:
@@ -85,7 +96,7 @@ jobs:
       - <<: *step_setup_global_packages
       - run:
           name: "Download parity"
-          command: wget https://releases.parity.io/ethereum/v2.3.8/x86_64-unknown-linux-gnu/parity
+          command: wget https://releases.parity.io/ethereum/v2.7.2/x86_64-unknown-linux-gnu/parity
       - run:
           name: "Setup parity"
           command: |
@@ -308,7 +319,7 @@ jobs:
           command: |
             sudo apt-get update
             sudo apt-get install lsof
-            npm run stop:blockchain:client
+            npm run stop:blockchain:client && rm -rf ganache-chain-db*
       - run:
           name: "Running coverage tests for foreign-side of bridge"
           command: npm run test:contracts:bridging:2:coverage
@@ -326,7 +337,7 @@ jobs:
       - <<: *step_restore_cache
       - run:
           name: "Install packages"
-          command: | 
+          command: |
             sudo npm install -g npm@8.5.5
             npm ci
       - attach_workspace:

.solcover.chainid.js

@@ -4,5 +4,4 @@ config.providerOptions.network_id = parseInt(process.env.CHAIN_ID, 10);
 config.providerOptions._chainId = parseInt(process.env.CHAIN_ID, 10);
 config.providerOptions._chainIdRpc = parseInt(process.env.CHAIN_ID, 10);
 config.istanbulFolder = `./coverage-chainid-${process.env.CHAIN_ID}`
-
 module.exports = config

.solcover.crosschain.js

@@ -1,11 +1,28 @@
 const config = require("./.solcover.js")
 const log = console.log;
 const { execSync } = require("child_process");
+const ethers  = require("ethers");
+
+const { FORKED_XDAI_CHAINID } = require("./helpers/constants");
 
 const existingCompileComplete = config.onCompileComplete;
 
-config.istanbulFolder = `./coverage-cross-chain-${process.env.TRUFFLE_HOME ? "home" : "foreign"}`
+let chainId;
+// We configure the truffle coverage chain to have the same chainid as one of the
+// nodes we've started up, but on a different port
+// TODO: Actually query nodes, don't hard-code here, or work out how to get environment
+// variables in package.json to work here as I want.
+if (JSON.parse(process.env.TRUFFLE_FOREIGN)){
+  chainId = FORKED_XDAI_CHAINID + 1;
+} else {
+  chainId = FORKED_XDAI_CHAINID;
+}
+
+config.providerOptions.network_id = chainId;
+config.providerOptions._chainId = chainId;
+config.providerOptions._chainIdRpc = chainId;
 
+config.istanbulFolder = `./coverage-cross-chain-${JSON.parse(process.env.TRUFFLE_FOREIGN) ? "foreign" : "home"}`
 
 function provisionSafeContracts(){
   let output;

.solcover.js

@@ -4,13 +4,13 @@ const log = console.log;
 // Copies pre-built token artifacts to .coverage_artifacts/contracts
 function provisionTokenContracts(config){
   let output;
-  const provisionColonyToken = `BUILD_DIR="build-coverage" bash ./scripts/provision-token-contracts.sh`;
+  const provisionColonyToken = `BUILD_DIR="build-coverage" npm run provision:token:contracts`;
 
   log('Provisioning ColonyToken contracts...')
   output = execSync(provisionColonyToken);
   log(output.toString())
 
-  const provisionSafeContracts = `BUILD_DIR="build-coverage" bash ./scripts/provision-safe-contracts.sh`;
+  const provisionSafeContracts = `BUILD_DIR="build-coverage" npm run provision:safe:contracts`;
 
   log('Provisioning Safe contracts...')
   output = execSync(provisionSafeContracts);
@@ -33,6 +33,9 @@ module.exports = {
       account_keys_path: "./ganache-accounts.json",
       vmErrorsOnRPCResponse: false,
       total_accounts: 18,
+      _chainId: 265669100,
+      _chainIdRpc: 265669100,
+      network_id: 265669100,
       accounts: [
         {secretKey:"0x0355596cdb5e5242ad082c4fe3f8bbe48c9dba843fe1f99dd8272f487e70efae","balance":"100000000000000000000"},
         {secretKey:"0xe9aebe8791ad1ebd33211687e9c53f13fe8cca53b271a6529c7d7ba05eda5ce2","balance":"100000000000000000000"},
@@ -56,5 +59,5 @@ module.exports = {
     },
     onCompileComplete: provisionTokenContracts,
     istanbulFolder: "./coverage-contracts",
-    modifierWhitelist: ["always"],
+    modifierWhitelist: ["always", "onlyMiningChain", "onlyNotMiningChain"],
 }

contracts/colony/Colony.sol

@@ -48,7 +48,7 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
   {
     require(_amount > 0, "colony-reward-must-be-positive");
     require(domainExists(_domainId), "colony-domain-does-not-exist");
-    IColonyNetwork(colonyNetworkAddress).appendReputationUpdateLog(_user, _amount, domains[_domainId].skillId);
+    emitReputation(_user, _amount, domains[_domainId].skillId);
 
     emit ArbitraryReputationUpdate(msgSender(), _user, domains[_domainId].skillId, _amount);
   }
@@ -57,7 +57,7 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
   public stoppable auth validGlobalOrLocalSkill(_skillId)
   {
     require(_amount > 0, "colony-reward-must-be-positive");
-    IColonyNetwork(colonyNetworkAddress).appendReputationUpdateLog(_user, _amount, _skillId);
+    emitReputation(_user, _amount, _skillId);
 
     emit ArbitraryReputationUpdate(msgSender(), _user, _skillId, _amount);
   }
@@ -71,7 +71,7 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
   ) public stoppable authDomain(_permissionDomainId, _childSkillIndex, _domainId)
   {
     require(_amount <= 0, "colony-penalty-cannot-be-positive");
-    IColonyNetwork(colonyNetworkAddress).appendReputationUpdateLog(_user, _amount, domains[_domainId].skillId);
+    emitReputation(_user, _amount, domains[_domainId].skillId);
 
     emit ArbitraryReputationUpdate(msgSender(), _user, domains[_domainId].skillId, _amount);
   }
@@ -80,7 +80,7 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
   public stoppable auth validGlobalOrLocalSkill(_skillId)
   {
     require(_amount <= 0, "colony-penalty-cannot-be-positive");
-    IColonyNetwork(colonyNetworkAddress).appendReputationUpdateLog(_user, _amount, _skillId);
+    emitReputation(_user, _amount, _skillId);
 
     emit ArbitraryReputationUpdate(msgSender(), _user, _skillId, _amount);
   }
@@ -114,7 +114,9 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
     // After doing all the local storage changes, then do all the external calls
     for (uint256 i = 0; i < _users.length; i++) {
       require(ERC20Extended(token).transfer(_users[i], uint256(_amounts[i])), "colony-bootstrap-token-transfer-failed");
-      IColonyNetwork(colonyNetworkAddress).appendReputationUpdateLog(_users[i], _amounts[i], domains[1].skillId);
+      uint256 scaleFactor = tokenReputationScalings[token]; // NB This is a WAD
+      int256 tokenScaledReputationAmount = scaleReputation(_amounts[i], scaleFactor);
+      emitReputation(_users[i], tokenScaledReputationAmount, domains[1].skillId);
     }
 
     emit ColonyBootstrapped(msgSender(), _users, _amounts);
@@ -173,6 +175,7 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
   function addGlobalSkill() public
   stoppable
   auth
+  onlyMiningChain
   returns (uint256)
   {
     return IColonyNetwork(colonyNetworkAddress).addSkill(0); // ignore-swc-107
@@ -214,6 +217,38 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
     IColonyNetwork(colonyNetworkAddress).addColonyVersion(_version, _resolver);
   }
 
+  function setBridgeData(
+    address _bridgeAddress,
+    uint256 _chainId,
+    uint256 _gas,
+    bytes memory _updateLogBefore,
+    bytes memory _updateLogAfter,
+    bytes memory _skillCreationBefore,
+    bytes memory _skillCreationAfter,
+    bytes memory _setReputationRootHashBefore,
+    bytes memory _setReputationRootHashAfter,
+    bytes memory _setColonyDecayRateBefore,
+    bytes memory _setColonyDecayRateAfter
+  )
+    external
+    stoppable
+    auth
+  {
+    IColonyNetwork(colonyNetworkAddress).setBridgeData(
+      _bridgeAddress,
+      _chainId,
+      _gas,
+      _updateLogBefore,
+      _updateLogAfter,
+      _skillCreationBefore,
+      _skillCreationAfter,
+      _setReputationRootHashBefore,
+      _setReputationRootHashAfter,
+      _setColonyDecayRateBefore,
+      _setColonyDecayRateAfter
+    );
+  }
+
   function addExtensionToNetwork(bytes32 _extensionId, address _resolver)
   public stoppable auth
   {
@@ -315,14 +350,38 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
     ColonyAuthority colonyAuthority = ColonyAuthority(address(authority));
     bytes4 sig;
 
-    sig = bytes4(keccak256("makeArbitraryTransactions(address[],bytes[],bool)"));
+    sig = bytes4(keccak256("setBridgeData(address,uint256,uint256,bytes,bytes,bytes,bytes,bytes,bytes,bytes,bytes)"));
     colonyAuthority.setRoleCapability(uint8(ColonyRole.Root), address(this), sig, true);
 
     sig = bytes4(keccak256("setDefaultGlobalClaimDelay(uint256)"));
     colonyAuthority.setRoleCapability(uint8(ColonyRole.Root), address(this), sig, true);
 
     sig = bytes4(keccak256("setExpenditureMetadata(uint256,uint256,uint256,string)"));
     colonyAuthority.setRoleCapability(uint8(ColonyRole.Arbitration), address(this), sig, true);
+
+    sig = bytes4(keccak256("setDomainReputationScaling(uint256,uint256)"));
+    colonyAuthority.setRoleCapability(uint8(ColonyRole.Root), address(this), sig, true);
+
+    // Set the default token weighting for the native token
+    tokenReputationScalings[token] = WAD;
+
+    sig = bytes4(keccak256("setReputationDecayRate(uint256,uint256)"));
+    colonyAuthority.setRoleCapability(uint8(ColonyRole.Root), address(this), sig, true);
+
+    sig = bytes4(keccak256("setReputationMiningCycleRewardReputationScaling(uint256)"));
+    colonyAuthority.setRoleCapability(uint8(ColonyRole.Root), address(this), sig, true);
+  }
+
+  function setTokenReputationScaling(address _token, uint256 _scaling) public stoppable {
+      tokenReputationScalings[_token] = _scaling;
+  }
+
+  function getTokenReputationScaling(address _token) public view returns (uint256) {
+    return tokenReputationScalings[_token];
+  }
+
+  function setReputationDecayRate(uint256 _numerator, uint256 _denominator) stoppable auth public {
+    IColonyNetwork(colonyNetworkAddress).setColonyReputationDecayRate(_numerator, _denominator);
   }
 
   function getMetatransactionNonce(address _user) override public view returns (uint256 nonce){
@@ -400,4 +459,12 @@ contract Colony is BasicMetaTransaction, Multicall, ColonyStorage, PatriciaTreeP
     return tokenApprovalTotals[_token];
   }
 
+  function setReputationMiningCycleRewardReputationScaling(uint256 _factor) public stoppable auth {
+    require(_factor <= WAD, "colony-invalid-reputation-scale-factor");
+    require(IColonyNetwork(colonyNetworkAddress).getMetaColony() == address(this), "colony-only-on-metacolony");
+    uint256 reputationMiningSkillId = IColonyNetwork(colonyNetworkAddress).getReputationMiningSkillId();
+    skillReputationScalingComplements[reputationMiningSkillId] = WAD - _factor;
+
+    emit MiningReputationScalingSet(_factor);
+  }
 }

contracts/colony/ColonyAuthority.sol

@@ -129,6 +129,13 @@ contract ColonyAuthority is CommonAuthority {
 
     // Added in colony v10 (ginger-lwss)
     addRoleCapability(ARBITRATION_ROLE, "setExpenditurePayout(uint256,uint256,uint256,uint256,address,uint256)");
+
+    // Added in colony vxxx
+    addRoleCapability(ROOT_ROLE, "setBridgeData(address,uint256,uint256,bytes,bytes,bytes,bytes,bytes,bytes,bytes,bytes)");
+    addRoleCapability(ROOT_ROLE, "setDomainReputationScaling(uint256,uint256)");
+    addRoleCapability(ROOT_ROLE, "setReputationDecayRate(uint256,uint256)");
+    addRoleCapability(ROOT_ROLE, "setReputationMiningCycleRewardReputationScaling(uint256)");
+
   }
 
   function addRoleCapability(uint8 role, bytes memory sig) private {

contracts/colony/ColonyDataTypes.sol

@@ -349,6 +349,12 @@ interface ColonyDataTypes {
 
   event ArbitraryTransaction(address target, bytes data, bool success);
 
+  event DomainReputationScalingSet(uint256 domainId, uint256 factor);
+
+  /// @notice Event logged when the reputation scaling factor for miners is set
+  /// @param factor The factor (from 0 to WAD) governing how reputation awards for miners is scaled
+  event MiningReputationScalingSet(uint256 factor);
+
   struct RewardPayoutCycle {
     // Reputation root hash at the time of reward payout creation
     bytes32 reputationState;

contracts/colony/ColonyDomains.sol

@@ -59,6 +59,9 @@ contract ColonyDomains is ColonyStorage {
     // Set initial colony reward inverse amount to the max indicating a zero rewards to start with
     rewardInverse = 2**256 - 1;
 
+    // Set the token weighting for the native token to 1
+    tokenReputationScalings[token] = WAD;
+
     emit ColonyInitialised(msgSender(), _colonyNetworkAddress, _token);
   }
 
@@ -124,6 +127,15 @@ contract ColonyDomains is ColonyStorage {
     return domainCount;
   }
 
+  function setDomainReputationScaling(uint256 _domainId, uint256 _factor) public stoppable auth {
+    require(domainExists(_domainId), "colony-domain-does-not-exist");
+    require(_factor <= WAD, "colony-network-invalid-reputation-scale-factor");
+
+    skillReputationScalingComplements[domains[_domainId].skillId] = WAD - _factor;
+
+    emit DomainReputationScalingSet(_domainId, _factor);
+  }
+
   // Internal
 
   function initialiseDomain(uint256 _skillId) internal {

contracts/colony/ColonyExpenditure.sol

@@ -175,7 +175,6 @@ contract ColonyExpenditure is ColonyStorage {
     expenditureOnlyOwner(_id)
   {
     require(_slots.length == _skillIds.length, "colony-expenditure-bad-slots");
-    IColonyNetwork colonyNetworkContract = IColonyNetwork(colonyNetworkAddress);
 
     for (uint256 i; i < _slots.length; i++) {
       require(isValidGlobalOrLocalSkill(_skillIds[i]), "colony-not-valid-global-or-local-skill");
@@ -214,6 +213,7 @@ contract ColonyExpenditure is ColonyStorage {
     require(_slots.length == _payoutModifiers.length, "colony-expenditure-bad-slots");
 
     for (uint256 i; i < _slots.length; i++) {
+      require(_payoutModifiers[i] <= 0, "colony-expenditure-bad-payout-modifier");
       expenditureSlots[_id][_slots[i]].payoutModifier = _payoutModifiers[i];
 
       emit ExpenditurePayoutModifierSet(msgSender(), _id, _slots[i], _payoutModifiers[i]);
@@ -316,14 +316,14 @@ contract ColonyExpenditure is ColonyStorage {
       // Validate payout modifier
       if (offset == 2) {
         require(
-          int256(uint256(_value)) <= MAX_PAYOUT_MODIFIER &&
+          (int256(uint256(_value)) <= 0 || IColony(address(this)).hasUserRole(msgSender(), 1, ColonyRole.Root)) &&
           int256(uint256(_value)) >= MIN_PAYOUT_MODIFIER,
           "colony-expenditure-bad-payout-modifier"
         );
       }
 
     } else {
-      require(false, "colony-expenditure-bad-slot");
+      revert("colony-expenditure-bad-slot");
     }
 
     executeStateChange(keccak256(abi.encode(_id, _storageSlot)), _mask, _keys, _value);
@@ -361,11 +361,11 @@ contract ColonyExpenditure is ColonyStorage {
     internal
   {
     for (uint256 i; i < _tokens.length; i++) {
-      (bool success, bytes memory returndata) = address(this).delegatecall(
+      (bool success, bytes memory returndata) = address(this).delegatecall( // solhint-disable-line avoid-low-level-calls
         abi.encodeWithSignature("setExpenditurePayouts(uint256,uint256[],address,uint256[])", _id, _slots[i], _tokens[i], _values[i])
       );
       if (!success) {
-        if (returndata.length == 0) revert();
+        if (returndata.length == 0) revert("colony-expenditure-null-return");
         assembly {
           revert(add(32, returndata), mload(returndata))
         }