Merge pull request #56 from luciditytech/feature/individual-phase-durations

feat(Chain): individual phase durations

Author: DZariusz

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+###Changed
+- Each phase has its own duration
+
 ## [0.5.1] - 2020-01-27
 ### Changed
 - when updating contract via `ContractRegistry`, old `Chain` contract is not killed

config/development.json

@@ -10,7 +10,8 @@
     "verifiersPerShard": "10"
   },
   "Chain": {
-    "blocksPerPhase": "10",
+    "blocksPerPropose": "100",
+    "blocksPerReveal": "10",
     "minimumStakingTokenPercentage": "70"
   },
   "ContractRegistry": {

config/production.json

@@ -11,7 +11,8 @@
   },
   "Chain": {
     "verifierRegistryAddress": "0x614cb086657c47739068c12eeff43a4018be1190",
-    "blocksPerPhase": "10",
+    "blocksPerPropose": "100",
+    "blocksPerReveal": "10",
     "minimumStakingTokenPercentage": "70"
   },
   "ContractRegistry": {

config/staging.json

@@ -11,7 +11,8 @@
   },
   "Chain": {
     "verifierRegistryAddress": "0xd209f28511f37e3e975d4631b7cfa2f52ffabcef",
-    "blocksPerPhase": "10",
+    "blocksPerPropose": "100",
+    "blocksPerReveal": "10",
     "minimumStakingTokenPercentage": "70"
   },
   "ContractRegistry": {

contracts/Chain.sol

@@ -20,11 +20,11 @@ contract Chain is IChain, RegistrableWithSingleStorage, ReentrancyGuard, Ownable
   bytes32  constant NAME = "Chain";
 
   modifier whenProposePhase() {
-    require(getCurrentElectionCycleBlock() < blocksPerPhase(), "we are not in propose phase");
+    require(getCurrentElectionCycleBlock() < blocksPerPropose(), "we are not in propose phase");
     _;
   }
   modifier whenRevealPhase() {
-    require(getCurrentElectionCycleBlock() >= blocksPerPhase(), "we are not in reveal phase");
+    require(getCurrentElectionCycleBlock() >= blocksPerPropose(), "we are not in reveal phase");
     _;
   }
 
@@ -113,7 +113,7 @@ contract Chain is IChain, RegistrableWithSingleStorage, ReentrancyGuard, Ownable
   }
 
   function getBlockHeight() public view returns (uint256) {
-    return block.number.div(uint256(blocksPerPhase()) * 2);
+    return block.number.div(uint256(blocksPerPropose() + blocksPerReveal()) );
   }
 
   /// @dev this function needs to be called each time we successfully reveal a proposal
@@ -235,18 +235,25 @@ contract Chain is IChain, RegistrableWithSingleStorage, ReentrancyGuard, Ownable
     return _storage().minimumStakingTokenPercentage();
   }
 
-  function blocksPerPhase()
+  function blocksPerPropose()
   public
   view
   returns (uint8) {
-    return _storage().blocksPerPhase();
+    return _storage().blocksPerPropose();
+  }
+
+  function blocksPerReveal()
+  public
+  view
+  returns (uint8) {
+    return _storage().blocksPerReveal();
   }
 
   function getCurrentElectionCycleBlock()
   public
   view
   returns (uint256) {
-    return block.number % (uint256(blocksPerPhase()) * 2);
+    return block.number % (uint256(blocksPerPropose() + blocksPerReveal()));
   }
 
   /// @return first block number (blockchain block) of current cycle
@@ -261,7 +268,7 @@ contract Chain is IChain, RegistrableWithSingleStorage, ReentrancyGuard, Ownable
   public
   view
   returns (bool) {
-    return getCurrentElectionCycleBlock() < blocksPerPhase();
+    return getCurrentElectionCycleBlock() < blocksPerPropose();
   }
 
   function initialBlockHeights(uint256 _shard)

contracts/ChainStorage.sol

@@ -17,54 +17,69 @@ contract ChainStorage is StorageBase {
   /// @dev structure of block that is created for each election
   struct Block {
     /// @dev shard => root of merkle tree (the winner)
-    mapping (uint256 => bytes32) roots;
-    mapping (bytes32 => bool) uniqueBlindedProposals;
-    mapping (address => Voter) voters;
+    mapping(uint256 => bytes32) roots;
+    mapping(bytes32 => bool) uniqueBlindedProposals;
+    mapping(address => Voter) voters;
 
     /// @dev shard => max votes
-    mapping (uint256 => uint256) maxsVotes;
+    mapping(uint256 => uint256) maxsVotes;
 
     // shard => proposal => counts
     // Im using mapping, because its less gas consuming that array,
     // and also it is much easier to work with mapping than with array
     // unfortunately we can't be able to delete this data to release gas, why?
     // because to do this, we need to save all the keys and then run loop for all keys... that may cause OOG
     // also storing keys is more gas consuming so... I made decision to stay with mapping and never delete history
-    mapping (uint256 => mapping(bytes32 => uint256)) counts;
+    mapping(uint256 => mapping(bytes32 => uint256)) counts;
 
     /// @dev shard => total amount of tokens
-    mapping (uint256 => uint256) balancesPerShard;
+    mapping(uint256 => uint256) balancesPerShard;
 
     address[] verifierAddresses;
   }
 
   /// @dev blockHeight => Block - results of each elections will be saved here: one block (array element) per election
-  mapping (uint256 => Block) blocks;
+  mapping(uint256 => Block) blocks;
 
   /// @dev shard => blockHeight
-  mapping (uint256 => uint256) public initialBlockHeights;
+  mapping(uint256 => uint256) public initialBlockHeights;
 
   bool public updateMinimumStakingTokenPercentageEnabled;
 
-  uint8 public blocksPerPhase;
+  uint8 public blocksPerPropose;
+  uint8 public blocksPerReveal;
 
   uint8 public minimumStakingTokenPercentage;
 
-  event LogChainConfig(uint8 blocksPerPhase, uint8 requirePercentOfTokens, bool updateMinimumStakingTokenPercentageEnabled);
+  event LogChainConfig(
+    uint8 blocksPerPropose,
+    uint8 blocksPerReveal,
+    uint8 requirePercentOfTokens,
+    bool updateMinimumStakingTokenPercentageEnabled
+  );
 
-  constructor(uint8 _blocksPerPhase,
+  constructor(
+    uint8 _blocksPerPropose,
+    uint8 _blocksPerReveal,
     uint8 _minimumStakingTokenPercentage,
     bool _updateMinimumStakingTokenPercentageEnabled) public {
-    require(_blocksPerPhase > 0, "_blocksPerPhase can't be empty");
-    blocksPerPhase = _blocksPerPhase;
+    require(_blocksPerPropose > 0, "_blocksPerPropose can't be empty");
+    require(_blocksPerReveal > 0, "_blocksPerReveal can't be empty");
+    blocksPerPropose = _blocksPerPropose;
+    blocksPerReveal = _blocksPerReveal;
 
     require(_minimumStakingTokenPercentage > 0, "_minimumStakingTokenPercentage can't be empty");
     require(_minimumStakingTokenPercentage <= 100, "_minimumStakingTokenPercentage can't be over 100%");
     minimumStakingTokenPercentage = _minimumStakingTokenPercentage;
 
     updateMinimumStakingTokenPercentageEnabled = _updateMinimumStakingTokenPercentageEnabled;
 
-    emit LogChainConfig(_blocksPerPhase, _minimumStakingTokenPercentage, _updateMinimumStakingTokenPercentageEnabled);
+    emit LogChainConfig(
+      _blocksPerPropose,
+      _blocksPerReveal,
+      _minimumStakingTokenPercentage,
+      _updateMinimumStakingTokenPercentageEnabled
+    );
   }
 
   function getInitialBlockHeight(uint256 _shard) public view returns (uint256) {
@@ -147,7 +162,7 @@ contract ChainStorage is StorageBase {
   }
 
   function updateBlockVoter(uint256 _blockHeight, address _voterAddr, bytes32 _blindedProposal, uint256 _shard, uint256 _balance)
-    external onlyFromStorageOwner returns (bool) {
+  external onlyFromStorageOwner returns (bool) {
     Voter storage voter = blocks[_blockHeight].voters[_voterAddr];
     voter.blindedProposal = _blindedProposal;
     voter.shard = _shard;
@@ -170,7 +185,7 @@ contract ChainStorage is StorageBase {
     require(_minimumStakingTokenPercentage <= 100, "_minimumStakingTokenPercentage can't be over 100%");
     minimumStakingTokenPercentage = _minimumStakingTokenPercentage;
 
-    emit LogChainConfig(blocksPerPhase, _minimumStakingTokenPercentage, true);
+    emit LogChainConfig(blocksPerPropose, blocksPerReveal, _minimumStakingTokenPercentage, true);
 
     return true;
   }

migrations/2.0_deploy_chain_storage.js

@@ -7,7 +7,8 @@ module.exports = (deployer, network, accounts) => {
 
   return deployer.deploy(
     ChainStorageArtifact,
-    config.Chain.blocksPerPhase,
+    config.Chain.blocksPerPropose,
+    config.Chain.blocksPerReveal,
     config.Chain.minimumStakingTokenPercentage,
     false,
     options,

migrations/deployers/ChainStorage.js

@@ -10,7 +10,8 @@ module.exports = (
 
   return deployer.deploy(
     ChainStorageArtifact,
-    config.Chain.blocksPerPhase,
+    config.Chain.blocksPerPropose,
+    config.Chain.blocksPerReveal,
     config.Chain.minimumStakingTokenPercentage,
     false,
     options,

test/helpers/CycleFunctions.js

@@ -1,25 +1,29 @@
-function blockOfCycle(currentBlock, phaseDuration) {
-  return currentBlock % (phaseDuration * 2);
+function blockOfCycle(currentBlock, cycleDuration) {
+  return currentBlock % cycleDuration;
 }
 
-function isProposePhase(currentBlock, phaseDuration) {
-  return blockOfCycle(currentBlock, phaseDuration) < phaseDuration;
+function isProposePhase(currentBlock, proposePhaseDuration, revealPhaseDuration) {
+  const cycleBlock = blockOfCycle(currentBlock, proposePhaseDuration + revealPhaseDuration);
+  return cycleBlock < proposePhaseDuration;
 }
 
-function isRevealPhase(currentBlock, phaseDuration) {
-  return !isProposePhase(currentBlock, phaseDuration);
+function isRevealPhase(currentBlock, proposePhaseDuration, revealPhaseDuration) {
+  return !isProposePhase(currentBlock, proposePhaseDuration, revealPhaseDuration);
 }
 
-function blocksToWaitForPropose(currentBlock, phaseDuration) {
-  if (isProposePhase(currentBlock, phaseDuration)) return 0;
+function blocksToWaitForPropose(currentBlock, proposePhaseDuration, revealPhaseDuration) {
+  if (isProposePhase(currentBlock, proposePhaseDuration, revealPhaseDuration)) return 0;
 
-  return (phaseDuration * 2) - blockOfCycle(currentBlock, phaseDuration);
+  // +1 because we want to be in first block in a phase
+  return (proposePhaseDuration + revealPhaseDuration + 1) -
+    blockOfCycle(currentBlock, proposePhaseDuration + revealPhaseDuration);
 }
 
-function blocksToWaitForReveal(currentBlock, phaseDuration) {
-  if (isRevealPhase(currentBlock, phaseDuration)) return 0;
+function blocksToWaitForReveal(currentBlock, proposePhaseDuration, revealPhaseDuration) {
+  if (isRevealPhase(currentBlock, proposePhaseDuration, revealPhaseDuration)) return 0;
 
-  return phaseDuration - blockOfCycle(currentBlock, phaseDuration);
+  return proposePhaseDuration -
+    blockOfCycle(currentBlock, proposePhaseDuration + revealPhaseDuration);
 }
 
 export {

test/helpers/SpecHelper.js

@@ -37,6 +37,8 @@ const advanceToBlock = async (number) => {
   const blockNumber = await web3.eth.getBlockNumber();
   if (blockNumber > number) {
     throw Error(`block number ${number} is in the past (current is ${blockNumber})`);
+  } else if (blockNumber === number) {
+    return Promise.resolve();
   }
 
   const awaits = [];
@@ -50,30 +52,32 @@ const advanceToBlock = async (number) => {
   return Promise.all(awaits);
 };
 
-const mineUntilPropose = async (phaseDuration) => {
+const mineUntilPropose = async (proposePhaseDuration, revealPhaseDuration) => {
   const blockNumber = await web3.eth.getBlockNumber();
+
   const toMine =
-    blocksToWaitForPropose(blockNumber, phaseDuration);
+    blocksToWaitForPropose(blockNumber, proposePhaseDuration, revealPhaseDuration);
 
   const prosalStartBlockNumber = new BigNumber(blockNumber).plus(toMine);
 
   await advanceToBlock(prosalStartBlockNumber.toNumber());
 };
 
-const mineUntilReveal = async (phaseDuration) => {
+const mineUntilReveal = async (proposePhaseDuration, revealPhaseDuration) => {
   const blockNumber = await web3.eth.getBlockNumber();
+
   const toMine =
-    blocksToWaitForReveal(blockNumber, phaseDuration);
+    blocksToWaitForReveal(blockNumber, proposePhaseDuration, revealPhaseDuration);
 
   const revealStartBlockNumber = new BigNumber(blockNumber).plus(toMine);
   await advanceToBlock(revealStartBlockNumber.toNumber());
 };
 
-const getBlockHeight = async (phaseDuration) => {
+const getBlockHeight = async (proposePhaseDuration, revealPhaseDuration) => {
   const blockNumber = await web3.eth.getBlockNumber();
+
   return BigNumber(blockNumber)
-    .div(phaseDuration, 10)
-    .div(2, 10)
+    .div(parseInt(proposePhaseDuration, 10) + parseInt(revealPhaseDuration, 10), 10)
     .toString(10)
     .split('.')[0];
 };