epochs: make epoch manager upgradeable (#256)

Author: abarmat

contracts/curation/Curation.sol

@@ -72,9 +72,15 @@ contract Curation is CurationV1Storage, ICuration, Governed {
     /**
      * @dev Initialize this contract.
      */
-    function initialize(address _token) external onlyGovernorOrInit {
+    function initialize(
+        address _token,
+        uint32 _defaultReserveRatio,
+        uint256 _minimumCurationStake
+    ) external onlyGovernorOrInit {
         BancorFormula._initialize();
         token = IGraphToken(_token);
+        defaultReserveRatio = _defaultReserveRatio;
+        minimumCurationStake = _minimumCurationStake;
     }
 
     /**
@@ -84,7 +90,7 @@ contract Curation is CurationV1Storage, ICuration, Governed {
      * @param _defaultReserveRatio Reserve ratio to initialize the bonding curve of CurationPool
      * @param _minimumCurationStake Minimum amount of tokens that curators can stake
      */
-    function acceptUpgrade(
+    function acceptProxy(
         GraphProxy _proxy,
         address _token,
         uint32 _defaultReserveRatio,
@@ -96,9 +102,7 @@ contract Curation is CurationV1Storage, ICuration, Governed {
         _proxy.acceptImplementation();
 
         // Initialization
-        Curation(address(_proxy)).initialize(_token);
-        Curation(address(_proxy)).setDefaultReserveRatio(_defaultReserveRatio);
-        Curation(address(_proxy)).setMinimumCurationStake(_minimumCurationStake);
+        Curation(address(_proxy)).initialize(_token, _defaultReserveRatio, _minimumCurationStake);
     }
 
     /**

contracts/EpochManager.sol renamed to contracts/epochs/EpochManager.sol

@@ -2,37 +2,36 @@ pragma solidity ^0.6.4;
 
 import "@openzeppelin/contracts/math/SafeMath.sol";
 
-import "./governance/Governed.sol";
+import "../governance/Governed.sol";
+import "../upgrades/GraphProxy.sol";
+
+import "./EpochManagerStorage.sol";
+import "./IEpochManager.sol";
 
 /**
  * @title EpochManager contract
  * @dev Tracks epochs based on its block duration to sync contracts in the protocol.
  */
-contract EpochManager is Governed {
+contract EpochManager is EpochManagerV1Storage, IEpochManager, Governed {
     using SafeMath for uint256;
 
-    // -- State --
-
-    // Epoch length in blocks
-    uint256 public epochLength;
-
-    // Epoch that was last run
-    uint256 public lastRunEpoch;
-
-    // Block and epoch when epoch length was last updated
-    uint256 public lastLengthUpdateEpoch;
-    uint256 public lastLengthUpdateBlock;
-
     // -- Events --
 
     event EpochRun(uint256 indexed epoch, address caller);
     event EpochLengthUpdate(uint256 indexed epoch, uint256 epochLength);
 
     /**
-     * @dev Contract Constructor.
-     * @param _epochLength Epoch length in blocks
+     * @dev Check if the caller is the governor or initializing the implementation.
      */
-    constructor(uint256 _epochLength) public {
+    modifier onlyGovernorOrInit {
+        require(msg.sender == governor || msg.sender == implementation, "Only Governor can call");
+        _;
+    }
+
+    /**
+     * @dev Initialize this contract.
+     */
+    function initialize(uint256 _epochLength) external onlyGovernorOrInit {
         require(_epochLength > 0, "Epoch length cannot be 0");
 
         lastLengthUpdateEpoch = 0;
@@ -42,12 +41,27 @@ contract EpochManager is Governed {
         emit EpochLengthUpdate(lastLengthUpdateEpoch, epochLength);
     }
 
+    /**
+     * @dev Accept to be an implementation of proxy and run initializer.
+     * @param _proxy Graph proxy delegate caller
+     * @param _epochLength Epoch length in blocks
+     */
+    function acceptProxy(GraphProxy _proxy, uint256 _epochLength) external {
+        require(msg.sender == _proxy.governor(), "Only proxy governor can upgrade");
+
+        // Accept to be the implementation for this proxy
+        _proxy.acceptImplementation();
+
+        // Initialization
+        EpochManager(address(_proxy)).initialize(_epochLength);
+    }
+
     /**
      * @dev Set the epoch length.
      * @notice Set epoch length to `_epochLength` blocks
      * @param _epochLength Epoch length in blocks
      */
-    function setEpochLength(uint256 _epochLength) external onlyGovernor {
+    function setEpochLength(uint256 _epochLength) external override onlyGovernor {
         require(_epochLength > 0, "Epoch length cannot be 0");
         require(_epochLength != epochLength, "Epoch length must be different to current");
 
@@ -62,7 +76,7 @@ contract EpochManager is Governed {
      * @dev Run a new epoch, should be called once at the start of any epoch.
      * @notice Perform state changes for the current epoch
      */
-    function runEpoch() external {
+    function runEpoch() external override {
         // Check if already called for the current epoch
         require(!isCurrentEpochRun(), "Current epoch already run");
 
@@ -77,23 +91,23 @@ contract EpochManager is Governed {
      * @dev Return true if the current epoch has already run.
      * @return Return true if epoch has run
      */
-    function isCurrentEpochRun() public view returns (bool) {
+    function isCurrentEpochRun() public override view returns (bool) {
         return lastRunEpoch == currentEpoch();
     }
 
     /**
      * @dev Return current block number.
      * @return Block number
      */
-    function blockNum() public view returns (uint256) {
+    function blockNum() public override view returns (uint256) {
         return block.number;
     }
 
     /**
      * @dev Return blockhash for a block.
      * @return BlockHash for `_block` number
      */
-    function blockHash(uint256 _block) public view returns (bytes32) {
+    function blockHash(uint256 _block) public override view returns (bytes32) {
         uint256 currentBlock = blockNum();
 
         require(_block < currentBlock, "Can only retrieve past block hashes");
@@ -109,23 +123,23 @@ contract EpochManager is Governed {
      * @dev Return the current epoch, it may have not been run yet.
      * @return The current epoch based on epoch length
      */
-    function currentEpoch() public view returns (uint256) {
+    function currentEpoch() public override view returns (uint256) {
         return lastLengthUpdateEpoch.add(epochsSinceUpdate());
     }
 
     /**
      * @dev Return block where the current epoch started.
      * @return The block number when the current epoch started
      */
-    function currentEpochBlock() public view returns (uint256) {
+    function currentEpochBlock() public override view returns (uint256) {
         return lastLengthUpdateBlock.add(epochsSinceUpdate().mul(epochLength));
     }
 
     /**
      * @dev Return the number of blocks that passed since current epoch started.
      * @return Blocks that passed since start of epoch
      */
-    function currentEpochBlockSinceStart() public view returns (uint256) {
+    function currentEpochBlockSinceStart() public override view returns (uint256) {
         return blockNum() - currentEpochBlock();
     }
 
@@ -134,7 +148,7 @@ contract EpochManager is Governed {
      * @param _epoch Epoch to use as since epoch value
      * @return Number of epochs and current epoch
      */
-    function epochsSince(uint256 _epoch) public view returns (uint256) {
+    function epochsSince(uint256 _epoch) public override view returns (uint256) {
         uint256 epoch = currentEpoch();
         return _epoch < epoch ? epoch.sub(_epoch) : 0;
     }
@@ -143,7 +157,7 @@ contract EpochManager is Governed {
      * @dev Return number of epochs passed since last epoch length update.
      * @return The number of epoch that passed since last epoch length update
      */
-    function epochsSinceUpdate() public view returns (uint256) {
+    function epochsSinceUpdate() public override view returns (uint256) {
         return blockNum().sub(lastLengthUpdateBlock).div(epochLength);
     }
 }

contracts/epochs/EpochManagerStorage.sol

@@ -0,0 +1,17 @@
+pragma solidity ^0.6.4;
+
+import "../upgrades/GraphProxyStorage.sol";
+
+contract EpochManagerV1Storage is GraphProxyStorage {
+    // -- State --
+
+    // Epoch length in blocks
+    uint256 public epochLength;
+
+    // Epoch that was last run
+    uint256 public lastRunEpoch;
+
+    // Block and epoch when epoch length was last updated
+    uint256 public lastLengthUpdateEpoch;
+    uint256 public lastLengthUpdateBlock;
+}

contracts/epochs/IEpochManager.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.6.4;
+
+interface IEpochManager {
+    // -- Configuration --
+
+    function setEpochLength(uint256 _epochLength) external;
+
+    // -- Epochs
+
+    function runEpoch() external;
+
+    // -- Getters --
+
+    function isCurrentEpochRun() external view returns (bool);
+
+    function blockNum() external view returns (uint256);
+
+    function blockHash(uint256 _block) external view returns (bytes32);
+
+    function currentEpoch() external view returns (uint256);
+
+    function currentEpochBlock() external view returns (uint256);
+
+    function currentEpochBlockSinceStart() external view returns (uint256);
+
+    function epochsSince(uint256 _epoch) external view returns (uint256);
+
+    function epochsSinceUpdate() external view returns (uint256);
+}

contracts/staking/Staking.sol

@@ -3,8 +3,8 @@ pragma experimental ABIEncoderV2;
 
 import "@nomiclabs/buidler/console.sol";
 
-import "../EpochManager.sol";
 import "../curation/ICuration.sol";
+import "../epochs/IEpochManager.sol";
 import "../governance/Governed.sol";
 import "../token/IGraphToken.sol";
 import "../upgrades/GraphProxy.sol";
@@ -205,7 +205,7 @@ contract Staking is StakingV1Storage, IStaking, Governed {
      */
     function initialize(address _token, address _epochManager) external onlyGovernorOrInit {
         token = IGraphToken(_token);
-        epochManager = EpochManager(_epochManager);
+        epochManager = IEpochManager(_epochManager);
     }
 
     /**
@@ -214,7 +214,7 @@ contract Staking is StakingV1Storage, IStaking, Governed {
      * @param _token Address of the Graph Protocol token
      * @param _epochManager Address of the EpochManager contract
      */
-    function acceptUpgrade(
+    function acceptProxy(
         GraphProxy _proxy,
         address _token,
         address _epochManager

contracts/staking/StakingStorage.sol

@@ -1,7 +1,7 @@
 pragma solidity ^0.6.4;
 
-import "../EpochManager.sol";
 import "../curation/ICuration.sol";
+import "../epochs/IEpochManager.sol";
 import "../staking/IStaking.sol";
 import "../token/IGraphToken.sol";
 import "../upgrades/GraphProxyStorage.sol";
@@ -68,6 +68,6 @@ contract StakingV1Storage is GraphProxyStorage {
     // -- Related contracts --
 
     IGraphToken public token;
-    EpochManager public epochManager;
+    IEpochManager public epochManager;
     ICuration public curation;
 }

contracts/upgrades/GraphProxy.sol

@@ -27,7 +27,7 @@ contract GraphProxy is GraphProxyStorage, Governed {
      * @dev Upgrades to a new implementation contract.
      * @param _newImplementation Address of implementation contract
      */
-    function upgradeTo(address _newImplementation) external onlyGovernor {
+    function setImplementation(address _newImplementation) external onlyGovernor {
         address oldPendingImplementation = pendingImplementation;
         pendingImplementation = _newImplementation;
 

graph.config.yml

@@ -20,6 +20,7 @@ contracts:
     slashingPercentage: 50000 # in basis points
   EpochManager:
     lengthInBlocks: 5760 # One day in blocks
+    __proxy: true
   GNS:
     didRegistry: "0xdca7ef03e98e0dc2b855be647c39abe984fcf21b"
   GraphToken:

scripts/cli/commands/upgrade.ts

@@ -59,12 +59,12 @@ export const upgrade = async (cli: CLIEnvironment, cliArgs: CLIArgs): Promise<vo
   // Upgrade to new implementation
   const pendingImplementation = (await proxy.functions['pendingImplementation']())[0]
   if (pendingImplementation != implAddress) {
-    await sendTransaction(cli.wallet, proxy, 'upgradeTo', ...[implAddress])
+    await sendTransaction(cli.wallet, proxy, 'setImplementation', ...[implAddress])
   }
 
   // Accept upgrade from the implementation
   const contractArgs = initArgs ? initArgs.split(',') : []
-  await sendTransaction(cli.wallet, contract, 'acceptUpgrade', ...[proxy.address, ...contractArgs])
+  await sendTransaction(cli.wallet, contract, 'acceptProxy', ...[proxy.address, ...contractArgs])
 
   // TODO
   // -- update entry

scripts/cli/deploy.ts

@@ -125,12 +125,12 @@ export const deployContractWithProxyAndSave = async (
   // Deploy implementation
   const contract = await deployContractAndSave(name, [], wallet, addressBook)
   // Upgrade to implementation
-  await sendTransaction(wallet, proxy, 'upgradeTo', contract.address)
+  await sendTransaction(wallet, proxy, 'setImplementation', contract.address)
   // Implementation accepts upgrade
   await sendTransaction(
     wallet,
     contract,
-    'acceptUpgrade',
+    'acceptProxy',
     ...[proxy.address, ...args.map((a) => a.value)],
   )