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

package/contracts/base/incentives/GlobalIncentivesHelper.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./NotifyHelperStateful.sol";
+import "./NotifyHelperGeneric.sol";
+import "../inheritance/Controllable.sol";
+
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+
+contract GlobalIncentivesHelper is Controllable {
+
+  using SafeMathUpgradeable for uint256;
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+
+  address public helperControlStorage;
+  address public notifyHelperGeneric;
+  address public escrow;
+  address public reserve;
+  address public farm;
+
+  event ChangerSet(address indexed account, bool value);
+  event NotifierSet(address indexed account, bool value);
+  event Vesting(address pool, uint256 amount);
+  event PoolChanged(address indexed pool, uint256 percentage, uint256 notificationType, bool vests);
+
+  enum NotificationType {
+    VOID, AMPLIFARM, FARM, TRANSFER, PROFIT_SHARE, TOKEN
+  }
+
+  mapping (address => address) public tokenToHelper;
+  mapping (address => bool) public changer;
+  mapping (address => bool) public notifier;
+
+  modifier onlyChanger {
+    require(changer[msg.sender] || msg.sender == governance(), "Only changer");
+    _;
+  }
+
+  modifier onlyNotifier {
+    require(notifier[msg.sender] || msg.sender == governance(), "Only notifier");
+    _;
+  }
+
+  constructor(address _storage, address _farm, address _farmHelper, address _notifyHelperGeneric, address _escrow, address _reserve) public Controllable(_storage) {
+    tokenToHelper[_farm] = _farmHelper;
+    farm = _farm;
+    notifyHelperGeneric = _notifyHelperGeneric;
+    helperControlStorage = address(new Storage());
+    escrow = _escrow;
+    reserve = _reserve;
+  }
+
+  function notifyPools(address[] calldata tokens, uint256[] calldata totals, uint256 timestamp) external onlyNotifier {
+    for (uint256 i = 0; i < tokens.length; i++) {
+      // IERC20Upgradeable(tokens[i]).safeTransferFrom(msg.sender, address(this), totals[i]);
+      IERC20Upgradeable(tokens[i]).approve(tokenToHelper[tokens[i]], totals[i]);
+      NotifyHelperStateful(tokenToHelper[tokens[i]]).notifyPools(totals[i], timestamp);
+    }
+  }
+
+  // uses generic helper
+  function newToken(address token) external onlyChanger {
+    newTokenWithHelper(token, notifyHelperGeneric);
+  }
+
+  // uses a specific notify helper
+  function newTokenWithHelper(address token, address notifyHelper) public onlyChanger {
+    require(tokenToHelper[token] == address(0), "Token already initialized");
+    tokenToHelper[token] = address(new NotifyHelperStateful(
+      helperControlStorage,
+      notifyHelper, // the universal helper should be sufficient in all cases
+      token,
+      address(0), // no iFARM/ampliFARM notify helper is needed
+      escrow,
+      reserve
+    ));
+    if (notifyHelper == notifyHelperGeneric) {
+      NotifyHelperGeneric(notifyHelper).setWhitelist(tokenToHelper[token], true);
+    }
+    NotifyHelperStateful(tokenToHelper[token]).setNotifier(address(this), true);
+    NotifyHelperStateful(tokenToHelper[token]).setNotifier(governance(), true);
+    NotifyHelperStateful(tokenToHelper[token]).setChanger(address(this), true);
+    NotifyHelperStateful(tokenToHelper[token]).setChanger(governance(), true);
+  }
+
+  function resetToken(address token) public onlyChanger {
+    tokenToHelper[token] = address(0);
+  }
+
+  /// Whitelisted entity makes changes to the notifications
+  function setPoolBatch(
+    address[] calldata tokens,
+    address[] calldata poolAddress,
+    uint256[] calldata poolPercentage,
+    NotificationType[] calldata notificationType,
+    bool[] calldata vests) external onlyChanger {
+    for (uint256 i = 0; i < poolAddress.length; i++) {
+      setPool(tokens[i], poolAddress[i], poolPercentage[i], notificationType[i], vests[i]);
+    }
+  }
+
+  /// Pool management, adds, updates or removes a transfer/notification
+  function setPool(
+    address token,
+    address poolAddress,
+    uint256 poolPercentage,
+    NotificationType notificationType,
+    bool vests
+  ) public onlyChanger {
+    if (token == farm) {
+      require(notificationType != NotificationType.TOKEN, "With FARM, use FARM, AMPLIFARM, or TRANSFER");
+    }
+    if (notificationType == NotificationType.TOKEN) {
+      // we use type translation so that we can use the same contract
+      NotifyHelperStateful(tokenToHelper[token]).setPool(poolAddress, poolPercentage,
+        NotifyHelperStateful.NotificationType(uint256(NotificationType.FARM)), vests);
+    } else {
+      NotifyHelperStateful(tokenToHelper[token]).setPool(poolAddress, poolPercentage,
+        NotifyHelperStateful.NotificationType(uint256(notificationType)), vests);
+    }
+    emit PoolChanged(poolAddress, poolPercentage, uint256(notificationType), vests);
+  }
+
+  /// emergency draining of tokens and ETH as there should be none staying here
+  function emergencyDrain(address token, uint256 amount) public onlyGovernance {
+    if (token == address(0)) {
+      msg.sender.transfer(amount);
+    } else {
+      IERC20Upgradeable(token).safeTransfer(msg.sender, amount);
+    }
+  }
+
+  /// Configuration method for vesting for governance
+  function setVestingEscrow(address token, address _escrow) external onlyGovernance {
+    NotifyHelperStateful(tokenToHelper[token]).setVestingEscrow(_escrow);
+  }
+
+  /// Configuration method for vesting for governance
+  function setVesting(address token, uint256 _numerator, uint256 _denominator) external onlyGovernance {
+    NotifyHelperStateful(tokenToHelper[token]).setVesting(_numerator, _denominator);
+  }
+
+  function notificationExists(address token, address poolAddress) public view returns(bool) {
+    return NotifyHelperStateful(tokenToHelper[token]).notificationExists(poolAddress);
+  }
+
+  /// Returning the governance
+  function transferGovernance(address target, address newStorage) external onlyGovernance {
+    Governable(target).setStorage(newStorage);
+  }
+
+  /// The governance configures whitelists
+  function setChanger(address who, bool value) external onlyGovernance {
+    changer[who] = value;
+    emit ChangerSet(who, value);
+  }
+
+  /// The governance configures whitelists
+  function setNotifier(address who, bool value) external onlyGovernance {
+    notifier[who] = value;
+    emit NotifierSet(who, value);
+  }
+}

package/contracts/base/incentives/NotifyHelperGeneric.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+import "../inheritance/Controllable.sol";
+import "../PotPool.sol";
+
+contract NotifyHelperGeneric is Controllable {
+
+  using SafeMathUpgradeable for uint256;
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+
+  event WhitelistSet(address who, bool value);
+
+  mapping (address => bool) public alreadyNotified;
+  mapping (address => bool) public whitelist;
+
+  modifier onlyWhitelisted {
+    require(whitelist[msg.sender] || msg.sender == governance(), "Only whitelisted");
+    _;
+  }
+
+  constructor(address _storage)
+  Controllable(_storage) public {
+    setWhitelist(governance(), true);
+  }
+
+  function setWhitelist(address who, bool value) public onlyWhitelisted {
+    whitelist[who] = value;
+    emit WhitelistSet(who, value);
+  }
+
+  /**
+  * Notifies all the pools, safe guarding the notification amount.
+  */
+  function notifyPools(uint256[] memory amounts,
+    address[] memory pools,
+    uint256 sum, address _token
+  ) public onlyWhitelisted {
+    require(amounts.length == pools.length, "Amounts and pools lengths mismatch");
+    for (uint i = 0; i < pools.length; i++) {
+      alreadyNotified[pools[i]] = false;
+    }
+
+    uint256 check = 0;
+    for (uint i = 0; i < pools.length; i++) {
+      require(amounts[i] > 0, "Notify zero");
+      require(!alreadyNotified[pools[i]], "Duplicate pool");
+      IERC20Upgradeable token = IERC20Upgradeable(_token);
+      token.safeTransferFrom(msg.sender, pools[i], amounts[i]);
+      PotPool(pools[i]).notifyTargetRewardAmount(_token, amounts[i]);
+      check = check.add(amounts[i]);
+      alreadyNotified[pools[i]] = true;
+    }
+    require(sum == check, "Wrong check sum");
+  }
+}

package/contracts/base/incentives/NotifyHelperStateful.sol

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "../inheritance/Controllable.sol";
+import "../PotPool.sol";
+
+interface INotifyHelperGeneric {
+  function feeRewardForwarder() external view returns (address);
+
+  function notifyPools(uint256[] calldata amounts,
+    address[] calldata pools,
+    uint256 sum, address token
+  ) external;
+}
+
+interface INotifyHelperAmpliFARM {
+  function notifyPools(uint256[] calldata amounts,
+    address[] calldata pools,
+    uint256 sum
+  ) external;
+}
+
+contract NotifyHelperStateful is Controllable {
+
+  using SafeMathUpgradeable for uint256;
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+
+  event ChangerSet(address indexed account, bool value);
+  event NotifierSet(address indexed account, bool value);
+  event Vesting(address pool, uint256 amount);
+  event PoolChanged(address indexed pool, uint256 percentage, uint256 notificationType, bool vests);
+
+  enum NotificationType {
+    VOID, AMPLIFARM, FARM, TRANSFER, PROFIT_SHARE, TOKEN
+  }
+
+  struct Notification {
+    address poolAddress;
+    NotificationType notificationType;
+    uint256 percentage;
+    bool vests;
+  }
+
+  struct WorkingNotification {
+    address[] pools;
+    uint256[] amounts;
+    uint256 checksum;
+    uint256 counter;
+  }
+
+  uint256 public VESTING_DENOMINATOR = 3;
+  uint256 public VESTING_NUMERATOR = 2;
+
+  mapping (address => bool) changer;
+  mapping (address => bool) notifier;
+
+  address public notifyHelperRegular;
+  address public notifyHelperAmpliFARM;
+  address public rewardToken;
+
+  Notification[] public notifications;
+  mapping (address => uint256) public poolToIndex;
+  mapping (uint256 => uint256) public numbers; // NotificationType to the number of pools
+
+  address public reserve;
+  address public vestingEscrow;
+  uint256 public totalPercentage; // maintain state to not have to calculate during emissions
+
+  modifier onlyChanger {
+    require(changer[msg.sender] || msg.sender == governance(), "Only changer");
+    _;
+  }
+
+  modifier onlyNotifier {
+    require(notifier[msg.sender], "Only notifier");
+    _;
+  }
+
+  constructor(address _storage,
+    address _notifyHelperRegular,
+    address _rewardToken,
+    address _notifyHelperAmpliFARM,
+    address _escrow,
+    address _reserve)
+  Controllable(_storage) public {
+    // used for getting a reference to FeeRewardForwarder
+    notifyHelperRegular = _notifyHelperRegular;
+    rewardToken = _rewardToken;
+    notifyHelperAmpliFARM = _notifyHelperAmpliFARM;
+    vestingEscrow = _escrow;
+    reserve = _reserve;
+    require(_reserve != address(0), "invalid reserve");
+    require(_escrow != address(0), "invalid escrow");
+  }
+
+  /// Whitelisted entities can notify pools based on the state, both for FARM and iFARM
+  /// The only whitelisted entity here would be the minter helper
+  function notifyPools(uint256 total, uint256 timestamp) public onlyNotifier {
+    // transfer the tokens from the msg.sender to here
+    IERC20Upgradeable(rewardToken).safeTransferFrom(msg.sender, address(this), total);
+
+    // prepare the notification data
+    WorkingNotification memory ampliFARM = WorkingNotification(
+      new address[](numbers[uint256(NotificationType.AMPLIFARM)]),
+      new uint256[](numbers[uint256(NotificationType.AMPLIFARM)]),
+      0,
+      0
+    );
+    WorkingNotification memory regular = WorkingNotification(
+      new address[](numbers[uint256(NotificationType.FARM)]),
+      new uint256[](numbers[uint256(NotificationType.FARM)]),
+      0,
+      0
+    );
+    uint256 vestingAmount = 0;
+    for (uint256 i = 0; i < notifications.length; i++) {
+      Notification storage notification = notifications[i];
+      if (notification.notificationType == NotificationType.TRANSFER) {
+        // simple transfer
+        IERC20Upgradeable(rewardToken).safeTransfer(
+          notification.poolAddress,
+          total.mul(notification.percentage).div(totalPercentage)
+        );
+      } else {
+        // FARM or ampliFARM notification
+        WorkingNotification memory toUse = notification.notificationType == NotificationType.FARM ? regular : ampliFARM;
+        toUse.amounts[toUse.counter] = total.mul(notification.percentage).div(totalPercentage);
+        if (notification.vests) {
+          uint256 toVest = toUse.amounts[toUse.counter].mul(VESTING_NUMERATOR).div(VESTING_DENOMINATOR);
+          toUse.amounts[toUse.counter] = toUse.amounts[toUse.counter].sub(toVest);
+          vestingAmount = vestingAmount.add(toVest);
+          emit Vesting(notification.poolAddress, toVest);
+        }
+        toUse.pools[toUse.counter] = notification.poolAddress;
+        toUse.checksum = toUse.checksum.add(toUse.amounts[toUse.counter]);
+        toUse.counter = toUse.counter.add(1);
+      }
+    }
+
+    // handle vesting
+    if (vestingAmount > 0) {
+      IERC20Upgradeable(rewardToken).safeTransfer(vestingEscrow, vestingAmount);
+    }
+
+    // ampliFARM notifications
+    if (ampliFARM.checksum > 0) {
+      IERC20Upgradeable(rewardToken).approve(notifyHelperAmpliFARM, ampliFARM.checksum);
+      INotifyHelperAmpliFARM(notifyHelperAmpliFARM).notifyPools(ampliFARM.amounts, ampliFARM.pools, ampliFARM.checksum);
+    }
+
+    // regular notifications
+    if (regular.checksum > 0) {
+      IERC20Upgradeable(rewardToken).approve(notifyHelperRegular, regular.checksum);
+      INotifyHelperGeneric(notifyHelperRegular).notifyPools(
+        regular.amounts, regular.pools, regular.checksum, rewardToken
+      );
+    }
+
+    // send rest to the reserve
+    uint256 remainingBalance = IERC20Upgradeable(rewardToken).balanceOf(address(this));
+    if (remainingBalance > 0) {
+      IERC20Upgradeable(rewardToken).safeTransfer(reserve, remainingBalance);
+    }
+  }
+
+  /// Returning the governance
+  function transferGovernance(address target, address newStorage) external onlyGovernance {
+    Governable(target).setStorage(newStorage);
+  }
+
+  /// The governance configures whitelists
+  function setChanger(address who, bool value) external onlyGovernance {
+    changer[who] = value;
+    emit ChangerSet(who, value);
+  }
+
+  /// The governance configures whitelists
+  function setNotifier(address who, bool value) external onlyGovernance {
+    notifier[who] = value;
+    emit NotifierSet(who, value);
+  }
+
+  /// Whitelisted entity makes changes to the notifications
+  function setPoolBatch(address[] calldata poolAddress, uint256[] calldata poolPercentage, NotificationType[] calldata notificationType, bool[] calldata vests) external onlyChanger {
+    for (uint256 i = 0; i < poolAddress.length; i++) {
+      setPool(poolAddress[i], poolPercentage[i], notificationType[i], vests[i]);
+    }
+  }
+
+  /// Pool management, adds, updates or removes a transfer/notification
+  function setPool(address poolAddress, uint256 poolPercentage, NotificationType notificationType, bool vests) public onlyChanger {
+    require(notificationType != NotificationType.VOID, "Use valid indication");
+    require(notificationType != NotificationType.TOKEN, "We do not use TOKEN here");
+    if (notificationExists(poolAddress) && poolPercentage == 0) {
+      // remove
+      removeNotification(poolAddress);
+    } else if (notificationExists(poolAddress)) {
+      // update
+      updateNotification(poolAddress, notificationType, poolPercentage, vests);
+    } else if (poolPercentage > 0) {
+      // add because it does not exist
+      addNotification(poolAddress, poolPercentage, notificationType, vests);
+    }
+    emit PoolChanged(poolAddress, poolPercentage, uint256(notificationType), vests);
+  }
+
+  /// Configuration method for vesting for governance
+  function setVestingEscrow(address _escrow) external onlyGovernance {
+    vestingEscrow = _escrow;
+  }
+
+  /// Configuration method for vesting for governance
+  function setVesting(uint256 _numerator, uint256 _denominator) external onlyGovernance {
+    VESTING_DENOMINATOR = _numerator;
+    VESTING_NUMERATOR = _denominator;
+  }
+
+  function notificationExists(address poolAddress) public view returns(bool) {
+    if (notifications.length == 0) return false;
+    if (poolToIndex[poolAddress] != 0) return true;
+    return (notifications[0].poolAddress == poolAddress);
+  }
+
+  function removeNotification(address poolAddress) internal {
+    require(notificationExists(poolAddress), "notification does not exist");
+    uint256 index = poolToIndex[poolAddress];
+    Notification storage notification = notifications[index];
+
+    totalPercentage = totalPercentage.sub(notification.percentage);
+    numbers[uint256(notification.notificationType)] = numbers[uint256(notification.notificationType)].sub(1);
+
+    // move the last element here and pop from the array
+    notifications[index] = notifications[notifications.length.sub(1)];
+    poolToIndex[notifications[index].poolAddress] = index;
+    poolToIndex[poolAddress] = 0;
+    notifications.pop();
+  }
+
+  function updateNotification(address poolAddress, NotificationType notificationType, uint256 percentage, bool vesting) internal {
+    require(notificationExists(poolAddress), "notification does not exist");
+    require(percentage > 0, "notification is 0");
+    uint256 index = poolToIndex[poolAddress];
+    totalPercentage = totalPercentage.sub(notifications[index].percentage).add(percentage);
+    notifications[index].percentage = percentage;
+    notifications[index].vests = vesting;
+    if (notifications[index].notificationType != notificationType) {
+      numbers[uint256(notifications[index].notificationType)] = numbers[uint256(notifications[index].notificationType)].sub(1);
+      notifications[index].notificationType = notificationType;
+      numbers[uint256(notifications[index].notificationType)] = numbers[uint256(notifications[index].notificationType)].add(1);
+    }
+  }
+
+  function addNotification(address poolAddress, uint256 percentage, NotificationType notificationType, bool vesting) internal {
+    require(!notificationExists(poolAddress), "notification exists");
+    require(percentage > 0, "notification is 0");
+    require(PotPool(poolAddress).getRewardTokenIndex(rewardToken) != uint256(-1), "Token not configured on pot pool");
+    Notification memory notification = Notification(poolAddress, notificationType, percentage, vesting);
+    notifications.push(notification);
+    totalPercentage = totalPercentage.add(notification.percentage);
+    numbers[uint256(notification.notificationType)] = numbers[uint256(notification.notificationType)].add(1);
+    poolToIndex[notification.poolAddress] = notifications.length.sub(1);
+    require(notificationExists(poolAddress), "notification was not added");
+  }
+
+  /// emergency draining of tokens and ETH as there should be none staying here
+  function emergencyDrain(address token, uint256 amount) public onlyGovernance {
+    if (token == address(0)) {
+      msg.sender.transfer(amount);
+    } else {
+      IERC20Upgradeable(token).safeTransfer(msg.sender, amount);
+    }
+  }
+
+  function getConfig(uint256 totalAmount) external view returns(address[] memory, uint256[] memory, uint256[] memory) {
+    address[] memory pools = new address[](notifications.length);
+    uint256[] memory percentages = new uint256[](notifications.length);
+    uint256[] memory amounts = new uint256[](notifications.length);
+    for (uint256 i = 0; i < notifications.length; i++) {
+      Notification storage notification = notifications[i];
+      pools[i] = notification.poolAddress;
+      percentages[i] = notification.percentage.mul(1000000).div(totalPercentage);
+      amounts[i] = notification.percentage.mul(totalAmount).div(totalPercentage);
+    }
+    return (pools, percentages, amounts);
+  }
+}

package/contracts/base/inheritance/Controllable.sol

@@ -0,0 +1,26 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "./Governable.sol";
+
+contract Controllable is Governable {
+
+  constructor(address _storage) Governable(_storage) public {
+  }
+
+  modifier onlyController() {
+    require(store.isController(msg.sender), "Not a controller");
+    _;
+  }
+
+  modifier onlyControllerOrGovernance(){
+    require((store.isController(msg.sender) || store.isGovernance(msg.sender)),
+      "The caller must be controller or governance");
+    _;
+  }
+
+  function controller() public view returns (address) {
+    return store.controller();
+  }
+}

package/contracts/base/inheritance/ControllableInit.sol

@@ -0,0 +1,31 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "./GovernableInit.sol";
+
+// A clone of Governable supporting the Initializable interface and pattern
+contract ControllableInit is GovernableInit {
+
+  constructor() public {
+  }
+
+  function initialize(address _storage) public override initializer {
+    GovernableInit.initialize(_storage);
+  }
+
+  modifier onlyController() {
+    require(Storage(_storage()).isController(msg.sender), "Not a controller");
+    _;
+  }
+
+  modifier onlyControllerOrGovernance(){
+    require((Storage(_storage()).isController(msg.sender) || Storage(_storage()).isGovernance(msg.sender)),
+      "The caller must be controller or governance");
+    _;
+  }
+
+  function controller() public view returns (address) {
+    return Storage(_storage()).controller();
+  }
+}

package/contracts/base/inheritance/Governable.sol

@@ -0,0 +1,29 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "./Storage.sol";
+
+contract Governable {
+
+  Storage public store;
+
+  constructor(address _store) public {
+    require(_store != address(0), "new storage shouldn't be empty");
+    store = Storage(_store);
+  }
+
+  modifier onlyGovernance() {
+    require(store.isGovernance(msg.sender), "Not governance");
+    _;
+  }
+
+  function setStorage(address _store) public onlyGovernance {
+    require(_store != address(0), "new storage shouldn't be empty");
+    store = Storage(_store);
+  }
+
+  function governance() public view returns (address) {
+    return store.governance();
+  }
+}

package/contracts/base/inheritance/GovernableInit.sol

@@ -0,0 +1,51 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "../upgradability/ReentrancyGuardUpgradeable.sol";
+import "./Storage.sol";
+
+// A clone of Governable supporting the Initializable interface and pattern
+contract GovernableInit is ReentrancyGuardUpgradeable {
+
+  bytes32 internal constant _STORAGE_SLOT = 0xa7ec62784904ff31cbcc32d09932a58e7f1e4476e1d041995b37c917990b16dc;
+
+  modifier onlyGovernance() {
+    require(Storage(_storage()).isGovernance(msg.sender), "Not governance");
+    _;
+  }
+
+  constructor() public {
+    assert(_STORAGE_SLOT == bytes32(uint256(keccak256("eip1967.governableInit.storage")) - 1));
+  }
+
+  function initialize(address _store) public virtual initializer {
+    _setStorage(_store);
+    ReentrancyGuardUpgradeable.initialize();
+  }
+
+  function _setStorage(address newStorage) private {
+    bytes32 slot = _STORAGE_SLOT;
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, newStorage)
+    }
+  }
+
+  function setStorage(address _store) public onlyGovernance {
+    require(_store != address(0), "new storage shouldn't be empty");
+    _setStorage(_store);
+  }
+
+  function _storage() internal view returns (address str) {
+    bytes32 slot = _STORAGE_SLOT;
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  function governance() public view returns (address) {
+    return Storage(_storage()).governance();
+  }
+}

package/contracts/base/inheritance/IUpgradeSource.sol

@@ -0,0 +1,8 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IUpgradeSource {
+  function shouldUpgrade() external view returns (bool, address);
+  function finalizeUpgrade() external;
+}

package/contracts/base/inheritance/OwnableWhitelist.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+contract OwnableWhitelist is Ownable {
+  mapping (address => bool) public whitelist;
+
+  modifier onlyWhitelisted() {
+    require(whitelist[msg.sender] || msg.sender == owner(), "not allowed");
+    _;
+  }
+
+  function setWhitelist(address target, bool isWhitelisted) public onlyOwner {
+    whitelist[target] = isWhitelisted;
+  }
+}