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

package/contracts/base/interface/balancer/linearPool/ILinearPool.sol

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "./IPoolSwapStructs.sol";
+
+interface IBasePool is IPoolSwapStructs {
+    /**
+     * @dev Called by the Vault when a user calls `IVault.joinPool` to add liquidity to this Pool. Returns how many of
+     * each registered token the user should provide, as well as the amount of protocol fees the Pool owes to the Vault.
+     * The Vault will then take tokens from `sender` and add them to the Pool's balances, as well as collect
+     * the reported amount in protocol fees, which the pool should calculate based on `protocolSwapFeePercentage`.
+     *
+     * Protocol fees are reported and charged on join events so that the Pool is free of debt whenever new users join.
+     *
+     * `sender` is the account performing the join (from which tokens will be withdrawn), and `recipient` is the account
+     * designated to receive any benefits (typically pool shares). `balances` contains the total balances
+     * for each token the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.
+     *
+     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total
+     * balance.
+     *
+     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of
+     * join (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)
+     *
+     * Contracts implementing this function should check that the caller is indeed the Vault before performing any
+     * state-changing operations, such as minting pool shares.
+     */
+    function onJoinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);
+
+    /**
+     * @dev Called by the Vault when a user calls `IVault.exitPool` to remove liquidity from this Pool. Returns how many
+     * tokens the Vault should deduct from the Pool's balances, as well as the amount of protocol fees the Pool owes
+     * to the Vault. The Vault will then take tokens from the Pool's balances and send them to `recipient`,
+     * as well as collect the reported amount in protocol fees, which the Pool should calculate based on
+     * `protocolSwapFeePercentage`.
+     *
+     * Protocol fees are charged on exit events to guarantee that users exiting the Pool have paid their share.
+     *
+     * `sender` is the account performing the exit (typically the pool shareholder), and `recipient` is the account
+     * to which the Vault will send the proceeds. `balances` contains the total token balances for each token
+     * the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.
+     *
+     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total
+     * balance.
+     *
+     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of
+     * exit (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)
+     *
+     * Contracts implementing this function should check that the caller is indeed the Vault before performing any
+     * state-changing operations, such as burning pool shares.
+     */
+    function onExitPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
+
+    /**
+     * @dev Returns this Pool's ID, used when interacting with the Vault (to e.g. join the Pool or swap with it).
+     */
+    function getPoolId() external view returns (bytes32);
+
+    /**
+     * @dev Returns the current swap fee percentage as a 18 decimal fixed point number, so e.g. 1e17 corresponds to a
+     * 10% swap fee.
+     */
+    function getSwapFeePercentage() external view returns (uint256);
+
+    /**
+     * @dev Returns the scaling factors of each of the Pool's tokens. This is an implementation detail that is typically
+     * not relevant for outside parties, but which might be useful for some types of Pools.
+     */
+    function getScalingFactors() external view returns (uint256[] memory);
+
+    function queryJoin(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256 bptOut, uint256[] memory amountsIn);
+
+    function queryExit(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256 bptIn, uint256[] memory amountsOut);
+}
+
+interface ILinearPool is IBasePool {
+    /**
+     * @dev Returns the Pool's main token.
+     */
+    function getMainToken() external view returns (address);
+
+    /**
+     * @dev Returns the Pool's wrapped token.
+     */
+    function getWrappedToken() external view returns (address);
+
+    /**
+     * @dev Returns the index of the Pool's BPT in the Pool tokens array (as returned by IVault.getPoolTokens).
+     */
+    function getBptIndex() external view returns (uint256);
+
+    /**
+     * @dev Returns the index of the Pool's main token in the Pool tokens array (as returned by IVault.getPoolTokens).
+     */
+    function getMainIndex() external view returns (uint256);
+
+    /**
+     * @dev Returns the index of the Pool's wrapped token in the Pool tokens array (as returned by
+     * IVault.getPoolTokens).
+     */
+    function getWrappedIndex() external view returns (uint256);
+
+    /**
+     * @dev Returns the Pool's targets for the main token balance. These values have had the main token's scaling
+     * factor applied to them.
+     */
+    function getTargets() external view returns (uint256 lowerTarget, uint256 upperTarget);
+
+    /**
+     * @notice Set the lower and upper bounds of the zero-fee trading range for the main token balance.
+     * @dev For a new target range to be valid:
+     *      - the current balance must be between the current targets (meaning no fees are currently pending)
+     *      - the current balance must be between the new targets (meaning setting them does not create pending fees)
+     *
+     * The first requirement could be relaxed, as the LPs actually benefit from the pending fees not being paid out,
+     * but being stricter makes analysis easier at little expense.
+     *
+     * This is a permissioned function, reserved for the pool owner. It will revert when called within a Vault context
+     * (i.e. in the middle of a join or an exit).
+     *
+     * Correct behavior depends on the token balances from the Vault, which may be out of sync with the state of
+     * the pool during execution of a Vault hook.
+     *
+     * See https://forum.balancer.fi/t/reentrancy-vulnerability-scope-expanded/4345 for reference.
+     */
+    function setTargets(uint256 newLowerTarget, uint256 newUpperTarget) external;
+
+    /**
+     * @notice Set the swap fee percentage.
+     * @dev This is a permissioned function, reserved for the pool owner. It will revert when called within a Vault
+     * context (i.e. in the middle of a join or an exit).
+     *
+     * Correct behavior depends on the token balances from the Vault, which may be out of sync with the state of
+     * the pool during execution of a Vault hook.
+     *
+     * See https://forum.balancer.fi/t/reentrancy-vulnerability-scope-expanded/4345 for reference.
+     */
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+}

package/contracts/base/interface/balancer/linearPool/ILinearPoolFactory.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface ILinearPoolFactory {
+    function create(
+        string memory name,
+        string memory symbol,
+        address mainToken,
+        address wrappedToken,
+        uint256 upperTarget,
+        uint256 swapFeePercentage,
+        address owner,
+        uint256 protocolId
+    ) external returns (address);
+}

package/contracts/base/interface/balancer/linearPool/ILinearPoolRebalancer.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface ILinearPoolRebalancer {
+    function rebalance(address recipient) external;
+    function rebalanceWithExtraMain(address recipient, uint extraMain) external;
+}

package/contracts/base/interface/balancer/linearPool/IPoolSwapStructs.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import "../IBVault.sol";
+
+interface IPoolSwapStructs {
+    // This is not really an interface - it just defines common structs used by other interfaces: IGeneralPool and
+    // IMinimalSwapInfoPool.
+    //
+    // This data structure represents a request for a token swap, where `kind` indicates the swap type ('given in' or
+    // 'given out') which indicates whether or not the amount sent by the pool is known.
+    //
+    // The pool receives `tokenIn` and sends `tokenOut`. `amount` is the number of `tokenIn` tokens the pool will take
+    // in, or the number of `tokenOut` tokens the Pool will send out, depending on the given swap `kind`.
+    //
+    // All other fields are not strictly necessary for most swaps, but are provided to support advanced scenarios in
+    // some Pools.
+    //
+    // `poolId` is the ID of the Pool involved in the swap - this is useful for Pool contracts that implement more than
+    // one Pool.
+    //
+    // The meaning of `lastChangeBlock` depends on the Pool specialization:
+    //  - Two Token or Minimal Swap Info: the last block in which either `tokenIn` or `tokenOut` changed its total
+    //    balance.
+    //  - General: the last block in which *any* of the Pool's registered tokens changed its total balance.
+    //
+    // `from` is the origin address for the funds the Pool receives, and `to` is the destination address
+    // where the Pool sends the outgoing tokens.
+    //
+    // `userData` is extra data provided by the caller - typically a signature from a trusted party.
+    struct SwapRequest {
+        IBVault.SwapKind kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        // Misc data
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+}

package/contracts/base/interface/caviar/ICaviarChef.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.12;
+
+interface ICaviarChef {
+    function balanceOf() external view returns(uint256);
+    function userInfo(address _user) external view returns (uint256, uint256);
+    function update(address from, address to) external;
+    function harvestRebase(address from, address to) external;
+    function underlying() external view returns (address);
+    function seedRewards(uint256 _amount) external;
+    function claimEmissions() external returns (uint256);
+    function harvest(address to) external;
+    function deposit(uint256 amount, address to) external;
+    function withdraw(uint256 amount, address to) external;
+    function withdrawAndHarvest(uint256 amount, address to) external;
+}

package/contracts/base/interface/compound/IComet.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+/**
+ * @title Compound's Comet Main Interface (without Ext)
+ * @notice An efficient monolithic money market protocol
+ * @author Compound
+ */
+interface IComet {
+    struct AssetInfo {
+        uint8 offset;
+        address asset;
+        address priceFeed;
+        uint64 scale;
+        uint64 borrowCollateralFactor;
+        uint64 liquidateCollateralFactor;
+        uint64 liquidationFactor;
+        uint128 supplyCap;
+    }
+
+    function supply(address asset, uint amount) external;
+    function supplyTo(address dst, address asset, uint amount) external;
+    function supplyFrom(address from, address dst, address asset, uint amount) external;
+
+    function transfer(address dst, uint amount) external returns (bool);
+    function transferFrom(address src, address dst, uint amount) external returns (bool);
+
+    function transferAsset(address dst, address asset, uint amount) external;
+    function transferAssetFrom(address src, address dst, address asset, uint amount) external;
+
+    function withdraw(address asset, uint amount) external;
+    function withdrawTo(address to, address asset, uint amount) external;
+    function withdrawFrom(address src, address to, address asset, uint amount) external;
+
+    function approveThis(address manager, address asset, uint amount) external;
+    function withdrawReserves(address to, uint amount) external;
+
+    function absorb(address absorber, address[] calldata accounts) external;
+    function buyCollateral(address asset, uint minAmount, uint baseAmount, address recipient) external;
+    function quoteCollateral(address asset, uint baseAmount) external view returns (uint);
+
+    function getAssetInfo(uint8 i) external view returns (AssetInfo memory);
+    function getAssetInfoByAddress(address asset) external view returns (AssetInfo memory);
+    function getCollateralReserves(address asset) external view returns (uint);
+    function getReserves() external view returns (int);
+    function getPrice(address priceFeed) external view returns (uint);
+
+    function isBorrowCollateralized(address account) external view returns (bool);
+    function isLiquidatable(address account) external view returns (bool);
+
+    function totalSupply() external view returns (uint256);
+    function totalBorrow() external view returns (uint256);
+    function balanceOf(address owner) external view returns (uint256);
+    function borrowBalanceOf(address account) external view returns (uint256);
+
+    function pause(bool supplyPaused, bool transferPaused, bool withdrawPaused, bool absorbPaused, bool buyPaused) external;
+    function isSupplyPaused() external view returns (bool);
+    function isTransferPaused() external view returns (bool);
+    function isWithdrawPaused() external view returns (bool);
+    function isAbsorbPaused() external view returns (bool);
+    function isBuyPaused() external view returns (bool);
+
+    function accrueAccount(address account) external;
+    function getSupplyRate(uint utilization) external view returns (uint64);
+    function getBorrowRate(uint utilization) external view returns (uint64);
+    function getUtilization() external view returns (uint);
+
+    function governor() external view returns (address);
+    function pauseGuardian() external view returns (address);
+    function baseToken() external view returns (address);
+    function baseTokenPriceFeed() external view returns (address);
+    function extensionDelegate() external view returns (address);
+
+    /// @dev uint64
+    function supplyKink() external view returns (uint);
+    /// @dev uint64
+    function supplyPerSecondInterestRateSlopeLow() external view returns (uint);
+    /// @dev uint64
+    function supplyPerSecondInterestRateSlopeHigh() external view returns (uint);
+    /// @dev uint64
+    function supplyPerSecondInterestRateBase() external view returns (uint);
+    /// @dev uint64
+    function borrowKink() external view returns (uint);
+    /// @dev uint64
+    function borrowPerSecondInterestRateSlopeLow() external view returns (uint);
+    /// @dev uint64
+    function borrowPerSecondInterestRateSlopeHigh() external view returns (uint);
+    /// @dev uint64
+    function borrowPerSecondInterestRateBase() external view returns (uint);
+    /// @dev uint64
+    function storeFrontPriceFactor() external view returns (uint);
+
+    /// @dev uint64
+    function baseScale() external view returns (uint);
+    /// @dev uint64
+    function trackingIndexScale() external view returns (uint);
+
+    /// @dev uint64
+    function baseTrackingSupplySpeed() external view returns (uint);
+    /// @dev uint64
+    function baseTrackingBorrowSpeed() external view returns (uint);
+    /// @dev uint104
+    function baseMinForRewards() external view returns (uint);
+    /// @dev uint104
+    function baseBorrowMin() external view returns (uint);
+    /// @dev uint104
+    function targetReserves() external view returns (uint);
+
+    function numAssets() external view returns (uint8);
+    function decimals() external view returns (uint8);
+
+    function initializeStorage() external;
+}

package/contracts/base/interface/compound/ICometRewards.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+/**
+ * @title Compound's CometRewards Contract
+ * @notice Hold and claim token rewards
+ * @author Compound
+ */
+interface ICometRewards {
+    struct RewardOwed {
+        address token;
+        uint owed;
+    }
+    function claim(address comet, address src, bool accrue) external;
+    function getRewardOwed(address comet, address account) external returns (RewardOwed memory);
+}

package/contracts/base/interface/curve/Gauge.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface Gauge {
+    function deposit(uint) external;
+    function balanceOf(address) external view returns (uint);
+    function withdraw(uint) external;
+    function user_checkpoint(address) external;
+    function claim_rewards() external;
+}
+
+interface VotingEscrow {
+    function create_lock(uint256 v, uint256 time) external;
+    function increase_amount(uint256 _value) external;
+    function increase_unlock_time(uint256 _unlock_time) external;
+    function withdraw() external;
+}
+
+interface Mintr {
+    function mint(address) external;
+}
+
+interface ICurveLP {
+    function minter() external view returns(address);
+}

package/contracts/base/interface/curve/ICurveDeposit_2token.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_2token {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[2] calldata amounts,
+    uint256 min_mint_amount
+  ) external payable;
+  function remove_liquidity_imbalance(
+    uint256[2] calldata amounts,
+    uint256 max_burn_amount
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[2] calldata amounts
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external payable;
+  function calc_token_amount(
+    uint256[2] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}

package/contracts/base/interface/curve/ICurveDeposit_2token_underlying.sol

@@ -0,0 +1,31 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_2token_underlying {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[2] calldata amounts,
+    uint256 min_mint_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity_imbalance(
+    uint256[2] calldata amounts,
+    uint256 max_burn_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[2] calldata amounts,
+    bool use_underlying
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function exchange_underlying(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function calc_token_amount(
+    uint256[2] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}

package/contracts/base/interface/curve/ICurveDeposit_3token.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_3token {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[3] calldata amounts,
+    uint256 min_mint_amount
+  ) external;
+  function remove_liquidity_imbalance(
+    uint256[3] calldata amounts,
+    uint256 max_burn_amount
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[3] calldata amounts
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function calc_token_amount(
+    uint256[3] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}

package/contracts/base/interface/curve/ICurveDeposit_3token_meta.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_3token_meta {
+  function add_liquidity(
+    address pool,
+    uint256[3] calldata amounts,
+    uint256 min_mint_amount
+  ) external;
+  function remove_liquidity_imbalance(
+    address pool,
+    uint256[3] calldata amounts,
+    uint256 max_burn_amount
+  ) external;
+  function remove_liquidity(
+    address pool,
+    uint256 _amount,
+    uint256[3] calldata amounts
+  ) external;
+}

package/contracts/base/interface/curve/ICurveDeposit_3token_underlying.sol

@@ -0,0 +1,31 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_3token_underlying {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[3] calldata amounts,
+    uint256 min_mint_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity_imbalance(
+    uint256[3] calldata amounts,
+    uint256 max_burn_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[3] calldata amounts,
+    bool use_underlying
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function exchange_underlying(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function calc_token_amount(
+    uint256[3] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}

package/contracts/base/interface/curve/ICurveDeposit_4token.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_4token {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[4] calldata amounts,
+    uint256 min_mint_amount
+  ) external;
+  function remove_liquidity_imbalance(
+    uint256[4] calldata amounts,
+    uint256 max_burn_amount
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[4] calldata amounts
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function calc_token_amount(
+    uint256[4] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}

package/contracts/base/interface/curve/ICurveDeposit_4token_meta.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_4token_meta {
+  function add_liquidity(
+    address pool,
+    uint256[4] calldata amounts,
+    uint256 min_mint_amount
+  ) external;
+  function remove_liquidity_imbalance(
+    address pool,
+    uint256[4] calldata amounts,
+    uint256 max_burn_amount
+  ) external;
+  function remove_liquidity(
+    address pool,
+    uint256 _amount,
+    uint256[4] calldata amounts
+  ) external;
+}

package/contracts/base/interface/curve/ICurveDeposit_4token_underlying.sol

@@ -0,0 +1,31 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface ICurveDeposit_4token_underlying {
+  function get_virtual_price() external view returns (uint);
+  function add_liquidity(
+    uint256[4] calldata amounts,
+    uint256 min_mint_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity_imbalance(
+    uint256[4] calldata amounts,
+    uint256 max_burn_amount,
+    bool use_underlying
+  ) external;
+  function remove_liquidity(
+    uint256 _amount,
+    uint256[4] calldata amounts,
+    bool use_underlying
+  ) external;
+  function exchange(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function exchange_underlying(
+    int128 from, int128 to, uint256 _from_amount, uint256 _min_to_amount
+  ) external;
+  function calc_token_amount(
+    uint256[4] calldata amounts,
+    bool deposit
+  ) external view returns(uint);
+}