@pendle/core-v2 2.21.0 → 2.22.0

package/contracts/core/StandardizedYield/implementations/Thena/ThenaPreview.sol

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "./ThenaMath.sol";
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/IPendlePreviewHelper.sol";
+import "../../../../interfaces/Thena/IThenaFactory.sol";
+
+interface IThenaSY {
+    function pair() external view returns (address);
+}
+
+contract ThenaPreview is
+    IPendlePreviewHelper,
+    ThenaMath,
+    BoringOwnableUpgradeable,
+    UUPSUpgradeable
+{
+    using Math for uint256;
+
+    address internal immutable factory;
+
+    constructor(address _factory) initializer {
+        factory = _factory;
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // solhint-disable-next-line
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenIn
+    ) external view returns (uint256 amountLpOut) {
+        address pair = IThenaSY(msg.sender).pair();
+
+        ThenaData memory data = _getNormalizedPairData(pair, tokenIn);
+
+        uint256 amountToSwap = _getZapInSwapAmount(data, tokenIn, amountTokenIn);
+        uint256 amountSwapOut = _getSwapAmountOut(data, amountToSwap);
+
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+
+        data.reserve0 = _getReserveAfterSwap(amountToSwap, data.reserve0, data.fee); // no need getBalance here since we dont need 100% accuracy
+        data.reserve1 -= amountSwapOut;
+
+        amount0ToAddLiq = amountTokenIn - amountToSwap;
+        amount1ToAddLiq = amountSwapOut;
+
+        return _calcAmountLpOut(data, amount0ToAddLiq, amount1ToAddLiq);
+    }
+
+    function previewRedeem(address tokenOut, uint256 amountLpIn) external view returns (uint256) {
+        address pair = IThenaSY(msg.sender).pair();
+
+        // Token1 = tokenOut
+        address token0 = IThenaPair(pair).token0();
+        address token1 = IThenaPair(pair).token1();
+
+        ThenaData memory data = _getNormalizedPairData(pair, tokenOut == token0 ? token1 : token0);
+
+        uint256 totalSupply = IThenaPair(data.pair).totalSupply();
+
+        uint256 amount0Removed = (data.reserve0 * amountLpIn) / totalSupply;
+        uint256 amount1Removed = (data.reserve1 * amountLpIn) / totalSupply;
+
+        data.reserve0 -= amount0Removed;
+        data.reserve1 -= amount1Removed;
+
+        return amount1Removed + _getSwapAmountOut(data, amount0Removed);
+    }
+
+    // @reference: Camelot
+    function _getSwapAmountOut(
+        ThenaData memory data,
+        uint256 amountIn
+    ) internal pure returns (uint256) {
+        if (!data.isStable) {
+            amountIn = amountIn * (FEE_DENOMINATOR - data.fee);
+            return (amountIn * data.reserve1) / (data.reserve0 * FEE_DENOMINATOR + amountIn);
+        } else {
+            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(
+                data.decimals0
+            );
+            uint256 reserveA = data.reserve0.divDown(data.decimals0);
+            uint256 reserveB = data.reserve1.divDown(data.decimals1);
+            uint256 xy = reserveA.mulDown(reserveB).mulDown(
+                reserveA.squareDown() + reserveB.squareDown()
+            );
+            uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
+            return y.mulDown(data.decimals1);
+        }
+    }
+
+    /**
+     * @notice This function simulates Camelot router so any precision issues from their calculation
+     * is preserved in preview functions...
+     */
+    function _calcAmountLpOut(
+        ThenaData memory data,
+        uint256 amount0ToAddLiq,
+        uint256 amount1ToAddLiq
+    ) private view returns (uint256 amountLpOut) {
+        uint256 amount1Optimal = _quote(amount0ToAddLiq, data.reserve0, data.reserve1);
+        if (amount1Optimal <= amount1ToAddLiq) {
+            amount1ToAddLiq = amount1Optimal;
+        } else {
+            amount0ToAddLiq = _quote(amount1ToAddLiq, data.reserve1, data.reserve0);
+        }
+
+        uint256 supply = IThenaPair(data.pair).totalSupply();
+        return
+            Math.min(
+                (amount0ToAddLiq * supply) / data.reserve0,
+                (amount1ToAddLiq * supply) / data.reserve1
+            );
+    }
+
+    function _quote(
+        uint256 amountA,
+        uint256 reserveA,
+        uint256 reserveB
+    ) private pure returns (uint256 amountB) {
+        amountB = (amountA * reserveB) / reserveA;
+    }
+
+    function _getNormalizedPairData(
+        address pair,
+        address pivotToken
+    ) internal view returns (ThenaData memory data) {
+        data.pair = pair;
+        data.isStable = IThenaPair(pair).isStable();
+        data.fee = IThenaFactory(factory).getFee(data.isStable);
+        (data.reserve0, data.reserve1, ) = IThenaPair(pair).getReserves();
+
+        if (data.isStable) {
+            // if not stable, skip readding these datas
+            data.decimals0 = 10 ** IERC20Metadata(IThenaPair(pair).token0()).decimals();
+            data.decimals1 = 10 ** IERC20Metadata(IThenaPair(pair).token1()).decimals();
+        }
+
+        // Normalize token order
+        if (pivotToken == IThenaPair(pair).token1()) {
+            (data.reserve0, data.reserve1) = (data.reserve1, data.reserve0);
+            (data.decimals0, data.decimals1) = (data.decimals1, data.decimals0);
+        }
+    }
+
+    // Camelot copied math functions
+    function _get_y(uint256 x0, uint256 xy, uint256 y) internal pure returns (uint256) {
+        for (uint256 i = 0; i < 255; i++) {
+            uint256 y_prev = y;
+            uint256 k = _f(x0, y);
+            if (k < xy) {
+                uint256 dy = ((xy - k) * 1e18) / _d(x0, y);
+                y = y + dy;
+            } else {
+                uint256 dy = ((k - xy) * 1e18) / _d(x0, y);
+                y = y - dy;
+            }
+            if (y > y_prev) {
+                if (y - y_prev <= 1) {
+                    return y;
+                }
+            } else {
+                if (y_prev - y <= 1) {
+                    return y;
+                }
+            }
+        }
+        return y;
+    }
+
+    function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
+        return
+            (x0 * ((((y * y) / 1e18) * y) / 1e18)) /
+            1e18 +
+            (((((x0 * x0) / 1e18) * x0) / 1e18) * y) /
+            1e18;
+    }
+
+    function _d(uint256 x0, uint256 y) internal pure returns (uint256) {
+        return (3 * x0 * ((y * y) / 1e18)) / 1e18 + ((((x0 * x0) / 1e18) * x0) / 1e18);
+    }
+}

package/contracts/core/libraries/math/Math.sol

@@ -81,6 +81,10 @@ library Math {
         return x * x;
     }
 
+    function squareDown(uint256 x) internal pure returns (uint256) {
+        return mulDown(x, x);
+    }
+
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }

package/contracts/interfaces/Ankr/IAnkrBNB.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IAnkrBNB {
+    function ratio() external view returns (uint256);
+
+    function bondsToShares(uint256 amount) external view returns (uint256);
+
+    function sharesToBonds(uint256 amount) external view returns (uint256);
+}

package/contracts/interfaces/Ankr/IAnkrLiquidStaking.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IAnkrLiquidStaking {
+    function swap(uint256 shares, address receiverAddress) external;
+
+    function stakeBonds() external payable;
+
+    function stakeCerts() external payable;
+
+    function getFreeBalance() external view returns (uint256);
+
+    function getMinStake() external view returns (uint256);
+
+    function getMinUnstake() external view returns (uint256);
+
+    function flashPoolCapacity() external view returns (uint256);
+
+    function getFlashUnstakeFee() external view returns (uint256);
+}

package/contracts/interfaces/Camelot/ICamelotNFTPool.sol

@@ -17,6 +17,8 @@ interface ICamelotNFTPool is IERC721 {
 
     function emergencyWithdraw(uint256 tokenId) external;
 
+    function emergencyUnlock() external view returns (bool);
+
     function getPoolInfo()
         external
         view

package/contracts/interfaces/Camelot/ICamelotNitroPool.sol

@@ -18,6 +18,7 @@ interface ICamelotNitroPool is IERC721 {
 
     function nftPool() external view returns (address);
 
+
     function harvest() external;
 
     function rewardsToken1() external view returns (RewardsToken calldata);
@@ -25,4 +26,6 @@ interface ICamelotNitroPool is IERC721 {
     function rewardsToken2() external view returns (RewardsToken calldata);
 
     function emergencyWithdraw(uint256 tokenId) external;
+ 
+    function emergencyClose() external view returns (bool);
 }

package/contracts/interfaces/Camelot/ICamelotPair.sol

@@ -56,6 +56,10 @@ interface ICamelotPair {
     );
     event Sync(uint112 reserve0, uint112 reserve1);
 
+    function precisionMultiplier0() external pure returns (uint256);
+
+    function precisionMultiplier1() external pure returns (uint256);
+    
     function MINIMUM_LIQUIDITY() external pure returns (uint256);
 
     function factory() external view returns (address);

package/contracts/interfaces/IPendlePreviewHelper.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPendlePreviewHelper {
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenIn
+    ) external view returns (uint256 amountSharesOut);
+
+    function previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToBurn
+    ) external view returns (uint256 amountTokenOut);
+}

package/contracts/interfaces/ISwETH.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ISwETH {
+    function deposit() external payable;
+
+    function getRate() external view returns (uint256);
+
+    function ethToSwETHRate() external view returns (uint256);
+}

package/contracts/interfaces/Thena/IThenaFactory.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IThenaFactory {
+    function allPairsLength() external view returns (uint);
+
+    function isPair(address pair) external view returns (bool);
+
+    function allPairs(uint index) external view returns (address);
+
+    function pairCodeHash() external pure returns (bytes32);
+
+    function getPair(address tokenA, address token, bool stable) external view returns (address);
+
+    function createPair(
+        address tokenA,
+        address tokenB,
+        bool stable
+    ) external returns (address pair);
+
+    function getFee(bool _stable) external view returns (uint256);
+}

package/contracts/interfaces/Thena/IThenaGaugeV2.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+
+interface IThenaGaugeV2 {
+    function emergency() external returns (bool);
+
+    function depositAll() external;
+
+    function withdrawAll() external;
+
+    function emergencyWithdraw() external;
+
+    function getReward() external;
+
+    function balanceOf(address account) external view returns (uint256);
+}

package/contracts/interfaces/Thena/IThenaPair.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IThenaPair {
+    function metadata() external view returns (uint dec0, uint dec1, uint r0, uint r1, bool st, address t0, address t1);
+    function claimFees() external returns (uint, uint);
+    function tokens() external view returns (address, address);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function transferFrom(address src, address dst, uint amount) external returns (bool);
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
+    function burn(address to) external returns (uint amount0, uint amount1);
+    function mint(address to) external returns (uint liquidity);
+    function getReserves() external view returns (uint _reserve0, uint _reserve1, uint _blockTimestampLast);
+    function getAmountOut(uint, address) external view returns (uint);
+
+    function name() external view returns(string memory);
+    function symbol() external view returns(string memory);
+    function totalSupply() external view returns (uint);
+    function decimals() external view returns (uint8);
+
+    function claimable0(address _user) external view returns (uint);
+    function claimable1(address _user) external view returns (uint);
+
+    function isStable() external view returns(bool);
+
+
+}

package/contracts/interfaces/Thena/IThenaRouter.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IThenaRouter {
+    function swapExactTokensForTokensSimple(
+        uint amountIn,
+        uint amountOutMin,
+        address tokenFrom,
+        address tokenTo,
+        bool stable,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB, uint liquidity);
+
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB);
+}

package/contracts/router/swap-aggregator/1inch/I1inchAggregationRouterV5.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+interface I1inchAggregationRouterV5 {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    function uniswapV3SwapTo(
+        address payable recipient,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns(uint256 returnAmount);
+
+    function swap(
+        address executor,
+        SwapDescription calldata desc,
+        bytes calldata permit,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (
+            uint256 returnAmount,
+            uint256 spentAmount
+        );
+
+    function unoswapTo(
+        address payable recipient,
+        address srcToken,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns(uint256 returnAmount);
+}

package/contracts/router/swap-aggregator/1inch/OneInchAggregationRouterHelper.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "./I1inchAggregationRouterV5.sol";
+import "../../../core/libraries/Errors.sol";
+
+abstract contract OneInchAggregationRouterHelper {
+    function _rescaleMinAmount(
+        uint256 minAmount,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (uint256) {
+        return (minAmount * newAmount) / oldAmount;
+    }
+
+    function _get1inchScaledInputData(bytes calldata rawCallData, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        bytes4 selector = bytes4(rawCallData[:4]);
+        bytes memory args = rawCallData[4:];
+
+        if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
+            (
+                address payable recipient,
+                uint256 amount,
+                uint256 minReturn,
+                uint256[] memory pools
+            ) = abi.decode(args, (address, uint256, uint256, uint256[]));
+
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
+        }
+
+        if (selector == I1inchAggregationRouterV5.swap.selector) {
+            (
+                address executor,
+                I1inchAggregationRouterV5.SwapDescription memory desc,
+                bytes memory permit,
+                bytes memory data
+            ) = abi.decode(
+                    args,
+                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
+                );
+
+            desc.amount = newAmount;
+            return abi.encodeWithSelector(selector, executor, desc, permit, data);
+        }
+
+        if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
+            (
+                address payable recipient,
+                address srcToken,
+                uint256 amount,
+                uint256 minReturn,
+                uint256[] memory pools
+            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
+
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
+        }
+
+        revert Errors.UnsupportedSelector(1, selector);
+    }
+}

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -4,8 +4,9 @@ pragma solidity 0.8.17;
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "./kyberswap/KyberInputScalingHelper.sol";
+import "./1inch/OneInchAggregationRouterHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper {
+contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
     using Address for address;
 
     function swap(
@@ -30,7 +31,7 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper {
         if (swapType == SwapType.KYBERSWAP) {
             scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
         } else if (swapType == SwapType.ONE_INCH) {
-            revert("not supported");
+            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
         } else {
             assert(false);
         }

package/deployments/1-markets/BALANCER-LP-AURA-WSTETH-ANKRETH-JUNE-27-2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY wstETH-ankrETH_BalancerLP Aura",
+    "SY": "0xb5Cd090010D4735f18306EB680D898eF9F36F044",
+    "YT": "0xcE0BD0De35A39508916e1f63fBdaf15221c66d18",
+    "PT": "0x86a0ADF389Ba99006633978dDd43c5aa711DDF3E",
+    "market": "0xD547d9C74314F787aFFc587d101146e1663d046e",
+    "expiry": 1719446400,
+    "scalarRoot": "87995560000000000000",
+    "initAnchor": "1033722000000000000"
+}

package/deployments/56-core.json

@@ -19,10 +19,10 @@
     "marketFactory": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
     "router": "0x00000000025EFaDc0b8d17d3d87aB5056e3D2510",
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0x6f41855CdF6861a1F8A017e8bB0F90927582cCf6",
+    "pendleSwap": "0x5D6357710b44f740Af20bD66F05e48DF59be7DD2",
     "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
     "ptOracle": "0x4d717868F4Bd14ac8B29Bb6361901e30Ae05e340",
     "receiverEndpoint": "0x998CF52b2585e05494BF9F2bF502351a9C7FdA8f",
     "vePendle": "0x8A09574b0401A856d89d1b583eE22E8cb0C5530B",
     "gaugeController": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0"
-}
+}

package/deployments/56-markets/ANKRBNB-26JUN2025.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY ankrBNB",
+    "SY": "0x58732F1C1243A0D5876a601FB8D1Ee508B21580D",
+    "YT": "0x269f3E230C90C0a29140106D4cFB5860aF6F6827",
+    "PT": "0x04eb6B56ff53f457c8E857ca8D4fbC8d9a531c0C",
+    "market": "0xEDa1D0e1681D59dea451702963d6287b844Cb94C",
+    "expiry": 1750896000,
+    "scalarRoot": "71188500000000000000",
+    "initAnchor": "1060546000000000000"
+}

package/deployments/56-offchain-helper.json

@@ -1,4 +1,4 @@
 {
-    "multicall": "0x9C5F6Be9A6E625b0DF5F9F97a5850a41f933434C",
+    "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "implicitSwapfeeContract": "0xed18de5442297a4ec1ce59c7c7d9427adc2a012b"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",