@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-13

package/contracts/interfaces/Kyber/IKyberElasticFactory.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/// @title KyberSwap v2 factory
+/// @notice Deploys KyberSwap v2 pools and manages control over government fees
+interface IKyberElasticFactory {
+    /// @notice Emitted when a pool is created
+    /// @param token0 First pool token by address sort order
+    /// @param token1 Second pool token by address sort order
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks
+    /// @param pool The address of the created pool
+    event PoolCreated(
+        address indexed token0,
+        address indexed token1,
+        uint24 indexed swapFeeUnits,
+        int24 tickDistance,
+        address pool
+    );
+
+    /// @notice Emitted when a new fee is enabled for pool creation via the factory
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks for pools created with the given fee
+    event SwapFeeEnabled(uint24 indexed swapFeeUnits, int24 indexed tickDistance);
+
+    /// @notice Emitted when vesting period changes
+    /// @param vestingPeriod The maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    event VestingPeriodUpdated(uint32 vestingPeriod);
+
+    /// @notice Emitted when configMaster changes
+    /// @param oldConfigMaster configMaster before the update
+    /// @param newConfigMaster configMaster after the update
+    event ConfigMasterUpdated(address oldConfigMaster, address newConfigMaster);
+
+    /// @notice Emitted when fee configuration changes
+    /// @param feeTo Recipient of government fees
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    event FeeConfigurationUpdated(address feeTo, uint24 governmentFeeUnits);
+
+    /// @notice Emitted when whitelist feature is enabled
+    event WhitelistEnabled();
+
+    /// @notice Emitted when whitelist feature is disabled
+    event WhitelistDisabled();
+
+    /// @notice Returns the maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    function vestingPeriod() external view returns (uint32);
+
+    /// @notice Returns the tick distance for a specified fee.
+    /// @dev Once added, cannot be updated or removed.
+    /// @param swapFeeUnits Swap fee, in fee units.
+    /// @return The tick distance. Returns 0 if fee has not been added.
+    function feeAmountTickDistance(uint24 swapFeeUnits) external view returns (int24);
+
+    /// @notice Returns the address which can update the fee configuration
+    function configMaster() external view returns (address);
+
+    /// @notice Returns the keccak256 hash of the Pool creation code
+    /// This is used for pre-computation of pool addresses
+    function poolInitHash() external view returns (bytes32);
+
+    /// @notice Returns the pool oracle contract for twap
+    function poolOracle() external view returns (address);
+
+    /// @notice Fetches the recipient of government fees
+    /// and current government fee charged in fee units
+    function feeConfiguration() external view returns (address _feeTo, uint24 _governmentFeeUnits);
+
+    /// @notice Returns the status of whitelisting feature of NFT managers
+    /// If true, anyone can mint liquidity tokens
+    /// Otherwise, only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function whitelistDisabled() external view returns (bool);
+
+    //// @notice Returns all whitelisted NFT managers
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function getWhitelistedNFTManagers() external view returns (address[] memory);
+
+    /// @notice Checks if sender is a whitelisted NFT manager
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    /// @param sender address to be checked
+    /// @return true if sender is a whistelisted NFT manager, false otherwise
+    function isWhitelistedNFTManager(address sender) external view returns (bool);
+
+    /// @notice Returns the pool address for a given pair of tokens and a swap fee
+    /// @dev Token order does not matter
+    /// @param tokenA Contract address of either token0 or token1
+    /// @param tokenB Contract address of the other token
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return pool The pool address. Returns null address if it does not exist
+    function getPool(address tokenA, address tokenB, uint24 swapFeeUnits) external view returns (address pool);
+
+    /// @notice Fetch parameters to be used for pool creation
+    /// @dev Called by the pool constructor to fetch the parameters of the pool
+    /// @return factory The factory address
+    /// @return poolOracle The pool oracle for twap
+    /// @return token0 First pool token by address sort order
+    /// @return token1 Second pool token by address sort order
+    /// @return swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return tickDistance Minimum number of ticks between initialized ticks
+    function parameters()
+        external
+        view
+        returns (
+            address factory,
+            address poolOracle,
+            address token0,
+            address token1,
+            uint24 swapFeeUnits,
+            int24 tickDistance
+        );
+
+    /// @notice Creates a pool for the given two tokens and fee
+    /// @param tokenA One of the two tokens in the desired pool
+    /// @param tokenB The other of the two tokens in the desired pool
+    /// @param swapFeeUnits Desired swap fee for the pool, in fee units
+    /// @dev Token order does not matter. tickDistance is determined from the fee.
+    /// Call will revert under any of these conditions:
+    ///     1) pool already exists
+    ///     2) invalid swap fee
+    ///     3) invalid token arguments
+    /// @return pool The address of the newly created pool
+    function createPool(address tokenA, address tokenB, uint24 swapFeeUnits) external returns (address pool);
+
+    /// @notice Enables a fee amount with the given tickDistance
+    /// @dev Fee amounts may never be removed once enabled
+    /// @param swapFeeUnits The fee amount to enable, in fee units
+    /// @param tickDistance The distance between ticks to be enforced for all pools created with the given fee amount
+    function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance) external;
+
+    /// @notice Updates the address which can update the fee configuration
+    /// @dev Must be called by the current configMaster
+    function updateConfigMaster(address) external;
+
+    /// @notice Updates the vesting period
+    /// @dev Must be called by the current configMaster
+    function updateVestingPeriod(uint32) external;
+
+    /// @notice Updates the address receiving government fees and fee quantity
+    /// @dev Only configMaster is able to perform the update
+    /// @param feeTo Address to receive government fees collected from pools
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    function updateFeeConfiguration(address feeTo, uint24 governmentFeeUnits) external;
+
+    /// @notice Enables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function enableWhitelist() external;
+
+    /// @notice Disables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function disableWhitelist() external;
+}

package/contracts/interfaces/Kyber/IKyberElasticPool.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberElasticPool {
+    function factory() external view returns (address);
+
+    /// @notice The first of the two tokens of the pool, sorted by address
+    /// @return The token contract address
+    function token0() external view returns (address);
+
+    /// @notice The second of the two tokens of the pool, sorted by address
+    /// @return The token contract address
+    function token1() external view returns (address);
+
+    /// @notice The fee to be charged for a swap in basis points
+    /// @return The swap fee in basis points
+    function swapFeeUnits() external view returns (uint24);
+
+    function totalSupply() external view returns (uint256);
+
+    /// @notice The pool tick distance
+    /// @dev Ticks can only be initialized and used at multiples of this value
+    /// It remains an int24 to avoid casting even though it is >= 1.
+    /// e.g: a tickDistance of 5 means ticks can be initialized every 5th tick, i.e., ..., -10, -5, 0, 5, 10, ...
+    /// @return The tick distance
+    function tickDistance() external view returns (int24);
+
+    /// @notice Maximum gross liquidity that an initialized tick can have
+    /// @dev This is to prevent overflow the pool's active base liquidity (uint128)
+    /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
+    /// @return The max amount of liquidity per tick
+    function maxTickLiquidity() external view returns (uint128);
+
+    /// @notice Look up information about a specific tick in the pool
+    /// @param tick The tick to look up
+    /// @return liquidityGross total liquidity amount from positions that uses this tick as a lower or upper tick
+    /// liquidityNet how much liquidity changes when the pool tick crosses above the tick
+    /// feeGrowthOutside the fee growth on the other side of the tick relative to the current tick
+    /// secondsPerLiquidityOutside the seconds per unit of liquidity  spent on the other side of the tick relative to the current tick
+    function ticks(
+        int24 tick
+    )
+        external
+        view
+        returns (
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            uint256 feeGrowthOutside,
+            uint128 secondsPerLiquidityOutside
+        );
+
+    /// @notice Returns the previous and next initialized ticks of a specific tick
+    /// @dev If specified tick is uninitialized, the returned values are zero.
+    /// @param tick The tick to look up
+    function initializedTicks(int24 tick) external view returns (int24 previous, int24 next);
+
+    /// @notice Returns the information about a position by the position's key
+    /// @return liquidity the liquidity quantity of the position
+    /// @return feeGrowthInsideLast fee growth inside the tick range as of the last mint / burn action performed
+    function getPositions(
+        address owner,
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint128 liquidity, uint256 feeGrowthInsideLast);
+
+    /// @notice Fetches the pool's prices, ticks and lock status
+    /// @return sqrtP sqrt of current price: sqrt(token1/token0)
+    /// @return currentTick pool's current tick
+    /// @return nearestCurrentTick pool's nearest initialized tick that is <= currentTick
+    /// @return locked true if pool is locked, false otherwise
+    function getPoolState()
+        external
+        view
+        returns (uint160 sqrtP, int24 currentTick, int24 nearestCurrentTick, bool locked);
+
+    /// @notice Fetches the pool's liquidity values
+    /// @return baseL pool's base liquidity without reinvest liqudity
+    /// @return reinvestL the liquidity is reinvested into the pool
+    /// @return reinvestLLast last cached value of reinvestL, used for calculating reinvestment token qty
+    function getLiquidityState() external view returns (uint128 baseL, uint128 reinvestL, uint128 reinvestLLast);
+
+    /// @return feeGrowthGlobal All-time fee growth per unit of liquidity of the pool
+    function getFeeGrowthGlobal() external view returns (uint256);
+
+    /// @return secondsPerLiquidityGlobal All-time seconds per unit of liquidity of the pool
+    /// @return lastUpdateTime The timestamp in which secondsPerLiquidityGlobal was last updated
+    function getSecondsPerLiquidityData()
+        external
+        view
+        returns (uint128 secondsPerLiquidityGlobal, uint32 lastUpdateTime);
+
+    /// @notice Calculates and returns the active time per unit of liquidity until current block.timestamp
+    /// @param tickLower The lower tick (of a position)
+    /// @param tickUpper The upper tick (of a position)
+    /// @return secondsPerLiquidityInside active time (multiplied by 2^96)
+    /// between the 2 ticks, per unit of liquidity.
+    function getSecondsPerLiquidityInside(
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint128 secondsPerLiquidityInside);
+}

package/contracts/interfaces/Kyber/IKyberElasticRouter.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+/// @notice Functions for swapping tokens via KyberSwap v2
+/// - Support swap with exact input or exact output
+/// - Support swap with a price limit
+/// - Support swap within a single pool and between multiple pools
+interface IKyberElasticRouter {
+    /// @dev Params for swapping exact input amount
+    /// @param tokenIn the token to swap
+    /// @param tokenOut the token to receive
+    /// @param fee the pool's fee
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountIn the tokenIn amount to swap
+    /// @param amountOutMinimum the minimum receive amount
+    /// @param limitSqrtP the price limit, if reached, stop swapping
+    struct ExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 minAmountOut;
+        uint160 limitSqrtP;
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+    /// @return amountOut The amount of the received token
+    function swapExactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
+
+    /// @dev Params for swapping exact input using multiple pools
+    /// @param path the encoded path to swap from tokenIn to tokenOut
+    ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token0, fee01, token1, fee12, token2]
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountIn the tokenIn amount to swap
+    /// @param amountOutMinimum the minimum receive amount
+    struct ExactInputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 minAmountOut;
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+    /// @return amountOut The amount of the received token
+    function swapExactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
+
+    /// @dev Params for swapping exact output amount
+    /// @param tokenIn the token to swap
+    /// @param tokenOut the token to receive
+    /// @param fee the pool's fee
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountOut the tokenOut amount of tokenOut
+    /// @param amountInMaximum the minimum input amount
+    /// @param limitSqrtP the price limit, if reached, stop swapping
+    struct ExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 maxAmountIn;
+        uint160 limitSqrtP;
+    }
+
+    /// @notice Swaps as little as possible of one token for `amountOut` of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+    /// @return amountIn The amount of the input token
+    function swapExactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
+
+    /// @dev Params for swapping exact output using multiple pools
+    /// @param path the encoded path to swap from tokenIn to tokenOut
+    ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token2, fee12, token1, fee01, token0]
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountOut the tokenOut amount of tokenOut
+    /// @param amountInMaximum the minimum input amount
+    struct ExactOutputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 maxAmountIn;
+    }
+
+    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
+    /// @return amountIn The amount of the input token
+    function swapExactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
+}

package/contracts/interfaces/Kyber/IKyberLiquidityMining.sol

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+interface IKyberLiquidityMining {
+    error Forbidden();
+    error EmergencyEnabled();
+
+    error InvalidRange();
+    error InvalidTime();
+    error InvalidReward();
+
+    error PositionNotEligible();
+    error FarmNotFound();
+    error InvalidFarm();
+    error NotOwner();
+    error StakeNotFound();
+    error RangeNotMatch();
+    error RangeNotFound();
+    error PhaseSettled();
+    error InvalidInput();
+    error LiquidityNotMatch();
+    error FailToAdd();
+    error FailToRemove();
+    error Expired();
+
+    event UpdateEmergency(bool enableOrDisable);
+    event UpdateTokenCode(bytes farmingTokenCode);
+    event WithdrawUnusedRewards(address token, uint256 amount, address receiver);
+
+    event AddFarm(
+        uint256 indexed fId,
+        address poolAddress,
+        RangeInput[] ranges,
+        PhaseInput phase,
+        address farmingToken
+    );
+    event AddPhase(uint256 indexed fId, PhaseInput phase);
+    event ForceClosePhase(uint256 indexed fId);
+    event AddRange(uint256 indexed fId, RangeInput range);
+    event RemoveRange(uint256 indexed fId, uint256 rangeId);
+    event ActivateRange(uint256 indexed fId, uint256 rangeId);
+    event ExpandEndTimeAndRewards(uint256 indexed fId, uint256 duration, uint256[] rewardAmounts);
+
+    event Deposit(uint256 indexed fId, uint256 rangeId, uint256[] nftIds, address indexed depositer, address receiver);
+    event UpdateLiquidity(uint256 indexed fId, uint256 nftId, uint256 liquidity);
+    event Withdraw(uint256[] nftIds, address receiver);
+    event WithdrawEmergency(uint256 nftId, address receiver);
+    event ClaimReward(uint256 fId, uint256[] nftIds, address token, uint256 amount, address receiver);
+
+    struct RangeInput {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+    }
+
+    struct RewardInput {
+        address rewardToken;
+        uint256 rewardAmount;
+    }
+
+    struct PhaseInput {
+        uint32 startTime;
+        uint32 endTime;
+        RewardInput[] rewards;
+    }
+
+    struct RemoveLiquidityInput {
+        uint256 nftId;
+        uint128 liquidity;
+    }
+
+    struct RangeInfo {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+        bool isRemoved;
+    }
+
+    struct PhaseInfo {
+        uint32 startTime;
+        uint32 endTime;
+        bool isSettled;
+        RewardInput[] rewards;
+    }
+
+    struct FarmInfo {
+        address poolAddress;
+        RangeInfo[] ranges;
+        PhaseInfo phase;
+        uint256 liquidity;
+        address farmingToken;
+        uint256[] sumRewardPerLiquidity;
+        uint32 lastTouchedTime;
+    }
+
+    struct StakeInfo {
+        address owner;
+        uint256 fId;
+        uint256 rangeId;
+        uint256 liquidity;
+        uint256[] lastSumRewardPerLiquidity;
+        uint256[] rewardUnclaimed;
+    }
+
+    // ======== user ============
+    /// @dev deposit nfts to farm
+    /// @dev store curRewardPerLiq now to stake info, mint an amount of farmingToken (if needed) to msg.sender
+    /// @param fId farm's id
+    /// @param rangeId rangeId to add, should use quoter to get best APR rangeId
+    /// @param nftIds nfts to deposit
+    function deposit(uint256 fId, uint256 rangeId, uint256[] memory nftIds, address receiver) external;
+
+    /// @dev claim reward earned for nfts
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    function claimReward(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev withdraw nfts from farm
+    /// @dev only can call by nfts's owner, also claim reward earned
+    /// @dev burn an amount of farmingToken (if needed) from msg.sender
+    /// @param fId farm's id
+    /// @param nftIds nfts to withdraw
+    function withdraw(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev add liquidity of nfts when liquidity already added on Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint an amount of farmingToken to msg.sender
+    /// @param fId farm's id
+    /// @param rangeId rangeId of deposited nfts
+    /// @param nftIds nfts to add liquidity
+    function addLiquidity(uint256 fId, uint256 rangeId, uint256[] calldata nftIds) external;
+
+    /// @dev remove liquidity of nfts from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint/burn an amount of farmingToken
+    /// @param nftId id of nft to remove liquidity
+    /// @param liquidity amount to remove from nft
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    /// @param isClaimFee is also burnRTokens or not
+    function removeLiquidity(
+        uint256 nftId,
+        uint128 liquidity,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isClaimFee,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev claim fee from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    function claimFee(
+        uint256 fId,
+        uint256[] calldata nftIds,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev withdraw nfts in case emergency
+    /// @dev only can call by nfts's owner
+    /// @dev in normal case, abandon all rewards, must return farmingToken
+    /// @dev incase emergencyEnabled, bypass all calculation
+    /// @param nftIds nfts to withdraw
+    function withdrawEmergency(uint256[] calldata nftIds) external;
+
+    function emergencyEnabled() external view returns (bool);
+
+    // ======== view ============
+
+    function getFarm(
+        uint256 fId
+    )
+        external
+        view
+        returns (
+            address poolAddress,
+            RangeInfo[] memory ranges,
+            PhaseInfo memory phase,
+            uint256 liquidity,
+            address farmingToken,
+            uint256[] memory sumRewardPerLiquidity,
+            uint32 lastTouchedTime
+        );
+
+    function getDepositedNFTs(address user) external view returns (uint256[] memory listNFTs);
+
+    function getStake(
+        uint256 nftId
+    )
+        external
+        view
+        returns (
+            address owner,
+            uint256 fId,
+            uint256 rangeId,
+            uint256 liquidity,
+            uint256[] memory lastSumRewardPerLiquidity,
+            uint256[] memory rewardUnclaimeds
+        );
+}

package/contracts/interfaces/Kyber/IKyberMathHelper.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberMathHelper {
+    function getSingleSidedSwapAmount(
+        address kyberPool,
+        uint256 startAmount,
+        bool isToken0,
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint256 amountToSwap);
+
+    function previewDeposit(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountIn
+    ) external view returns (uint256);
+
+    function previewRedeem(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountShares
+    ) external view returns (uint256);
+}