@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/README.md

@@ -1,5 +1,110 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=%40harvest-finance%2Fharvest-strategy-polygon for more information.
+# Polygon Chain: Harvest Strategy Development
+
+This [Hardhat](https://hardhat.org/) environment is configured to use Mainnet fork by default and provides templates and utilities for strategy development and testing.
+
+## Installation
+
+1. Run `npm install` to install all the dependencies.
+2. Sign up on [Alchemy](https://dashboard.alchemyapi.io/signup/). We recommend using Alchemy over Infura to allow for a reproducible
+Mainnet fork testing environment as well as efficiency due to caching.
+3. Create a file `dev-keys.json`:
+  ```
+    {
+      "alchemyKey": "<your-alchemy-key>"
+    }
+  ```
+
+## Run
+
+All tests are located under the `test` folder.
+
+1. Run `npx hardhat test [test file location]`: `npx hardhat test ./test/curve/aave.js` (if for some reason the NodeJS heap runs out of memory, make sure to explicitly increase its size via `export NODE_OPTIONS=--max_old_space_size=4096`). This will produce the following output:
+  ```
+  Polygon Mainnet Curve Aave
+Impersonating...
+0xf00dD244228F51547f0563e60bCa65a30FBF5f7f
+Fetching Underlying at:  0xE7a24EF0C5e95Ffb0f6684b813A78F2a3AD7D171
+New Vault Deployed:  0xF8ce90c2710713552fb564869694B2505Bfc0846
+Strategy Deployed:  0xDDa0648FA8c9cD593416EC37089C2a2E6060B45c
+Strategy and vault added to Controller.
+    Happy path
+loop  0
+old shareprice:  1000000000000000000
+new shareprice:  1000000000000000000
+growth:  1
+loop  1
+old shareprice:  1000000000000000000
+new shareprice:  1000141138681462160
+growth:  1.000141138681462
+loop  2
+old shareprice:  1000141138681462160
+new shareprice:  1000327782939361291
+growth:  1.000186617918892
+loop  3
+old shareprice:  1000327782939361291
+new shareprice:  1000514426794411531
+growth:  1.0001865826964256
+loop  4
+old shareprice:  1000514426794411531
+new shareprice:  1000701097344949064
+growth:  1.0001865745715788
+loop  5
+old shareprice:  1000701097344949064
+new shareprice:  1000878677026348228
+growth:  1.0001774552679819
+loop  6
+old shareprice:  1000878677026348228
+new shareprice:  1001019907056855214
+growth:  1.0001411060438679
+loop  7
+old shareprice:  1001019907056855214
+new shareprice:  1001161152484596161
+growth:  1.0001411015173078
+loop  8
+old shareprice:  1001161152484596161
+new shareprice:  1001302413308521684
+growth:  1.0001410969888065
+loop  9
+old shareprice:  1001302413308521684
+new shareprice:  1001443692715028091
+growth:  1.000141095641665
+earned!
+APR: 11.570408862519965 %
+APY: 12.264303010549993 %
+      √ Farmer should earn money (45307ms)
+
+
+  1 passing (1m)
+  ```
+
+## Develop
+
+Under `contracts/strategies`, there are plenty of examples to choose from in the repository already, therefore, creating a strategy is no longer a complicated task. Copy-pasting existing strategies with minor modifications is acceptable.
+
+Under `contracts/base`, there are existing base interfaces and contracts that can speed up development.
+Base contracts currently exist for developing SNX and MasterChef-based strategies.
+
+Note that the Universal Liquidator will not be available on BSC until a later stage of this project.
+
+## Contribute
+
+When ready, open a pull request with the following information:
+1. Instructions on how to run the test and at which block number
+2. A **mainnet fork test output** (like the one above in the README) clearly showing the increases of share price
+3. Info about the protocol, including:
+   - Live farm page(s)
+   - GitHub link(s)
+   - Etherscan link(s)
+   - Start/end dates for rewards
+   - Any limitations (e.g., maximum pool size)
+   - Current pool sizes used for liquidation (to make sure they are not too shallow)
+
+   The first few items can be omitted for well-known protocols (such as `curve.fi`).
+
+5. A description of **potential value** for Harvest: why should your strategy be live? High APYs, decent pool sizes, longevity of rewards, well-secured protocols, high-potential collaborations, etc.
+
+A more extensive checklist for assessing protocols and farming opportunities can be found [here](https://www.notion.so/harvestfinance/Farm-ops-check-list-7cd2e0d9da364252ac465cb8a176f0e0)
+
+## Deployment
+
+If your pull request is merged and given a green light for deployment, the Harvest team will take care of on-chain deployment.

package/contracts/base/Controller.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+
+import "./interface/IController.sol";
+import "./interface/IStrategy.sol";
+import "./interface/IVault.sol";
+import "./FeeRewardForwarder.sol";
+import "./inheritance/Governable.sol";
+
+contract Controller is IController, Governable {
+
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    using Address for address;
+    using SafeMath for uint256;
+
+    // external parties
+    address public override feeRewardForwarder;
+
+    // [Grey list]
+    // An EOA can safely interact with the system no matter what.
+    // If you're using Metamask, you're using an EOA.
+    // Only smart contracts may be affected by this grey list.
+    //
+    // This contract will not be able to ban any EOA from the system
+    // even if an EOA is being added to the greyList, he/she will still be able
+    // to interact with the whole system as if nothing happened.
+    // Only smart contracts will be affected by being added to the greyList.
+    mapping (address => bool) public override greyList;
+
+    uint256 public constant override profitSharingNumerator = 5;
+    uint256 public constant override profitSharingDenominator = 100;
+
+    event SharePriceChangeLog(
+      address indexed vault,
+      address indexed strategy,
+      uint256 oldSharePrice,
+      uint256 newSharePrice,
+      uint256 timestamp
+    );
+
+    mapping (address => bool) public hardWorkers;
+
+    modifier onlyHardWorkerOrGovernance() {
+        require(hardWorkers[msg.sender] || (msg.sender == governance()),
+        "only hard worker can call this");
+        _;
+    }
+
+    constructor(address _storage, address _feeRewardForwarder)
+    Governable(_storage) public {
+        require(_feeRewardForwarder != address(0), "feeRewardForwarder should not be empty");
+        feeRewardForwarder = _feeRewardForwarder;
+    }
+
+    function addHardWorker(address _worker) public onlyGovernance {
+      require(_worker != address(0), "_worker must be defined");
+      hardWorkers[_worker] = true;
+    }
+
+    function removeHardWorker(address _worker) public onlyGovernance {
+      require(_worker != address(0), "_worker must be defined");
+      hardWorkers[_worker] = false;
+    }
+
+    // Only smart contracts will be affected by the greyList.
+    function addToGreyList(address _target) public onlyGovernance {
+        greyList[_target] = true;
+    }
+
+    function removeFromGreyList(address _target) public onlyGovernance {
+        greyList[_target] = false;
+    }
+
+    function setFeeRewardForwarder(address _feeRewardForwarder) public override onlyGovernance {
+      require(_feeRewardForwarder != address(0), "new reward forwarder should not be empty");
+      feeRewardForwarder = _feeRewardForwarder;
+    }
+
+    function addVaultAndStrategy(address _vault, address _strategy) external override onlyGovernance {
+        require(_vault != address(0), "new vault shouldn't be empty");
+        require(_strategy != address(0), "new strategy shouldn't be empty");
+
+        // adding happens while setting
+        IVault(_vault).setStrategy(_strategy);
+    }
+
+    function doHardWork(address _vault) external override onlyHardWorkerOrGovernance {
+        uint256 oldSharePrice = IVault(_vault).getPricePerFullShare();
+        IVault(_vault).doHardWork();
+        emit SharePriceChangeLog(
+          _vault,
+          IVault(_vault).strategy(),
+          oldSharePrice,
+          IVault(_vault).getPricePerFullShare(),
+          block.timestamp
+        );
+    }
+
+    // transfers token in the controller contract to the governance
+    function salvage(address _token, uint256 _amount) external override onlyGovernance {
+        IERC20Upgradeable(_token).safeTransfer(governance(), _amount);
+    }
+
+    function salvageStrategy(address _strategy, address _token, uint256 _amount) external override onlyGovernance {
+        // the strategy is responsible for maintaining the list of
+        // salvagable tokens, to make sure that governance cannot come
+        // in and take away the coins
+        IStrategy(_strategy).salvage(governance(), _token, _amount);
+    }
+
+    function notifyFee(address underlying, uint256 fee) external override {
+      if (fee > 0) {
+        IERC20Upgradeable(underlying).safeTransferFrom(msg.sender, address(this), fee);
+        IERC20Upgradeable(underlying).safeApprove(feeRewardForwarder, 0);
+        IERC20Upgradeable(underlying).safeApprove(feeRewardForwarder, fee);
+        FeeRewardForwarder(feeRewardForwarder).poolNotifyFixedTarget(underlying, fee);
+      }
+    }
+}

package/contracts/base/ControllerV2.sol

@@ -0,0 +1,363 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import "./inheritance/Governable.sol";
+
+import "./interface/IStrategy.sol";
+import "./interface/IVault.sol";
+
+import "./RewardForwarderV2.sol";
+
+
+contract ControllerV2 is Governable {
+    using SafeERC20 for IERC20;
+    using Address for address;
+    using SafeMath for uint256;
+
+    // ========================= Fields =========================
+
+    // external parties
+    address public targetToken;
+    address public protocolFeeReceiver;
+    address public profitSharingReceiver;
+    address public rewardForwarder;
+    address public universalLiquidator;
+
+    uint256 public nextImplementationDelay;
+
+    /// 15% of fees captured go to iFARM stakers
+    uint256 public profitSharingNumerator = 500;
+    uint256 public nextProfitSharingNumerator = 0;
+    uint256 public nextProfitSharingNumeratorTimestamp = 0;
+
+    /// 5% of fees captured go to strategists
+    uint256 public strategistFeeNumerator = 0;
+    uint256 public nextStrategistFeeNumerator = 0;
+    uint256 public nextStrategistFeeNumeratorTimestamp = 0;
+
+    /// 5% of fees captured go to the devs of the platform
+    uint256 public platformFeeNumerator = 300;
+    uint256 public nextPlatformFeeNumerator = 0;
+    uint256 public nextPlatformFeeNumeratorTimestamp = 0;
+
+    /// used for queuing a new delay
+    uint256 public tempNextImplementationDelay = 0;
+    uint256 public tempNextImplementationDelayTimestamp = 0;
+
+    uint256 public constant MAX_TOTAL_FEE = 3000;
+    uint256 public constant FEE_DENOMINATOR = 10000;
+
+    /// @notice This mapping allows certain contracts to stake on a user's behalf
+    mapping (address => bool) public addressWhitelist;
+    mapping (bytes32 => bool) public codeWhitelist;
+
+    // All eligible hardWorkers that we have
+    mapping (address => bool) public hardWorkers;
+
+    // ========================= Events =========================
+
+    event QueueProfitSharingChange(uint profitSharingNumerator, uint validAtTimestamp);
+    event ConfirmProfitSharingChange(uint profitSharingNumerator);
+
+    event QueueStrategistFeeChange(uint strategistFeeNumerator, uint validAtTimestamp);
+    event ConfirmStrategistFeeChange(uint strategistFeeNumerator);
+
+    event QueuePlatformFeeChange(uint platformFeeNumerator, uint validAtTimestamp);
+    event ConfirmPlatformFeeChange(uint platformFeeNumerator);
+
+    event QueueNextImplementationDelay(uint implementationDelay, uint validAtTimestamp);
+    event ConfirmNextImplementationDelay(uint implementationDelay);
+
+    event AddedAddressToWhitelist(address indexed _address);
+    event RemovedAddressFromWhitelist(address indexed _address);
+
+    event AddedCodeToWhitelist(address indexed _address);
+    event RemovedCodeFromWhitelist(address indexed _address);
+
+    event SharePriceChangeLog(
+        address indexed vault,
+        address indexed strategy,
+        uint256 oldSharePrice,
+        uint256 newSharePrice,
+        uint256 timestamp
+    );
+
+    // ========================= Modifiers =========================
+
+    modifier onlyHardWorkerOrGovernance() {
+        require(hardWorkers[msg.sender] || (msg.sender == governance()),
+            "only hard worker can call this");
+        _;
+    }
+
+    constructor(
+        address _storage,
+        address _targetToken,
+        address _protocolFeeReceiver,
+        address _profitSharingReceiver,
+        address _rewardForwarder,
+        address _universalLiquidator,
+        uint _nextImplementationDelay
+    )
+    Governable(_storage)
+    public {
+        require(_targetToken != address(0), "_targetToken should not be empty");
+        require(_protocolFeeReceiver != address(0), "_protocolFeeReceiver should not be empty");
+        require(_profitSharingReceiver != address(0), "_profitSharingReceiver should not be empty");
+        require(_rewardForwarder != address(0), "_rewardForwarder should not be empty");
+        require(_nextImplementationDelay > 0, "_nextImplementationDelay should be gt 0");
+
+        targetToken = _targetToken;
+        protocolFeeReceiver = _protocolFeeReceiver;
+        profitSharingReceiver = _profitSharingReceiver;
+        rewardForwarder = _rewardForwarder;
+        universalLiquidator = _universalLiquidator;
+        nextImplementationDelay = _nextImplementationDelay;
+    }
+
+        // [Grey list]
+    // An EOA can safely interact with the system no matter what.
+    // If you're using Metamask, you're using an EOA.
+    // Only smart contracts may be affected by this grey list.
+    //
+    // This contract will not be able to ban any EOA from the system
+    // even if an EOA is being added to the greyList, he/she will still be able
+    // to interact with the whole system as if nothing happened.
+    // Only smart contracts will be affected by being added to the greyList.
+    function greyList(address _addr) public view returns (bool) {
+        return !addressWhitelist[_addr] && !codeWhitelist[getContractHash(_addr)];
+    }
+
+    // Only smart contracts will be affected by the whitelist.
+    function addToWhitelist(address _target) public onlyGovernance {
+        addressWhitelist[_target] = true;
+        emit AddedAddressToWhitelist(_target);
+    }
+
+    function addMultipleToWhitelist(address[] memory _targets) public onlyGovernance {
+        for (uint256 i = 0; i < _targets.length; i++) {
+        addressWhitelist[_targets[i]] = true;
+        }
+    }
+
+    function removeFromWhitelist(address _target) public onlyGovernance {
+        addressWhitelist[_target] = false;
+        emit RemovedAddressFromWhitelist(_target);
+    }
+
+    function removeMultipleFromWhitelist(address[] memory _targets) public onlyGovernance {
+        for (uint256 i = 0; i < _targets.length; i++) {
+        addressWhitelist[_targets[i]] = false;
+        }
+    }
+
+    function getContractHash(address a) public view returns (bytes32 hash) {
+        assembly {
+        hash := extcodehash(a)
+        }
+    }
+
+    function addCodeToWhitelist(address _target) public onlyGovernance {
+        codeWhitelist[getContractHash(_target)] = true;
+        emit AddedCodeToWhitelist(_target);
+    }
+
+    function removeCodeFromWhitelist(address _target) public onlyGovernance {
+        codeWhitelist[getContractHash(_target)] = false;
+        emit RemovedCodeFromWhitelist(_target);
+    }
+
+    function setRewardForwarder(address _rewardForwarder) public onlyGovernance {
+        require(_rewardForwarder != address(0), "new reward forwarder should not be empty");
+        rewardForwarder = _rewardForwarder;
+    }
+
+    function setTargetToken(address _targetToken) public onlyGovernance {
+        require(_targetToken != address(0), "new target token should not be empty");
+        targetToken = _targetToken;
+    }
+
+    function setProfitSharingReceiver(address _profitSharingReceiver) public onlyGovernance {
+        require(_profitSharingReceiver != address(0), "new profit sharing receiver should not be empty");
+        profitSharingReceiver = _profitSharingReceiver;
+    }
+
+    function setProtocolFeeReceiver(address _protocolFeeReceiver) public onlyGovernance {
+        require(_protocolFeeReceiver != address(0), "new protocol fee receiver should not be empty");
+        protocolFeeReceiver = _protocolFeeReceiver;
+    }
+
+    function setUniversalLiquidator(address _universalLiquidator) public onlyGovernance {
+        require(_universalLiquidator != address(0), "new universal liquidator should not be empty");
+        universalLiquidator = _universalLiquidator;
+    }
+
+    function getPricePerFullShare(address _vault) public view returns (uint256) {
+        return IVault(_vault).getPricePerFullShare();
+    }
+
+    function doHardWork(address _vault) external onlyHardWorkerOrGovernance {
+        uint256 oldSharePrice = IVault(_vault).getPricePerFullShare();
+        IVault(_vault).doHardWork();
+        emit SharePriceChangeLog(
+            _vault,
+            IVault(_vault).strategy(),
+            oldSharePrice,
+            IVault(_vault).getPricePerFullShare(),
+            block.timestamp
+        );
+    }
+
+    function notifyFee(address _token, uint256 _feeAmount) external {
+        IERC20(_token).safeTransferFrom(msg.sender, address(this), _feeAmount);
+        uint256 totalFee = profitSharingNumerator.add(strategistFeeNumerator).add(platformFeeNumerator);
+        uint256 profitShareAmount = _feeAmount.mul(profitSharingNumerator).div(totalFee);
+        uint256 strategistAmount = _feeAmount.mul(strategistFeeNumerator).div(totalFee);
+        uint256 platformAmount = _feeAmount.mul(platformFeeNumerator).div(totalFee);
+
+        IERC20(_token).safeApprove(rewardForwarder, 0);
+        IERC20(_token).safeApprove(rewardForwarder, _feeAmount);
+        RewardForwarderV2(rewardForwarder).notifyFee(_token, profitShareAmount, strategistAmount, platformAmount);
+    }
+
+    function addHardWorker(address _worker) public onlyGovernance {
+        require(_worker != address(0), "_worker must be defined");
+        hardWorkers[_worker] = true;
+    }
+
+    function removeHardWorker(address _worker) public onlyGovernance {
+        require(_worker != address(0), "_worker must be defined");
+        hardWorkers[_worker] = false;
+    }
+
+    // transfers token in the controller contract to the governance
+    function salvage(address _token, uint256 _amount) external onlyGovernance {
+        IERC20(_token).safeTransfer(governance(), _amount);
+    }
+
+    function salvageStrategy(address _strategy, address _token, uint256 _amount) external onlyGovernance {
+        // the strategy is responsible for maintaining the list of
+        // salvageable tokens, to make sure that governance cannot come
+        // in and take away the coins
+        IStrategy(_strategy).salvageToken(governance(), _token, _amount);
+    }
+
+    function feeDenominator() public pure returns (uint) {
+        // keep the interface for this function as a `view` for now, in case it changes in the future
+        return FEE_DENOMINATOR;
+    }
+
+    function setProfitSharingNumerator(uint _profitSharingNumerator) public onlyGovernance {
+        require(
+            _profitSharingNumerator + strategistFeeNumerator + platformFeeNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        nextProfitSharingNumerator = _profitSharingNumerator;
+        nextProfitSharingNumeratorTimestamp = block.timestamp + nextImplementationDelay;
+        emit QueueProfitSharingChange(nextProfitSharingNumerator, nextProfitSharingNumeratorTimestamp);
+    }
+
+    function confirmSetProfitSharingNumerator() public onlyGovernance {
+        require(
+            nextProfitSharingNumerator != 0
+            && nextProfitSharingNumeratorTimestamp != 0
+            && block.timestamp >= nextProfitSharingNumeratorTimestamp,
+            "invalid timestamp or no new profit sharing numerator confirmed"
+        );
+        require(
+            nextProfitSharingNumerator + strategistFeeNumerator + platformFeeNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        profitSharingNumerator = nextProfitSharingNumerator;
+        nextProfitSharingNumerator = 0;
+        nextProfitSharingNumeratorTimestamp = 0;
+        emit ConfirmProfitSharingChange(profitSharingNumerator);
+    }
+
+    function setStrategistFeeNumerator(uint _strategistFeeNumerator) public onlyGovernance {
+        require(
+            _strategistFeeNumerator + platformFeeNumerator + profitSharingNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        nextStrategistFeeNumerator = _strategistFeeNumerator;
+        nextStrategistFeeNumeratorTimestamp = block.timestamp + nextImplementationDelay;
+        emit QueueStrategistFeeChange(nextStrategistFeeNumerator, nextStrategistFeeNumeratorTimestamp);
+    }
+
+    function confirmSetStrategistFeeNumerator() public onlyGovernance {
+        require(
+            nextStrategistFeeNumerator != 0
+            && nextStrategistFeeNumeratorTimestamp != 0
+            && block.timestamp >= nextStrategistFeeNumeratorTimestamp,
+            "invalid timestamp or no new strategist fee numerator confirmed"
+        );
+        require(
+            nextStrategistFeeNumerator + platformFeeNumerator + profitSharingNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        strategistFeeNumerator = nextStrategistFeeNumerator;
+        nextStrategistFeeNumerator = 0;
+        nextStrategistFeeNumeratorTimestamp = 0;
+        emit ConfirmStrategistFeeChange(strategistFeeNumerator);
+    }
+
+    function setPlatformFeeNumerator(uint _platformFeeNumerator) public onlyGovernance {
+        require(
+            _platformFeeNumerator + strategistFeeNumerator + profitSharingNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        nextPlatformFeeNumerator = _platformFeeNumerator;
+        nextPlatformFeeNumeratorTimestamp = block.timestamp + nextImplementationDelay;
+        emit QueuePlatformFeeChange(nextPlatformFeeNumerator, nextPlatformFeeNumeratorTimestamp);
+    }
+
+    function confirmSetPlatformFeeNumerator() public onlyGovernance {
+        require(
+            nextPlatformFeeNumerator != 0
+            && nextPlatformFeeNumeratorTimestamp != 0
+            && block.timestamp >= nextPlatformFeeNumeratorTimestamp,
+            "invalid timestamp or no new platform fee numerator confirmed"
+        );
+        require(
+            nextPlatformFeeNumerator + strategistFeeNumerator + profitSharingNumerator <= MAX_TOTAL_FEE,
+            "total fee too high"
+        );
+
+        platformFeeNumerator = nextPlatformFeeNumerator;
+        nextPlatformFeeNumerator = 0;
+        nextPlatformFeeNumeratorTimestamp = 0;
+        emit ConfirmPlatformFeeChange(platformFeeNumerator);
+    }
+
+    function setNextImplementationDelay(uint256 _nextImplementationDelay) public onlyGovernance {
+        require(
+            _nextImplementationDelay > 0,
+            "invalid _nextImplementationDelay"
+        );
+
+        tempNextImplementationDelay = _nextImplementationDelay;
+        tempNextImplementationDelayTimestamp = block.timestamp + nextImplementationDelay;
+        emit QueueNextImplementationDelay(tempNextImplementationDelay, tempNextImplementationDelayTimestamp);
+    }
+
+    function confirmNextImplementationDelay() public onlyGovernance {
+        require(
+            tempNextImplementationDelayTimestamp != 0 && block.timestamp >= tempNextImplementationDelayTimestamp,
+            "invalid timestamp or no new implementation delay confirmed"
+        );
+        nextImplementationDelay = tempNextImplementationDelay;
+        tempNextImplementationDelay = 0;
+        tempNextImplementationDelayTimestamp = 0;
+        emit ConfirmNextImplementationDelay(nextImplementationDelay);
+    }
+}