Abstract tokens/rep into influence

Author: kronosapiens

contracts/extensions/VotingBase.sol

@@ -19,13 +19,12 @@ pragma solidity 0.7.3;
 pragma experimental ABIEncoderV2;
 
 import "./../colonyNetwork/IColonyNetwork.sol";
-import "./../common/ERC20Extended.sol";
 import "./../patriciaTree/PatriciaTreeProofs.sol";
 import "./../tokenLocking/ITokenLocking.sol";
 import "./ColonyExtension.sol";
 
 
-contract VotingBase is ColonyExtension, PatriciaTreeProofs {
+abstract contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
   // Events
   event MotionCreated(uint256 indexed motionId, address creator, uint256 indexed domainId);
@@ -96,17 +95,6 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
   // Public
 
-  /// @notice Returns the identifier of the extension
-  function identifier() public override pure returns (bytes32) {
-    return keccak256("VotingReputation");
-  }
-
-  /// @notice Return the version number
-  /// @return The version number
-  function version() public pure override returns (uint256) {
-    return 1;
-  }
-
   /// @notice Install the extension
   /// @param _colony Base colony for the installation
   function install(address _colony) public override {
@@ -190,7 +178,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     bytes32 rootHash;
     uint256 domainId;
     uint256 skillId;
-    uint256 skillRep;
+    uint256 maxVotes;
     uint256 totalVotes;
     uint256 paidVoterComp;
     uint256[2] pastVoterComp; // [nay, yay]
@@ -211,85 +199,24 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   mapping (bytes32 => uint256) expenditurePastVotes; // expenditure slot signature => voting power
   mapping (bytes32 => uint256) expenditureMotionCounts; // expenditure struct signature => count
 
-  // Public functions (interface)
+  // Virtual functions
 
-  /// @notice Create a motion in the root domain
-  /// @param _altTarget The contract to which we send the action (0x0 for the colony)
-  /// @param _action A bytes array encoding a function call
-  /// @param _key Reputation tree key for the root domain
-  /// @param _value Reputation tree value for the root domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
-  function createRootMotion(
-    address _altTarget,
-    bytes memory _action,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    public
-  {
-    uint256 rootSkillId = colony.getDomain(1).skillId;
-    createMotion(_altTarget, _action, 1, rootSkillId, _key, _value, _branchMask, _siblings);
-  }
+  function getInfluence(uint256 _motionId, address _user) public view virtual returns (uint256);
 
-  /// @notice Create a motion in any domain
-  /// @param _domainId The domain where we vote on the motion
-  /// @param _childSkillIndex The childSkillIndex pointing to the domain of the action
-  /// @param _action A bytes array encoding a function call
-  /// @param _key Reputation tree key for the domain
-  /// @param _value Reputation tree value for the domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
-  function createDomainMotion(
-    uint256 _domainId,
-    uint256 _childSkillIndex,
-    bytes memory _action,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    public
-  {
-    // Check the function requires a non-root permission (and thus a domain proof)
-    require(
-      colony.getCapabilityRoles(getSig(_action)) | ROOT_ROLES != ROOT_ROLES,
-      "voting-base-invalid-function"
-    );
-
-    uint256 domainSkillId = colony.getDomain(_domainId).skillId;
-    uint256 actionDomainSkillId = getActionDomainSkillId(_action);
-
-    if (domainSkillId != actionDomainSkillId) {
-      uint256 childSkillId = colonyNetwork.getChildSkillId(domainSkillId, _childSkillIndex);
-      require(childSkillId == actionDomainSkillId, "voting-base-invalid-domain-id");
-    }
-
-    createMotion(address(0x0), _action, _domainId, domainSkillId, _key, _value, _branchMask, _siblings);
-  }
+  // Public functions (interface)
 
   /// @notice Stake on a motion
   /// @param _motionId The id of the motion
   /// @param _permissionDomainId The domain where the extension has the arbitration permission
   /// @param _childSkillIndex For the domain in which the motion is occurring
   /// @param _vote The side being supported (0 = NAY, 1 = YAY)
   /// @param _amount The amount of tokens being staked
-  /// @param _key Reputation tree key for the staker/domain
-  /// @param _value Reputation tree value for the staker/domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
   function stakeMotion(
     uint256 _motionId,
     uint256 _permissionDomainId,
     uint256 _childSkillIndex,
     uint256 _vote,
-    uint256 _amount,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
+    uint256 _amount
   )
     public
   {
@@ -304,7 +231,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     uint256 stakerTotalAmount = add(stakes[_motionId][msg.sender][_vote], amount);
 
     require(
-      stakerTotalAmount <= getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings),
+      stakerTotalAmount <= getInfluence(_motionId, msg.sender),
       "voting-base-insufficient-rep"
     );
     require(
@@ -367,25 +294,12 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   /// @notice Submit a vote secret for a motion
   /// @param _motionId The id of the motion
   /// @param _voteSecret The hashed vote secret
-  /// @param _key Reputation tree key for the staker/domain
-  /// @param _value Reputation tree value for the staker/domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
-  function submitVote(
-    uint256 _motionId,
-    bytes32 _voteSecret,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    public
-  {
+  function submitVote(uint256 _motionId, bytes32 _voteSecret) public {
     Motion storage motion = motions[_motionId];
     require(getMotionState(_motionId) == MotionState.Submit, "voting-base-motion-not-open");
     require(_voteSecret != bytes32(0), "voting-base-invalid-secret");
 
-    uint256 userRep = getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings);
+    uint256 userRep = getInfluence(_motionId, msg.sender);
 
     // Count reputation if first submission
     if (voteSecrets[_motionId][msg.sender] == bytes32(0)) {
@@ -396,7 +310,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
     emit MotionVoteSubmitted(_motionId, msg.sender);
 
-    if (motion.totalVotes >= wmul(motion.skillRep, maxVoteFraction)) {
+    if (motion.totalVotes >= wmul(motion.maxVotes, maxVoteFraction)) {
       motion.events[SUBMIT_END] = uint64(block.timestamp);
       motion.events[REVEAL_END] = uint64(block.timestamp + revealPeriod);
 
@@ -408,33 +322,19 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   /// @param _motionId The id of the motion
   /// @param _salt The salt used to hash the vote
   /// @param _vote The side being supported (0 = NAY, 1 = YAY)
-  /// @param _key Reputation tree key for the staker/domain
-  /// @param _value Reputation tree value for the staker/domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
-  function revealVote(
-    uint256 _motionId,
-    bytes32 _salt,
-    uint256 _vote,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    public
-  {
+  function revealVote(uint256 _motionId, bytes32 _salt, uint256 _vote) public {
     Motion storage motion = motions[_motionId];
     require(getMotionState(_motionId) == MotionState.Reveal, "voting-base-motion-not-reveal");
     require(_vote <= 1, "voting-base-bad-vote");
 
-    uint256 userRep = getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings);
-    motion.votes[_vote] = add(motion.votes[_vote], userRep);
+    uint256 influence = getInfluence(_motionId, msg.sender);
+    motion.votes[_vote] = add(motion.votes[_vote], influence);
 
     bytes32 voteSecret = voteSecrets[_motionId][msg.sender];
     require(voteSecret == getVoteSecret(_salt, _vote), "voting-base-secret-no-match");
     delete voteSecrets[_motionId][msg.sender];
 
-    uint256 voterReward = getVoterReward(_motionId, userRep);
+    uint256 voterReward = getVoterReward(_motionId, influence);
     motion.paidVoterComp = add(motion.paidVoterComp, voterReward);
 
     emit MotionVoteRevealed(_motionId, msg.sender, _vote);
@@ -448,58 +348,6 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     tokenLocking.transfer(token, voterReward, msg.sender, true);
   }
 
-  /// @notice Escalate a motion to a higher domain
-  /// @param _motionId The id of the motion
-  /// @param _newDomainId The desired domain of escalation
-  /// @param _childSkillIndex For the current domain, relative to the escalated domain
-  /// @param _key Reputation tree key for the new domain
-  /// @param _value Reputation tree value for the new domain
-  /// @param _branchMask The branchmask of the proof
-  /// @param _siblings The siblings of the proof
-  function escalateMotion(
-    uint256 _motionId,
-    uint256 _newDomainId,
-    uint256 _childSkillIndex,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    public
-  {
-    Motion storage motion = motions[_motionId];
-    require(getMotionState(_motionId) == MotionState.Closed, "voting-base-motion-not-closed");
-
-    uint256 newDomainSkillId = colony.getDomain(_newDomainId).skillId;
-    uint256 childSkillId = colonyNetwork.getChildSkillId(newDomainSkillId, _childSkillIndex);
-    require(childSkillId == motion.skillId, "voting-base-invalid-domain-proof");
-
-    uint256 domainId = motion.domainId;
-    motion.domainId = _newDomainId;
-    motion.skillId = newDomainSkillId;
-    motion.skillRep = getReputationFromProof(_motionId, address(0x0), _key, _value, _branchMask, _siblings);
-
-    uint256 loser = (motion.votes[NAY] < motion.votes[YAY]) ? NAY : YAY;
-    motion.stakes[loser] = sub(motion.stakes[loser], motion.paidVoterComp);
-    motion.pastVoterComp[loser] = add(motion.pastVoterComp[loser], motion.paidVoterComp);
-    delete motion.paidVoterComp;
-
-    uint256 requiredStake = getRequiredStake(_motionId);
-    motion.events[STAKE_END] = (motion.stakes[NAY] < requiredStake || motion.stakes[YAY] < requiredStake) ?
-      uint64(block.timestamp + stakePeriod) : uint64(block.timestamp);
-
-    motion.events[SUBMIT_END] = motion.events[STAKE_END] + uint64(submitPeriod);
-    motion.events[REVEAL_END] = motion.events[SUBMIT_END] + uint64(revealPeriod);
-
-    motion.escalated = true;
-
-    emit MotionEscalated(_motionId, msg.sender, domainId, _newDomainId);
-
-    if (motion.events[STAKE_END] == uint64(block.timestamp)) {
-      emit MotionEventSet(_motionId, STAKE_END);
-    }
-  }
-
   function finalizeMotion(uint256 _motionId) public {
     Motion storage motion = motions[_motionId];
     require(getMotionState(_motionId) == MotionState.Finalizable, "voting-base-motion-not-finalizable");
@@ -737,7 +585,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   /// @return The voter reward
   function getVoterReward(uint256 _motionId, uint256 _voterRep) public view returns (uint256) {
     Motion storage motion = motions[_motionId];
-    uint256 fractionUserReputation = wdiv(_voterRep, motion.skillRep);
+    uint256 fractionUserReputation = wdiv(_voterRep, motion.maxVotes);
     uint256 totalStake = add(motion.stakes[YAY], motion.stakes[NAY]);
     return wmul(wmul(fractionUserReputation, totalStake), voterRewardFraction);
   }
@@ -817,12 +665,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   function createMotion(
     address _altTarget,
     bytes memory _action,
-    uint256 _domainId,
-    uint256 _skillId,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
+    uint256 _domainId
   )
     internal
     notDeprecated
@@ -839,9 +682,8 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
     motion.rootHash = colonyNetwork.getReputationRootHash();
     motion.domainId = _domainId;
-    motion.skillId = _skillId;
+    motion.skillId = colony.getDomain(_domainId).skillId;
 
-    motion.skillRep = getReputationFromProof(motionCount, address(0x0), _key, _value, _branchMask, _siblings);
     motion.altTarget = _altTarget;
     motion.action = _action;
 
@@ -853,45 +695,13 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   }
 
   function getRequiredStake(uint256 _motionId) internal view returns (uint256) {
-    return wmul(motions[_motionId].skillRep, totalStakeFraction);
+    return wmul(motions[_motionId].maxVotes, totalStakeFraction);
   }
 
   function flip(uint256 _vote) internal pure returns (uint256) {
     return sub(1, _vote);
   }
 
-  function getReputationFromProof(
-    uint256 _motionId,
-    address _who,
-    bytes memory _key,
-    bytes memory _value,
-    uint256 _branchMask,
-    bytes32[] memory _siblings
-  )
-    internal view returns (uint256)
-  {
-    bytes32 impliedRoot = getImpliedRootHashKey(_key, _value, _branchMask, _siblings);
-    require(motions[_motionId].rootHash == impliedRoot, "voting-base-invalid-root-hash");
-
-    uint256 reputationValue;
-    address keyColonyAddress;
-    uint256 keySkill;
-    address keyUserAddress;
-
-    assembly {
-      reputationValue := mload(add(_value, 32))
-      keyColonyAddress := mload(add(_key, 20))
-      keySkill := mload(add(_key, 52))
-      keyUserAddress := mload(add(_key, 72))
-    }
-
-    require(keyColonyAddress == address(colony), "voting-base-invalid-colony-address");
-    require(keySkill == motions[_motionId].skillId, "voting-base-invalid-skill-id");
-    require(keyUserAddress == _who, "voting-base-invalid-user-address");
-
-    return reputationValue;
-  }
-
   function getActionDomainSkillId(bytes memory _action) internal view returns (uint256) {
     uint256 permissionDomainId;
     uint256 childSkillIndex;