@pendle/core-v2 3.0.0-beta-9 → 3.0.0

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);
+}

package/contracts/interfaces/Kyber/IKyberPositionManager.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+interface IKyberPositionManager {
+    event MintPosition(
+        uint256 indexed tokenId,
+        uint80 indexed poolId,
+        uint128 liquidity,
+        uint256 amount0,
+        uint256 amount1
+    );
+
+    event RemoveLiquidity(
+        uint256 indexed tokenId,
+        uint128 liquidity,
+        uint256 amount0,
+        uint256 amount1,
+        uint256 additionalRTokenOwed
+    );
+
+    struct Position {
+        // the nonce for permits
+        uint96 nonce;
+        // the address that is approved for spending this token
+        address operator;
+        // the ID of the pool with which this token is connected
+        uint80 poolId;
+        // the tick range of the position
+        int24 tickLower;
+        int24 tickUpper;
+        // the liquidity of the position
+        uint128 liquidity;
+        // the current rToken that the position owed
+        uint256 rTokenOwed;
+        // fee growth per unit of liquidity as of the last update to liquidity
+        uint256 feeGrowthInsideLast;
+    }
+
+    struct PoolInfo {
+        address token0;
+        uint24 fee;
+        address token1;
+    }
+
+    /// @notice Params for the first time adding liquidity, mint new nft to sender
+    /// @param token0 the token0 of the pool
+    /// @param token1 the token1 of the pool
+    ///   - must make sure that token0 < token1
+    /// @param fee the pool's fee in fee units
+    /// @param tickLower the position's lower tick
+    /// @param tickUpper the position's upper tick
+    ///   - must make sure tickLower < tickUpper, and both are in tick distance
+    /// @param ticksPrevious the nearest tick that has been initialized and lower than or equal to
+    ///   the tickLower and tickUpper, use to help insert the tickLower and tickUpper if haven't initialized
+    /// @param amount0Desired the desired amount for token0
+    /// @param amount1Desired the desired amount for token1
+    /// @param amount0Min min amount of token 0 to add
+    /// @param amount1Min min amount of token 1 to add
+    /// @param recipient the owner of the position
+    /// @param deadline time that the transaction will be expired
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        int24[2] ticksPrevious;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    /// @notice Params for adding liquidity to the existing position
+    /// @param tokenId id of the position to increase its liquidity
+    /// @param ticksPrevious the nearest tick that has been initialized and lower than or equal to
+    ///   the tickLower and tickUpper, use to help insert the tickLower and tickUpper if haven't initialized
+    ///   only needed if the position has been closed and the owner wants to add more liquidity
+    /// @param amount0Desired the desired amount for token0
+    /// @param amount1Desired the desired amount for token1
+    /// @param amount0Min min amount of token 0 to add
+    /// @param amount1Min min amount of token 1 to add
+    /// @param deadline time that the transaction will be expired
+    struct IncreaseLiquidityParams {
+        uint256 tokenId;
+        int24[2] ticksPrevious;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Params for remove liquidity from the existing position
+    /// @param tokenId id of the position to remove its liquidity
+    /// @param amount0Min min amount of token 0 to receive
+    /// @param amount1Min min amount of token 1 to receive
+    /// @param deadline time that the transaction will be expired
+    struct RemoveLiquidityParams {
+        uint256 tokenId;
+        uint128 liquidity;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Burn the rTokens to get back token0 + token1 as fees
+    /// @param tokenId id of the position to burn r token
+    /// @param amount0Min min amount of token 0 to receive
+    /// @param amount1Min min amount of token 1 to receive
+    /// @param deadline time that the transaction will be expired
+    struct BurnRTokenParams {
+        uint256 tokenId;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Creates a new pool if it does not exist, then unlocks if it has not been unlocked
+    /// @param token0 the token0 of the pool
+    /// @param token1 the token1 of the pool
+    /// @param fee the fee for the pool
+    /// @param currentSqrtP the initia'l price of the pool
+    /// @return pool returns the pool address
+    function createAndUnlockPoolIfNecessary(
+        address token0,
+        address token1,
+        uint24 fee,
+        uint160 currentSqrtP
+    ) external payable returns (address pool);
+
+    function mint(
+        MintParams calldata params
+    ) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+
+    function addLiquidity(
+        IncreaseLiquidityParams calldata params
+    ) external payable returns (uint128 liquidity, uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed);
+
+    function removeLiquidity(
+        RemoveLiquidityParams calldata params
+    ) external returns (uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed);
+
+    function burnRTokens(
+        BurnRTokenParams calldata params
+    ) external returns (uint256 rTokenQty, uint256 amount0, uint256 amount1);
+
+    /**
+     * @dev Burn the token by its owner
+     * @notice All liquidity should be removed before burning
+     */
+    function burn(uint256 tokenId) external payable;
+
+    function syncFeeGrowth(uint256 tokenId) external returns (uint256 additionalRTokenOwed);
+
+    function positions(uint256 tokenId) external view returns (Position memory pos, PoolInfo memory info);
+
+    function addressToPoolId(address pool) external view returns (uint80);
+
+    function isRToken(address token) external view returns (bool);
+
+    function nextPoolId() external view returns (uint80);
+
+    function nextTokenId() external view returns (uint256);
+
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    function transferAllTokens(address token, uint256 minAmount, address recipient) external payable;
+}

package/contracts/interfaces/Lybra/IEUSD.sol

@@ -10,4 +10,4 @@ interface IEUSD {
     function getMintedEUSDByShares(uint256 _sharesAmount) external view returns (uint256);
 
     function sharesOf(address _account) external view returns (uint256);
-}
+}

package/contracts/interfaces/MUX/IMUXRewardRouter.sol

@@ -0,0 +1,139 @@
+pragma solidity ^0.8.0;
+
+interface IMUXRewardRouter {
+    function vault() external view returns (address);
+
+    function weth() external view returns (address);
+
+    function mlp() external view returns (address);
+
+    function mcb() external view returns (address);
+
+    function mux() external view returns (address);
+
+    function votingEscrow() external view returns (address);
+
+    function mlpFeeTracker() external view returns (address);
+
+    function mlpMuxTracker() external view returns (address);
+
+    function veFeeTracker() external view returns (address);
+
+    function veMuxTracker() external view returns (address);
+
+    function mlpVester() external view returns (address);
+
+    function muxVester() external view returns (address);
+
+    function protocolLiquidityOwner() external view returns (address);
+
+    function mlpDistributor() external view returns (address);
+
+    function muxDistributor() external view returns (address);
+
+    function setProtocolLiquidityOwner(address _protocolLiquidityOwner) external;
+
+    function withdrawToken(address _token, address _account, uint256 _amount) external;
+
+    // ========================== aggregated staking interfaces ==========================
+    function claimableRewards(
+        address account
+    )
+        external
+        returns (
+            uint256 mlpFeeAmount,
+            uint256 mlpMuxAmount,
+            uint256 veFeeAmount,
+            uint256 veMuxAmount,
+            uint256 mcbAmount
+        );
+
+    function claimAll() external;
+
+    // ========================== mux & mcb staking interfaces ==========================
+    function batchStakeMuxForAccount(
+        address[] memory _accounts,
+        uint256[] memory _amounts,
+        uint256[] memory _unlockTime
+    ) external;
+
+    function stakeMcbForAccount(address _account, uint256 _amount) external;
+
+    function stakeMcb(uint256 _amount, uint256 lockPeriod) external;
+
+    function stakeMux(uint256 _amount, uint256 lockPeriod) external;
+
+    function increaseStakeUnlockTime(uint256 lockPeriod) external;
+
+    function unstakeMcbAndMux() external;
+
+    function stakeMlp(uint256 _amount) external returns (uint256);
+
+    function unstakeMlp(uint256 _amount) external returns (uint256);
+
+    // ========================== mlp staking interfaces ==========================
+
+    function maxVestableTokenFromMlp(address account) external view returns (uint256);
+
+    function totalVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function claimedVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function claimableVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function depositToMlpVester(uint256 amount) external;
+
+    function withdrawFromMlpVester() external;
+
+    function claimFromMlp() external;
+
+    function claimVestedTokenFromMlp(address account) external returns (uint256);
+
+    // ========================== ve staking interfaces ==========================
+
+    function maxVestableTokenFromVe(address account) external view returns (uint256);
+
+    function totalVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimedVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimableVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimVestedTokenFromVe(address account) external returns (uint256);
+
+    function claimFromVe() external;
+
+    function depositToVeVester(uint256 amount) external;
+
+    function withdrawFromVeVester() external;
+
+    // ========================== staking status interfaces ==========================
+
+    function averageStakePeriod() external view returns (uint256);
+
+    function unlockTime(address account) external view returns (uint256);
+
+    function stakedMlpAmount(address account) external view returns (uint256);
+
+    function votingEscrowedAmounts(address account) external view returns (uint256, uint256);
+
+    function feeRewardRate() external view returns (uint256);
+
+    function muxRewardRate() external view returns (uint256);
+
+    function reservedMlpAmount(address account) external view returns (uint256);
+
+    function mlpLockAmount(address account, uint256 amount) external view returns (uint256);
+
+    function poolOwnedRate() external view returns (uint256);
+
+    function votingEscrowedRate() external view returns (uint256);
+
+    // ========================== reserved interfaces ==========================
+
+    function compound() external;
+
+    function compoundForAccount(address _account) external;
+
+    function batchCompoundForAccounts(address[] memory _accounts) external;
+}