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

package/contracts/base/incentives/NotifyHelperStateful.sol

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/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) {
+    // 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(type(uint256).max), "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)) {
+      payable(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/incentives/ViewerNotifyHelperStateful.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./NotifyHelperStateful.sol";
+
+contract ViewerNotifyHelperStateful {
+
+  /// configuration check method
+  function getConfig(address helper, uint256 totalAmount)
+  external view returns(address[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
+    (
+    address[] memory pools,
+    uint256[] memory percentages,
+    uint256[] memory amounts
+    ) = NotifyHelperStateful(helper).getConfig(totalAmount);
+
+    uint256[] memory types = new uint256[](pools.length);
+    for (uint256 i = 0; i < pools.length; i++) {
+      (, NotifyHelperStateful.NotificationType notificationType, , ) = NotifyHelperStateful(helper).notifications(i);
+      types[i] = uint256(notificationType);
+    }
+
+    return (pools, percentages, amounts, types);
+  }
+}

package/contracts/base/inheritance/Controllable.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./Governable.sol";
+
+contract Controllable is Governable {
+
+  constructor(address _storage) Governable(_storage) {
+  }
+
+  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,30 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./GovernableInit.sol";
+
+// A clone of Governable supporting the Initializable interface and pattern
+contract ControllableInit is GovernableInit {
+
+  constructor() {
+  }
+
+  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,28 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./Storage.sol";
+
+contract Governable {
+
+  Storage public store;
+
+  constructor(address _store) {
+    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,50 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+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() {
+    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,7 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+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.8.26;
+
+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;
+  }
+}

package/contracts/base/inheritance/Storage.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+contract Storage {
+
+  address public governance;
+  address public controller;
+
+  constructor() {
+    governance = msg.sender;
+  }
+
+  modifier onlyGovernance() {
+    require(isGovernance(msg.sender), "Not governance");
+    _;
+  }
+
+  function setGovernance(address _governance) public onlyGovernance {
+    require(_governance != address(0), "new governance shouldn't be empty");
+    governance = _governance;
+  }
+
+  function setController(address _controller) public onlyGovernance {
+    require(_controller != address(0), "new controller shouldn't be empty");
+    controller = _controller;
+  }
+
+  function isGovernance(address account) public view returns (bool) {
+    return account == governance;
+  }
+
+  function isController(address account) public view returns (bool) {
+    return account == controller;
+  }
+}

package/contracts/base/interface/IBalDex.sol

@@ -0,0 +1,7 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IBalDex {
+    function setFee(address token0, address token1, uint24 fee) external;
+    function setPool(address token0, address token1, bytes32 pool) external;
+}

package/contracts/base/interface/IController.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IController {
+
+    // ========================= 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 AddedStakingContract(address indexed stakingContract);
+    event RemovedStakingContract(address indexed stakingContract);
+
+    event SharePriceChangeLog(
+        address indexed vault,
+        address indexed strategy,
+        uint256 oldSharePrice,
+        uint256 newSharePrice,
+        uint256 timestamp
+    );
+
+    // ==================== Functions ====================
+
+    /**
+     * 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. This grey list is only
+     * used in VaultV3.sol, see the code there for reference
+     */
+    function greyList(address _target) external view returns (bool);
+
+    function addressWhiteList(address _target) external view returns (bool);
+
+    function codeWhiteList(address _target) external view returns (bool);
+
+    function addToWhitelist(address _target) external;
+
+    function addCodeToWhitelist(address _target) external;
+
+    function store() external view returns (address);
+
+    function governance() external view returns (address);
+
+    function doHardWork(address _vault) external;
+
+    function addHardWorker(address _worker) external;
+
+    function removeHardWorker(address _worker) external;
+
+    function salvage(address _token, uint256 amount) external;
+
+    function salvageStrategy(address _strategy, address _token, uint256 amount) external;
+
+    /**
+     * @return The targeted profit token to convert all-non-compounding rewards to. Defaults to WETH.
+     */
+    function targetToken() external view returns (address);
+
+    function setTargetToken(address _targetToken) external;
+
+    function profitSharingReceiver() external view returns (address);
+
+    function setProfitSharingReceiver(address _profitSharingReceiver) external;
+
+    function protocolFeeReceiver() external view returns (address);
+
+    function setProtocolFeeReceiver(address _protocolFeeReceiver) external;
+
+    function rewardForwarder() external view returns (address);
+
+    function setRewardForwarder(address _rewardForwarder) external;
+
+    function universalLiquidator() external view returns (address);
+
+    function setUniversalLiquidator(address _universalLiquidator) external;
+
+    function dolomiteYieldFarmingRouter() external view returns (address);
+
+    function setDolomiteYieldFarmingRouter(address _value) external;
+
+    function nextImplementationDelay() external view returns (uint256);
+
+    function profitSharingNumerator() external view returns (uint256);
+
+    function strategistFeeNumerator() external view returns (uint256);
+
+    function platformFeeNumerator() external view returns (uint256);
+
+    function feeDenominator() external view returns (uint256);
+
+    function setProfitSharingNumerator(uint _profitSharingNumerator) external;
+
+    function confirmSetProfitSharingNumerator() external;
+
+    function setStrategistFeeNumerator(uint _strategistFeeNumerator) external;
+
+    function confirmSetStrategistFeeNumerator() external;
+
+    function setPlatformFeeNumerator(uint _platformFeeNumerator) external;
+
+    function confirmSetPlatformFeeNumerator() external;
+
+    function setNextImplementationDelay(uint256 _nextImplementationDelay) external;
+
+    function confirmNextImplementationDelay() external;
+
+    function nextProfitSharingNumerator() external view returns (uint256);
+
+    function nextProfitSharingNumeratorTimestamp() external view returns (uint256);
+
+    function nextStrategistFeeNumerator() external view returns (uint256);
+
+    function nextStrategistFeeNumeratorTimestamp() external view returns (uint256);
+
+    function nextPlatformFeeNumerator() external view returns (uint256);
+
+    function nextPlatformFeeNumeratorTimestamp() external view returns (uint256);
+
+    function tempNextImplementationDelay() external view returns (uint256);
+
+    function tempNextImplementationDelayTimestamp() external view returns (uint256);
+}

package/contracts/base/interface/IDex.sol

@@ -0,0 +1,9 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IDex {
+    function setFee(address token0, address token1, uint24 fee) external;
+    function setPool(address token0, address token1, address pool) external;
+    function setPool(address token0, address token1, bytes32 pool) external;
+    function pairSetup(address token0, address token1, address pool, uint256[5] calldata params) external;
+}