@pendle/core-v2 5.2.2 → 5.2.3-beta

package/contracts/core/StandardizedYield/implementations/Kyber/KyberNftManagerBaseUpg.sol

@@ -1,438 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import "../../../../interfaces/Kyber/IKyberLiquidityMining.sol";
-import "../../../../interfaces/Kyber/IKyberElasticPool.sol";
-import "../../../../interfaces/Kyber/IKyberElasticRouter.sol";
-import "../../../../interfaces/Kyber/IKyberElasticFactory.sol";
-import "../../../../interfaces/Kyber/IKyberPositionManager.sol";
-import "../../../../interfaces/Kyber/IKyberMathHelper.sol";
-import "../../../libraries/TokenHelper.sol";
-import "../../../libraries/ArrayLib.sol";
-import "../../../libraries/math/PMath.sol";
-
-abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721Receiver {
-    using PMath for uint256;
-
-    enum KyberLiquidityMiningStatus {
-        ACTIVE,
-        INACTIVE, // phase settled or range removed
-        EMERGENCY
-    }
-
-    error InvalidNft(uint256 tokenId);
-
-    uint256 internal constant MINIMUM_LIQUIDITY = 10 ** 3;
-    uint256 internal constant DEFAULT_POSITION_TOKEN_ID = type(uint256).max;
-
-    address internal immutable pool;
-    int24 internal immutable tickLower;
-    int24 internal immutable tickUpper;
-
-    address internal immutable positionManager;
-    address internal immutable router;
-    address internal immutable factory;
-
-    address internal immutable liquidityMining;
-    uint256 internal immutable farmId;
-    uint256 internal immutable rangeId;
-
-    address internal immutable token0;
-    address internal immutable token1;
-    uint24 internal immutable fee;
-
-    address internal immutable kyberMathHelper;
-
-    uint256 public positionTokenId;
-
-    uint256[100] private __gap;
-
-    struct KyberNftManagerImmutableParams {
-        address pool;
-        int24 tickLower;
-        int24 tickUpper;
-        // position related
-        address positionManager;
-        address router;
-        address factory;
-        // farming related
-        address liquidityMining;
-        uint256 farmId;
-        uint256 rangeId;
-        // math helper
-        address kyberMathHelper;
-    }
-
-    constructor(KyberNftManagerImmutableParams memory params) {
-        pool = params.pool;
-        tickLower = params.tickLower;
-        tickUpper = params.tickUpper;
-
-        positionManager = params.positionManager;
-        router = params.router;
-        factory = params.factory;
-
-        liquidityMining = params.liquidityMining;
-        farmId = params.farmId;
-        rangeId = params.rangeId;
-
-        kyberMathHelper = params.kyberMathHelper;
-
-        token0 = IKyberElasticPool(pool).token0();
-        token1 = IKyberElasticPool(pool).token1();
-        fee = IKyberElasticPool(pool).swapFeeUnits();
-
-        _validateFarmInfo(pool, tickLower, tickUpper, liquidityMining, farmId, rangeId);
-    }
-
-    function __KyberNftManagerBaseUpg_init() internal onlyInitializing {
-        _safeApproveInf(token0, positionManager);
-        _safeApproveInf(token1, positionManager);
-        _safeApproveInf(token0, router);
-        _safeApproveInf(token1, router);
-        positionTokenId = DEFAULT_POSITION_TOKEN_ID;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                                NFT RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     *
-     * @param tokenId The tokenId of the position to be deposited
-     * @dev in case position not initialized, a minimum amount of liquidity will be locked
-     * to prevent Kyber pool ticks from being deleted
-     */
-    function _depositNft(uint256 tokenId) internal returns (uint256 sharesMinted) {
-        uint128 liquidity = _validateTokenIdAndGetLiquidity(tokenId);
-        IERC721(positionManager).safeTransferFrom(msg.sender, address(this), tokenId);
-
-        if (positionTokenId == DEFAULT_POSITION_TOKEN_ID) {
-            positionTokenId = tokenId;
-            require(liquidity > MINIMUM_LIQUIDITY, "minimum liquidity not met");
-            sharesMinted = liquidity - MINIMUM_LIQUIDITY;
-
-            // It's okay to revert due to Kyber emergency or inactive farm in this initialization step
-            _depositNftToFarm();
-        } else {
-            // Tho most of the case sharesMinted = liquidity
-            // should re-calc it to prevent any precision issue
-            sharesMinted = _mergeNft(tokenId, liquidity);
-        }
-    }
-
-    function _withdrawNft(uint256 amountSharesToWithdraw, address recipient) internal returns (uint256 tokenId) {
-        (uint256 amount0, uint256 amount1) = _removeLiquidity(amountSharesToWithdraw.Uint128());
-        return _mintKyberNft(amount0, amount1, recipient);
-    }
-
-    function _mergeNft(uint256 tokenId, uint128 liquidity) private returns (uint256 sharesMinted) {
-        (uint256 amount0, uint256 amount1, ) = IKyberPositionManager(positionManager).removeLiquidity(
-            IKyberPositionManager.RemoveLiquidityParams({
-                tokenId: tokenId,
-                liquidity: liquidity,
-                amount0Min: 0,
-                amount1Min: 0,
-                deadline: type(uint256).max
-            })
-        );
-
-        _collectPositionManagerFloatingTokens(address(this));
-
-        // Kyber position is now updated with latest rTokenOwed
-        // We will now burn the rewards back to users
-        if (_getRTokenOwed(tokenId) > 0) _burnRToken(tokenId, msg.sender);
-
-        IKyberPositionManager(positionManager).burn(tokenId);
-        return _addLiquidity(amount0, amount1);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            ZAP RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function _zapIn(address tokenIn, uint256 amountTokenIn) internal returns (uint256 amountSharesOut) {
-        uint256 amountToSwap = IKyberMathHelper(kyberMathHelper).getSingleSidedSwapAmount(
-            pool,
-            amountTokenIn,
-            tokenIn == token0,
-            tickLower,
-            tickUpper
-        );
-
-        address tokenOut = tokenIn == token0 ? token1 : token0;
-        uint256 amountOut = _swap(tokenIn, tokenOut, amountToSwap);
-
-        (uint256 amount0, uint256 amount1) = tokenIn == token0
-            ? (amountTokenIn - amountToSwap, amountOut)
-            : (amountOut, amountTokenIn - amountToSwap);
-
-        return _addLiquidity(amount0, amount1);
-    }
-
-    function _zapOut(address tokenOut, uint256 amountSharesToRedeem) internal returns (uint256 amountTokenOut) {
-        (uint256 amount0, uint256 amount1) = _removeLiquidity(amountSharesToRedeem.Uint128());
-        bool isToken0 = tokenOut == token0;
-        address tokenIn = isToken0 ? token1 : token0;
-        uint256 amountIn = isToken0 ? amount1 : amount0;
-        uint256 amountOut = _swap(tokenIn, tokenOut, amountIn);
-
-        return amountOut + (isToken0 ? amount0 : amount1);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            REWARD RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function _claimKyberRewards() internal {
-        uint256 tokenId = positionTokenId;
-
-        // NOTE: Kyber LM reverts if there's no rTOKEN to be burned
-        // Kyber also doesnt allow calling syncFee() for unauthorized address so there is no good way to check if there's any rTOKEN to be burned
-        // Thus IKyberLiquidityMining.claimFee() should only be called after this painful process of [withdraw nft -> syncFee -> deposit -> claimFee]
-        // smh very gas-inefficient
-
-        KyberLiquidityMiningStatus status = _getKyberLiquidityMiningStatus();
-        bool nftInLm = _isNftInLiquidityMining();
-
-        if (nftInLm) {
-            _withdrawNftFromFarm(status); // withdraw nft (without emergency) should also claim reward
-        }
-
-        bool shouldBurnRToken = IKyberPositionManager(positionManager).syncFeeGrowth(tokenId) > 0;
-
-        if (!shouldBurnRToken) {
-            shouldBurnRToken = _getRTokenOwed(tokenId) > 0;
-        }
-
-        if (shouldBurnRToken) {
-            _burnRToken(tokenId, address(this));
-        }
-
-        if (status == KyberLiquidityMiningStatus.ACTIVE) {
-            _depositNftToFarm();
-        }
-    }
-
-    function _depositNftToFarm() internal {
-        uint256 tokenId = positionTokenId;
-        IERC721(positionManager).approve(liquidityMining, tokenId);
-        IKyberLiquidityMining(liquidityMining).deposit(farmId, rangeId, ArrayLib.create(tokenId), address(this));
-    }
-
-    function _withdrawNftFromFarm(KyberLiquidityMiningStatus status) internal {
-        if (status == KyberLiquidityMiningStatus.EMERGENCY) {
-            IKyberLiquidityMining(liquidityMining).withdrawEmergency(ArrayLib.create(positionTokenId));
-        } else {
-            IKyberLiquidityMining(liquidityMining).withdraw(farmId, ArrayLib.create(positionTokenId));
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            BASE FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function _addLiquidity(uint256 amount0, uint256 amount1) private returns (uint128 liquidity) {
-        uint256 tokenId = positionTokenId;
-        assert(tokenId != DEFAULT_POSITION_TOKEN_ID);
-
-        (liquidity, , , ) = IKyberPositionManager(positionManager).addLiquidity(
-            IKyberPositionManager.IncreaseLiquidityParams({
-                tokenId: tokenId,
-                amount0Desired: amount0,
-                amount1Desired: amount1,
-                amount0Min: 0,
-                amount1Min: 0,
-                deadline: type(uint256).max,
-                ticksPrevious: [tickLower, tickUpper] // doesnt matter as the ticks should always be initialized
-            })
-        );
-
-        if (_isAddLiquidityValid()) {
-            IKyberLiquidityMining(liquidityMining).addLiquidity(farmId, rangeId, ArrayLib.create(tokenId));
-        }
-    }
-
-    function _removeLiquidity(uint128 liquidity) private returns (uint256 amount0, uint256 amount1) {
-        uint256 tokenId = positionTokenId;
-        assert(tokenId != DEFAULT_POSITION_TOKEN_ID);
-
-        if (_isNftInLiquidityMining()) {
-            uint256 prevBalance0 = _selfBalance(token0);
-            uint256 prevBalance1 = _selfBalance(token1);
-            IKyberLiquidityMining(liquidityMining).removeLiquidity(
-                tokenId,
-                liquidity,
-                0,
-                0,
-                type(uint256).max,
-                false,
-                false
-            );
-            amount0 = _selfBalance(token0) - prevBalance0;
-            amount1 = _selfBalance(token1) - prevBalance1;
-        } else {
-            (amount0, amount1, ) = IKyberPositionManager(positionManager).removeLiquidity(
-                IKyberPositionManager.RemoveLiquidityParams({
-                    tokenId: tokenId,
-                    liquidity: liquidity,
-                    amount0Min: 0,
-                    amount1Min: 0,
-                    deadline: type(uint256).max
-                })
-            );
-            _collectPositionManagerFloatingTokens(address(this));
-        }
-    }
-
-    function _mintKyberNft(uint256 amount0, uint256 amount1, address recipient) private returns (uint256 tokenId) {
-        (tokenId, , , ) = IKyberPositionManager(positionManager).mint(
-            IKyberPositionManager.MintParams({
-                token0: token0,
-                token1: token1,
-                fee: fee,
-                tickLower: tickLower,
-                tickUpper: tickUpper,
-                ticksPrevious: [tickLower, tickUpper], // does matter, explained in _addLiquidity
-                amount0Desired: amount0,
-                amount1Desired: amount1,
-                amount0Min: 0,
-                amount1Min: 0,
-                recipient: recipient,
-                deadline: type(uint256).max
-            })
-        );
-    }
-
-    function _swap(address tokenIn, address tokenOut, uint256 amountIn) private returns (uint256) {
-        if (amountIn == 0) return 0;
-        return
-            IKyberElasticRouter(router).swapExactInputSingle(
-                IKyberElasticRouter.ExactInputSingleParams({
-                    tokenIn: tokenIn,
-                    tokenOut: tokenOut,
-                    fee: fee,
-                    recipient: address(this),
-                    deadline: type(uint256).max,
-                    amountIn: amountIn,
-                    minAmountOut: 0,
-                    limitSqrtP: 0 // Kyber router shall assign the appropriate inf price limit if set to 0
-                })
-            );
-    }
-
-    function _burnRToken(uint256 tokenId, address receiver) private {
-        IKyberPositionManager(positionManager).burnRTokens(
-            IKyberPositionManager.BurnRTokenParams({
-                tokenId: tokenId,
-                amount0Min: 0,
-                amount1Min: 0,
-                deadline: type(uint256).max
-            })
-        );
-        _collectPositionManagerFloatingTokens(receiver);
-    }
-
-    function _getRTokenOwed(uint256 tokenId) private view returns (uint256) {
-        (IKyberPositionManager.Position memory position, ) = IKyberPositionManager(positionManager).positions(tokenId);
-        return position.rTokenOwed;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            VALIDATION FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function _validateFarmInfo(
-        address _pool,
-        int24 _tickLower,
-        int24 _tickUpper,
-        address _liquidityMining,
-        uint256 _farmId,
-        uint256 _rangeId
-    ) private view {
-        (address farmPool, IKyberLiquidityMining.RangeInfo[] memory farmRanges, , , , , ) = IKyberLiquidityMining(
-            _liquidityMining
-        ).getFarm(_farmId);
-
-        require(
-            _pool == farmPool &&
-                _tickLower == farmRanges[_rangeId].tickLower &&
-                _tickUpper == farmRanges[_rangeId].tickUpper,
-            "invalid pool info"
-        );
-    }
-
-    function _getKyberLiquidityMiningStatus() private view returns (KyberLiquidityMiningStatus) {
-        if (IKyberLiquidityMining(liquidityMining).emergencyEnabled()) {
-            return KyberLiquidityMiningStatus.EMERGENCY;
-        }
-
-        (
-            ,
-            IKyberLiquidityMining.RangeInfo[] memory ranges,
-            IKyberLiquidityMining.PhaseInfo memory phase,
-            ,
-            ,
-            ,
-
-        ) = IKyberLiquidityMining(liquidityMining).getFarm(farmId); // expensive call urg... but no other way
-
-        if (rangeId >= ranges.length || ranges[rangeId].isRemoved) {
-            return KyberLiquidityMiningStatus.INACTIVE;
-        }
-
-        if (phase.endTime < block.timestamp || phase.isSettled) {
-            return KyberLiquidityMiningStatus.INACTIVE;
-        }
-        return KyberLiquidityMiningStatus.ACTIVE;
-    }
-
-    function _isNftInLiquidityMining() private view returns (bool) {
-        return IERC721(positionManager).ownerOf(positionTokenId) == liquidityMining;
-    }
-
-    function _isAddLiquidityValid() private view returns (bool) {
-        return _getKyberLiquidityMiningStatus() == KyberLiquidityMiningStatus.ACTIVE && _isNftInLiquidityMining();
-    }
-
-    function _validateTokenIdAndGetLiquidity(uint256 tokenId) private view returns (uint128 liquidity) {
-        (
-            IKyberPositionManager.Position memory position,
-            IKyberPositionManager.PoolInfo memory poolInfo
-        ) = IKyberPositionManager(positionManager).positions(tokenId);
-
-        if (IKyberElasticFactory(factory).getPool(poolInfo.token0, poolInfo.token1, poolInfo.fee) != pool) {
-            revert InvalidNft(tokenId);
-        }
-
-        if (position.tickLower != tickLower || position.tickUpper != tickUpper) {
-            revert InvalidNft(tokenId);
-        }
-
-        return position.liquidity;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            MISC FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function _collectPositionManagerFloatingTokens(address receiver) private {
-        IKyberPositionManager(positionManager).transferAllTokens(
-            token0,
-            IERC20(token0).balanceOf(positionManager),
-            receiver
-        );
-        IKyberPositionManager(positionManager).transferAllTokens(
-            token1,
-            IERC20(token1).balanceOf(positionManager),
-            receiver
-        );
-    }
-
-    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
-        return IERC721Receiver.onERC721Received.selector;
-    }
-}

package/contracts/core/StandardizedYield/implementations/Kyber/PendleKyberElasticSYUpg.sol

@@ -1,155 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "./KyberNftManagerBaseUpg.sol";
-import "../../SYBaseWithRewardsUpg.sol";
-
-contract PendleKyberElasticSYUpg is SYBaseWithRewardsUpg, KyberNftManagerBaseUpg {
-    using ArrayLib for address[];
-
-    event DepositNft(address indexed user, uint256 indexed tokenId, uint256 amountSharesOut);
-
-    event WithdrawNft(address indexed user, uint256 indexed tokenId, uint256 amountSharesToWithdraw);
-
-    address[] internal allRewardTokens;
-
-    constructor(
-        KyberNftManagerImmutableParams memory params
-    ) KyberNftManagerBaseUpg(params) SYBaseUpg(params.pool) initializer {}
-
-    function initialize(
-        string memory _name,
-        string memory _symbol,
-        address[] memory _initialRewardTokens
-    ) external initializer {
-        allRewardTokens = _initialRewardTokens;
-        __SYBaseUpg_init(_name, _symbol);
-        __KyberNftManagerBaseUpg_init();
-    }
-
-    function depositNft(uint256 tokenId) external returns (uint256 amountSharesOut) {
-        amountSharesOut = _depositNft(tokenId);
-        _mint(msg.sender, amountSharesOut);
-        emit DepositNft(msg.sender, tokenId, amountSharesOut);
-    }
-
-    function withdrawNft(uint256 amountSharesToWithdraw) external returns (uint256 tokenId) {
-        _burn(msg.sender, amountSharesToWithdraw);
-        tokenId = _withdrawNft(amountSharesToWithdraw, msg.sender);
-        emit WithdrawNft(msg.sender, tokenId, amountSharesToWithdraw);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256 amountSharesOut) {
-        return _zapIn(tokenIn, amountDeposited);
-    }
-
-    function _redeem(
-        address receiver,
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal virtual override returns (uint256 amountTokenOut) {
-        amountTokenOut = _zapOut(tokenOut, amountSharesToRedeem);
-        _transferOut(tokenOut, receiver, amountTokenOut);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view virtual override returns (uint256) {
-        return PMath.ONE;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function addRewardToken(address rewardToken) external onlyOwner {
-        require(!allRewardTokens.contains(rewardToken), "rewardToken already existed");
-        allRewardTokens.push(rewardToken);
-    }
-
-    /**
-     * @dev See {IStandardizedYield-getRewardTokens}
-     */
-    function _getRewardTokens() internal view override returns (address[] memory res) {
-        return allRewardTokens;
-    }
-
-    function _redeemExternalReward() internal override {
-        _claimKyberRewards();
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                        MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 amountSharesOut) {
-        return
-            IKyberMathHelper(kyberMathHelper).previewDeposit(
-                pool,
-                tickLower,
-                tickUpper,
-                tokenIn == token0,
-                amountTokenToDeposit
-            );
-    }
-
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view override returns (uint256 amountTokenOut) {
-        return
-            IKyberMathHelper(kyberMathHelper).previewRedeem(
-                pool,
-                tickLower,
-                tickUpper,
-                tokenOut == token0,
-                amountSharesToRedeem
-            );
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = token0;
-        res[1] = token1;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = token0;
-        res[1] = token1;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == token0 || token == token1;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == token0 || token == token1;
-    }
-
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
-        return (AssetType.TOKEN, pool, 18);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                       POC for Emergency functions
-    //////////////////////////////////////////////////////////////*/
-
-    // function toggleEmergencyStatus() external {
-    //     // This function only acts as a POC. Any other call to this SY should also execute the withdraw emergency
-    //     require(IKyberLiquidityMining(liquidityMining).emergencyEnabled(), "not emergency");
-    //     _withdrawNftFromFarm(KyberLiquidityMiningStatus.EMERGENCY);
-    // }
-}