Extract reputation functionality into VotingReputation

Author: kronosapiens

contracts/extensions/VotingBase.sol

@@ -90,7 +90,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
   // Modifiers
 
   modifier onlyRoot() {
-    require(colony.hasUserRole(msg.sender, 1, ColonyDataTypes.ColonyRole.Root), "voting-rep-caller-not-root");
+    require(colony.hasUserRole(msg.sender, 1, ColonyDataTypes.ColonyRole.Root), "voting-base-caller-not-root");
     _;
   }
 
@@ -140,18 +140,18 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     public
     onlyRoot
   {
-    require(state == ExtensionState.Deployed, "voting-rep-already-initialised");
+    require(state == ExtensionState.Deployed, "voting-base-already-initialised");
 
-    require(_totalStakeFraction <= WAD / 2, "voting-rep-greater-than-half-wad");
-    require(_voterRewardFraction <= WAD / 2, "voting-rep-greater-than-half-wad");
+    require(_totalStakeFraction <= WAD / 2, "voting-base-greater-than-half-wad");
+    require(_voterRewardFraction <= WAD / 2, "voting-base-greater-than-half-wad");
 
-    require(_userMinStakeFraction <= WAD, "voting-rep-greater-than-wad");
-    require(_maxVoteFraction <= WAD, "voting-rep-greater-than-wad");
+    require(_userMinStakeFraction <= WAD, "voting-base-greater-than-wad");
+    require(_maxVoteFraction <= WAD, "voting-base-greater-than-wad");
 
-    require(_stakePeriod <= 365 days, "voting-rep-period-too-long");
-    require(_submitPeriod <= 365 days, "voting-rep-period-too-long");
-    require(_revealPeriod <= 365 days, "voting-rep-period-too-long");
-    require(_escalationPeriod <= 365 days, "voting-rep-period-too-long");
+    require(_stakePeriod <= 365 days, "voting-base-period-too-long");
+    require(_submitPeriod <= 365 days, "voting-base-period-too-long");
+    require(_revealPeriod <= 365 days, "voting-base-period-too-long");
+    require(_escalationPeriod <= 365 days, "voting-base-period-too-long");
 
     state = ExtensionState.Active;
 
@@ -190,7 +190,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]
@@ -213,62 +213,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
   // Public functions (interface)
 
-  /// @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);
-  }
-
-  /// @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-rep-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-rep-invalid-domain-id");
-    }
-
-    createMotion(address(0x0), _action, _domainId, domainSkillId, _key, _value, _branchMask, _siblings);
-  }
+  // MOTION CREATION & VOTING IMPLEMENTED IN SUBCLASSES
 
   /// @notice Stake on a motion
   /// @param _motionId The id of the motion
@@ -294,23 +239,23 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     public
   {
     Motion storage motion = motions[_motionId];
-    require(_vote <= 1, "voting-rep-bad-vote");
-    require(getMotionState(_motionId) == MotionState.Staking, "voting-rep-motion-not-staking");
+    require(_vote <= 1, "voting-base-bad-vote");
+    require(getMotionState(_motionId) == MotionState.Staking, "voting-base-motion-not-staking");
 
     uint256 requiredStake = getRequiredStake(_motionId);
     uint256 amount = min(_amount, sub(requiredStake, motion.stakes[_vote]));
-    require(amount > 0, "voting-rep-bad-amount");
+    require(amount > 0, "voting-base-bad-amount");
 
     uint256 stakerTotalAmount = add(stakes[_motionId][msg.sender][_vote], amount);
 
     require(
       stakerTotalAmount <= getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings),
-      "voting-rep-insufficient-rep"
+      "voting-base-insufficient-rep"
     );
     require(
       stakerTotalAmount >= wmul(requiredStake, userMinStakeFraction) ||
       add(motion.stakes[_vote], amount) == requiredStake, // To prevent a residual stake from being un-stakable
-      "voting-rep-insufficient-stake"
+      "voting-base-insufficient-stake"
     );
 
     colony.obligateStake(msg.sender, motion.domainId, amount);
@@ -333,7 +278,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
       expenditureMotionCounts[structHash] = add(expenditureMotionCounts[structHash], 1);
       // Set to UINT256_MAX / 3 to avoid overflow (finalizedTimestamp + globalClaimDelay + claimDelay)
       bytes memory claimDelayAction = createClaimDelayAction(motion.action, UINT256_MAX / 3);
-      require(executeCall(_motionId, claimDelayAction), "voting-rep-expenditure-lock-failed");
+      require(executeCall(_motionId, claimDelayAction), "voting-base-expenditure-lock-failed");
     }
 
     emit MotionStaked(_motionId, msg.sender, _vote, amount);
@@ -364,90 +309,6 @@ 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
-  {
-    Motion storage motion = motions[_motionId];
-    require(getMotionState(_motionId) == MotionState.Submit, "voting-rep-motion-not-open");
-    require(_voteSecret != bytes32(0), "voting-rep-invalid-secret");
-
-    uint256 userRep = getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings);
-
-    // Count reputation if first submission
-    if (voteSecrets[_motionId][msg.sender] == bytes32(0)) {
-      motion.totalVotes = add(motion.totalVotes, userRep);
-    }
-
-    voteSecrets[_motionId][msg.sender] = _voteSecret;
-
-    emit MotionVoteSubmitted(_motionId, msg.sender);
-
-    if (motion.totalVotes >= wmul(motion.skillRep, maxVoteFraction)) {
-      motion.events[SUBMIT_END] = uint64(block.timestamp);
-      motion.events[REVEAL_END] = uint64(block.timestamp + revealPeriod);
-
-      emit MotionEventSet(_motionId, SUBMIT_END);
-    }
-  }
-
-  /// @notice Reveal a vote secret for a motion
-  /// @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
-  {
-    Motion storage motion = motions[_motionId];
-    require(getMotionState(_motionId) == MotionState.Reveal, "voting-rep-motion-not-reveal");
-    require(_vote <= 1, "voting-rep-bad-vote");
-
-    uint256 userRep = getReputationFromProof(_motionId, msg.sender, _key, _value, _branchMask, _siblings);
-    motion.votes[_vote] = add(motion.votes[_vote], userRep);
-
-    bytes32 voteSecret = voteSecrets[_motionId][msg.sender];
-    require(voteSecret == getVoteSecret(_salt, _vote), "voting-rep-secret-no-match");
-    delete voteSecrets[_motionId][msg.sender];
-
-    uint256 voterReward = getVoterReward(_motionId, userRep);
-    motion.paidVoterComp = add(motion.paidVoterComp, voterReward);
-
-    emit MotionVoteRevealed(_motionId, msg.sender, _vote);
-
-    // See if reputation revealed matches reputation submitted
-    if (add(motion.votes[NAY], motion.votes[YAY]) == motion.totalVotes) {
-      motion.events[REVEAL_END] = uint64(block.timestamp);
-
-      emit MotionEventSet(_motionId, REVEAL_END);
-    }
-    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
@@ -468,16 +329,16 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     public
   {
     Motion storage motion = motions[_motionId];
-    require(getMotionState(_motionId) == MotionState.Closed, "voting-rep-motion-not-closed");
+    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-rep-invalid-domain-proof");
+    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);
+    motion.maxVotes = 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);
@@ -502,7 +363,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
 
   function finalizeMotion(uint256 _motionId) public {
     Motion storage motion = motions[_motionId];
-    require(getMotionState(_motionId) == MotionState.Finalizable, "voting-rep-motion-not-finalizable");
+    require(getMotionState(_motionId) == MotionState.Finalizable, "voting-base-motion-not-finalizable");
 
     assert(
       motion.stakes[YAY] == getRequiredStake(_motionId) ||
@@ -567,12 +428,12 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     require(
       getMotionState(_motionId) == MotionState.Finalized ||
       getMotionState(_motionId) == MotionState.Failed,
-      "voting-rep-motion-not-claimable"
+      "voting-base-motion-not-claimable"
     );
 
     (uint256 stakerReward, uint256 repPenalty) = getStakerReward(_motionId, _staker, _vote);
 
-    require(stakerReward > 0, "voting-rep-nothing-to-claim");
+    require(stakerReward > 0, "voting-base-nothing-to-claim");
     delete stakes[_motionId][_staker][_vote];
 
     tokenLocking.transfer(token, stakerReward, _staker, true);
@@ -737,7 +598,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,18 +678,13 @@ 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
   {
-    require(state == ExtensionState.Active, "voting-rep-not-active");
-    require(_altTarget != address(colony), "voting-rep-alt-target-cannot-be-base-colony");
+    require(state == ExtensionState.Active, "voting-base-not-active");
+    require(_altTarget != address(colony), "voting-base-alt-target-cannot-be-base-colony");
 
     motionCount += 1;
     Motion storage motion = motions[motionCount];
@@ -839,9 +695,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,7 +708,7 @@ 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) {
@@ -871,7 +726,7 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
     internal view returns (uint256)
   {
     bytes32 impliedRoot = getImpliedRootHashKey(_key, _value, _branchMask, _siblings);
-    require(motions[_motionId].rootHash == impliedRoot, "voting-rep-invalid-root-hash");
+    require(motions[_motionId].rootHash == impliedRoot, "voting-base-invalid-root-hash");
 
     uint256 reputationValue;
     address keyColonyAddress;
@@ -885,9 +740,9 @@ contract VotingBase is ColonyExtension, PatriciaTreeProofs {
       keyUserAddress := mload(add(_key, 72))
     }
 
-    require(keyColonyAddress == address(colony), "voting-rep-invalid-colony-address");
-    require(keySkill == motions[_motionId].skillId, "voting-rep-invalid-skill-id");
-    require(keyUserAddress == _who, "voting-rep-invalid-user-address");
+    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;
   }