@pendle/core-v2 2.29.4 → 2.30.0

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

@@ -57,21 +57,27 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
         uint128 liq1;
     }
 
-    function previewDeposit(address kyberPool, int24 tickLower, int24 tickUpper, bool isToken0, uint256 amountIn)
-        external
-        view
-        returns (uint256)
-    {
+    function previewDeposit(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountIn
+    ) external view returns (uint256) {
         uint256 amountToSwap = getSingleSidedSwapAmount(kyberPool, amountIn, isToken0, tickLower, tickUpper);
-        (uint256 amountOut,, uint160 newSqrtP) =
-            _simulateSwapExactIn(kyberPool, amountToSwap, _getExtCache(kyberPool, isToken0));
-        return LiquidityMath.getLiquidityFromQties(
-            newSqrtP,
-            TickMath.getSqrtRatioAtTick(tickLower),
-            TickMath.getSqrtRatioAtTick(tickUpper),
-            amountIn - amountToSwap,
-            amountOut
+        (uint256 amountOut, , uint160 newSqrtP) = _simulateSwapExactIn(
+            kyberPool,
+            amountToSwap,
+            _getExtCache(kyberPool, isToken0)
         );
+        return
+            LiquidityMath.getLiquidityFromQties(
+                newSqrtP,
+                TickMath.getSqrtRatioAtTick(tickLower),
+                TickMath.getSqrtRatioAtTick(tickUpper),
+                amountIn - amountToSwap,
+                amountOut
+            );
     }
 
     /**
@@ -79,15 +85,20 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
      * as it uses the old state of the pool to calculate the final swap
      * instead of the state of the pool after removing liquidity
      */
-    function previewRedeem(address kyberPool, int24 tickLower, int24 tickUpper, bool isToken0, uint256 amountShares)
-        external
-        view
-        returns (uint256)
-    {
+    function previewRedeem(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountShares
+    ) external view returns (uint256) {
         (uint256 amount0, uint256 amount1) = _simulateBurn(kyberPool, tickLower, tickUpper, amountShares);
 
-        (uint256 amountOut,,) =
-            _simulateSwapExactIn(kyberPool, isToken0 ? amount1 : amount0, _getExtCache(kyberPool, isToken0));
+        (uint256 amountOut, , ) = _simulateSwapExactIn(
+            kyberPool,
+            isToken0 ? amount1 : amount0,
+            _getExtCache(kyberPool, isToken0)
+        );
 
         return (isToken0 ? amount0 : amount1) + amountOut;
     }
@@ -118,7 +129,11 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
                 params.guess = (params.low + params.high) / 2;
             }
 
-            (params.amountOut, params.newTick, params.currentSqrtP) = _simulateSwapExactIn(kyberPool, params.guess, ext);
+            (params.amountOut, params.newTick, params.currentSqrtP) = _simulateSwapExactIn(
+                kyberPool,
+                params.guess,
+                ext
+            );
 
             if (isToken0) {
                 if (params.newTick < tickLower) {
@@ -127,10 +142,15 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
                     params.low = params.guess;
                 } else {
                     uint128 liq0 = LiquidityMath.getLiquidityFromQty0(
-                        params.currentSqrtP, params.upperSqrtP, startAmount - params.guess
+                        params.currentSqrtP,
+                        params.upperSqrtP,
+                        startAmount - params.guess
+                    );
+                    uint128 liq1 = LiquidityMath.getLiquidityFromQty1(
+                        params.lowerSqrtP,
+                        params.currentSqrtP,
+                        params.amountOut
                     );
-                    uint128 liq1 =
-                        LiquidityMath.getLiquidityFromQty1(params.lowerSqrtP, params.currentSqrtP, params.amountOut);
                     if (liq0 < liq1) {
                         params.high = params.guess;
                     } else {
@@ -143,10 +163,15 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
                 } else if (params.newTick >= tickUpper) {
                     params.high = params.guess;
                 } else {
-                    uint128 liq0 =
-                        LiquidityMath.getLiquidityFromQty0(params.currentSqrtP, params.upperSqrtP, params.amountOut);
+                    uint128 liq0 = LiquidityMath.getLiquidityFromQty0(
+                        params.currentSqrtP,
+                        params.upperSqrtP,
+                        params.amountOut
+                    );
                     uint128 liq1 = LiquidityMath.getLiquidityFromQty1(
-                        params.lowerSqrtP, params.currentSqrtP, startAmount - params.guess
+                        params.lowerSqrtP,
+                        params.currentSqrtP,
+                        startAmount - params.guess
                     );
                     if (liq1 < liq0) {
                         params.high = params.guess;
@@ -204,11 +229,11 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
         bool isToken0;
     }
 
-    function _simulateSwapExactIn(address kyberPool, uint256 swapQty, ExternalCache memory ext)
-        internal
-        view
-        returns (uint256 amountOut, int24 newTick, uint160 newSqrtP)
-    {
+    function _simulateSwapExactIn(
+        address kyberPool,
+        uint256 swapQty,
+        ExternalCache memory ext
+    ) internal view returns (uint256 amountOut, int24 newTick, uint160 newSqrtP) {
         SwapData memory swapData = SwapData({
             specifiedAmount: swapQty.Int(),
             returnedAmount: 0,
@@ -290,7 +315,10 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
 
             // update rTotalSupply, feeGrowthGlobal and reinvestL
             uint256 rMintQty = ReinvestmentMath.calcrMintQty(
-                swapData.reinvestL, cache.reinvestLLast, swapData.baseL, cache.rTotalSupply
+                swapData.reinvestL,
+                cache.reinvestLLast,
+                swapData.baseL,
+                cache.rTotalSupply
             );
 
             if (rMintQty != 0) {
@@ -323,34 +351,39 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
         newSqrtP = swapData.sqrtP;
     }
 
-    function _simulateBurn(address kyberPool, int24 tickLower, int24 tickUpper, uint256 liquidity)
-        internal
-        view
-        returns (uint256 amount0, uint256 amount1)
-    {
-        (uint160 sqrtP, int24 currentTick,,) = IKyberElasticPool(kyberPool).getPoolState();
+    function _simulateBurn(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        uint256 liquidity
+    ) internal view returns (uint256 amount0, uint256 amount1) {
+        (uint160 sqrtP, int24 currentTick, , ) = IKyberElasticPool(kyberPool).getPoolState();
 
         if (currentTick < tickLower) {
-            amount0 = QtyDeltaMath.calcRequiredQty0(
-                TickMath.getSqrtRatioAtTick(tickLower),
-                TickMath.getSqrtRatioAtTick(tickUpper),
-                liquidity.Uint128(),
-                false
-            ).abs();
+            amount0 = QtyDeltaMath
+                .calcRequiredQty0(
+                    TickMath.getSqrtRatioAtTick(tickLower),
+                    TickMath.getSqrtRatioAtTick(tickUpper),
+                    liquidity.Uint128(),
+                    false
+                )
+                .abs();
         } else if (currentTick >= tickUpper) {
-            amount1 = QtyDeltaMath.calcRequiredQty1(
-                TickMath.getSqrtRatioAtTick(tickLower),
-                TickMath.getSqrtRatioAtTick(tickUpper),
-                liquidity.Uint128(),
-                false
-            ).abs();
+            amount1 = QtyDeltaMath
+                .calcRequiredQty1(
+                    TickMath.getSqrtRatioAtTick(tickLower),
+                    TickMath.getSqrtRatioAtTick(tickUpper),
+                    liquidity.Uint128(),
+                    false
+                )
+                .abs();
         } else {
-            amount0 = QtyDeltaMath.calcRequiredQty0(
-                sqrtP, TickMath.getSqrtRatioAtTick(tickUpper), liquidity.Uint128(), false
-            ).abs();
-            amount1 = QtyDeltaMath.calcRequiredQty1(
-                TickMath.getSqrtRatioAtTick(tickLower), sqrtP, liquidity.Uint128(), false
-            ).abs();
+            amount0 = QtyDeltaMath
+                .calcRequiredQty0(sqrtP, TickMath.getSqrtRatioAtTick(tickUpper), liquidity.Uint128(), false)
+                .abs();
+            amount1 = QtyDeltaMath
+                .calcRequiredQty1(TickMath.getSqrtRatioAtTick(tickLower), sqrtP, liquidity.Uint128(), false)
+                .abs();
         }
     }
 
@@ -362,22 +395,24 @@ contract KyberMathHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
         uint128,
         bool willUpTick
     ) internal view returns (uint128 newLiquidity, int24 newNextTick) {
-        (, int128 liquidityNet,,) = IKyberElasticPool(kyberPool).ticks(nextTick);
+        (, int128 liquidityNet, , ) = IKyberElasticPool(kyberPool).ticks(nextTick);
         if (willUpTick) {
             (, newNextTick) = IKyberElasticPool(kyberPool).initializedTicks(nextTick);
         } else {
-            (newNextTick,) = IKyberElasticPool(kyberPool).initializedTicks(nextTick);
+            (newNextTick, ) = IKyberElasticPool(kyberPool).initializedTicks(nextTick);
             liquidityNet = -liquidityNet;
         }
         newLiquidity = LiqDeltaMath.applyLiquidityDelta(
-            currentLiquidity, liquidityNet >= 0 ? uint128(liquidityNet) : liquidityNet.revToUint128(), liquidityNet >= 0
+            currentLiquidity,
+            liquidityNet >= 0 ? uint128(liquidityNet) : liquidityNet.revToUint128(),
+            liquidityNet >= 0
         );
     }
 
     function _getExtCache(address kyberPool, bool isToken0) internal view returns (ExternalCache memory ext) {
         bool willUpTick = !isToken0;
         (ext.baseL, ext.reinvestL, ext.reinvestLLast) = IKyberElasticPool(kyberPool).getLiquidityState();
-        (ext.sqrtP, ext.currentTick, ext.nextTick,) = IKyberElasticPool(kyberPool).getPoolState();
+        (ext.sqrtP, ext.currentTick, ext.nextTick, ) = IKyberElasticPool(kyberPool).getPoolState();
         if (willUpTick) {
             (, ext.nextTick) = IKyberElasticPool(kyberPool).initializedTicks(ext.nextTick);
         }

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

@@ -130,7 +130,7 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
     }
 
     function _mergeNft(uint256 tokenId, uint128 liquidity) private returns (uint256 sharesMinted) {
-        (uint256 amount0, uint256 amount1,) = IKyberPositionManager(positionManager).removeLiquidity(
+        (uint256 amount0, uint256 amount1, ) = IKyberPositionManager(positionManager).removeLiquidity(
             IKyberPositionManager.RemoveLiquidityParams({
                 tokenId: tokenId,
                 liquidity: liquidity,
@@ -156,14 +156,19 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
 
     function _zapIn(address tokenIn, uint256 amountTokenIn) internal returns (uint256 amountSharesOut) {
         uint256 amountToSwap = IKyberMathHelper(kyberMathHelper).getSingleSidedSwapAmount(
-            pool, amountTokenIn, tokenIn == token0, tickLower, tickUpper
+            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);
+        (uint256 amount0, uint256 amount1) = tokenIn == token0
+            ? (amountTokenIn - amountToSwap, amountOut)
+            : (amountOut, amountTokenIn - amountToSwap);
 
         return _addLiquidity(amount0, amount1);
     }
@@ -234,7 +239,7 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
         uint256 tokenId = positionTokenId;
         assert(tokenId != DEFAULT_POSITION_TOKEN_ID);
 
-        (liquidity,,,) = IKyberPositionManager(positionManager).addLiquidity(
+        (liquidity, , , ) = IKyberPositionManager(positionManager).addLiquidity(
             IKyberPositionManager.IncreaseLiquidityParams({
                 tokenId: tokenId,
                 amount0Desired: amount0,
@@ -259,12 +264,18 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
             uint256 prevBalance0 = _selfBalance(token0);
             uint256 prevBalance1 = _selfBalance(token1);
             IKyberLiquidityMining(liquidityMining).removeLiquidity(
-                tokenId, liquidity, 0, 0, type(uint256).max, false, false
+                tokenId,
+                liquidity,
+                0,
+                0,
+                type(uint256).max,
+                false,
+                false
             );
             amount0 = _selfBalance(token0) - prevBalance0;
             amount1 = _selfBalance(token1) - prevBalance1;
         } else {
-            (amount0, amount1,) = IKyberPositionManager(positionManager).removeLiquidity(
+            (amount0, amount1, ) = IKyberPositionManager(positionManager).removeLiquidity(
                 IKyberPositionManager.RemoveLiquidityParams({
                     tokenId: tokenId,
                     liquidity: liquidity,
@@ -278,7 +289,7 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
     }
 
     function _mintKyberNft(uint256 amount0, uint256 amount1, address recipient) private returns (uint256 tokenId) {
-        (tokenId,,,) = IKyberPositionManager(positionManager).mint(
+        (tokenId, , , ) = IKyberPositionManager(positionManager).mint(
             IKyberPositionManager.MintParams({
                 token0: token0,
                 token1: token1,
@@ -298,18 +309,19 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
 
     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
-            })
-        );
+        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 {
@@ -325,7 +337,7 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
     }
 
     function _getRTokenOwed(uint256 tokenId) private view returns (uint256) {
-        (IKyberPositionManager.Position memory position,) = IKyberPositionManager(positionManager).positions(tokenId);
+        (IKyberPositionManager.Position memory position, ) = IKyberPositionManager(positionManager).positions(tokenId);
         return position.rTokenOwed;
     }
 
@@ -341,12 +353,14 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
         uint256 _farmId,
         uint256 _rangeId
     ) private view {
-        (address farmPool, IKyberLiquidityMining.RangeInfo[] memory farmRanges,,,,,) =
-            IKyberLiquidityMining(_liquidityMining).getFarm(_farmId);
+        (address farmPool, IKyberLiquidityMining.RangeInfo[] memory farmRanges, , , , , ) = IKyberLiquidityMining(
+            _liquidityMining
+        ).getFarm(_farmId);
 
         require(
-            _pool == farmPool && _tickLower == farmRanges[_rangeId].tickLower
-                && _tickUpper == farmRanges[_rangeId].tickUpper,
+            _pool == farmPool &&
+                _tickLower == farmRanges[_rangeId].tickLower &&
+                _tickUpper == farmRanges[_rangeId].tickUpper,
             "invalid pool info"
         );
     }
@@ -356,8 +370,15 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
             return KyberLiquidityMiningStatus.EMERGENCY;
         }
 
-        (, IKyberLiquidityMining.RangeInfo[] memory ranges, IKyberLiquidityMining.PhaseInfo memory phase,,,,) =
-            IKyberLiquidityMining(liquidityMining).getFarm(farmId); // expensive call urg... but no other way
+        (
+            ,
+            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;
@@ -378,8 +399,10 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
     }
 
     function _validateTokenIdAndGetLiquidity(uint256 tokenId) private view returns (uint128 liquidity) {
-        (IKyberPositionManager.Position memory position, IKyberPositionManager.PoolInfo memory poolInfo) =
-            IKyberPositionManager(positionManager).positions(tokenId);
+        (
+            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);
@@ -398,10 +421,14 @@ abstract contract KyberNftManagerBaseUpg is Initializable, TokenHelper, IERC721R
 
     function _collectPositionManagerFloatingTokens(address receiver) private {
         IKyberPositionManager(positionManager).transferAllTokens(
-            token0, IERC20(token0).balanceOf(positionManager), receiver
+            token0,
+            IERC20(token0).balanceOf(positionManager),
+            receiver
         );
         IKyberPositionManager(positionManager).transferAllTokens(
-            token1, IERC20(token1).balanceOf(positionManager), receiver
+            token1,
+            IERC20(token1).balanceOf(positionManager),
+            receiver
         );
     }
 

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

@@ -13,16 +13,15 @@ contract PendleKyberElasticSYUpg is SYBaseWithRewardsUpg, KyberNftManagerBaseUpg
 
     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
-    {
+    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();
@@ -44,21 +43,18 @@ contract PendleKyberElasticSYUpg is SYBaseWithRewardsUpg, KyberNftManagerBaseUpg
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    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)
-    {
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
         amountTokenOut = _zapOut(tokenOut, amountSharesToRedeem);
         _transferOut(tokenOut, receiver, amountTokenOut);
     }
@@ -95,26 +91,32 @@ contract PendleKyberElasticSYUpg is SYBaseWithRewardsUpg, KyberNftManagerBaseUpg
                         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 _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) {