@pendle/core-v2 2.21.1 → 2.22.1

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

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "../../../libraries/math/Math.sol";
+import "../../../../interfaces/Thena/IThenaPair.sol";
+
+abstract contract ThenaMath {
+    using Math for uint256;
+
+    struct ThenaData {
+        address pair;
+        bool isStable;
+        uint256 reserve0;
+        uint256 reserve1;
+        uint256 fee;
+        uint256 decimals0;
+        uint256 decimals1;
+    }
+
+    struct StableBinarySearchParams {
+        uint256 guessMin;
+        uint256 guessMax;
+        uint256 amountSwapIn;
+        uint256 newReserve0;
+        uint256 newReserve1;
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+    }
+
+    uint256 internal constant FEE_DENOMINATOR = 10000;
+    uint256 internal constant ONE = 1 * FEE_DENOMINATOR;
+    uint256 internal constant TWO = 2 * FEE_DENOMINATOR;
+    uint256 internal constant FOUR = 4 * FEE_DENOMINATOR;
+    uint256 internal constant DEFAULT_BINARY_SEARCH_EPS = 1e14; // 0.01% accuracy
+
+    uint256 public binarySearchEps = DEFAULT_BINARY_SEARCH_EPS;
+
+    function _getZapInSwapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) internal view returns (uint256) {
+        return
+            data.isStable
+                ? _getStableZapAmount(data, tokenIn, amountIn)
+                : _getVolatileZapAmount(data, amountIn);
+    }
+
+    function _getVolatileZapAmount(
+        ThenaData memory data,
+        uint256 amountIn
+    ) private pure returns (uint256) {
+
+        uint256 numer0 = (TWO - FEE_DENOMINATOR) * data.reserve0 / FEE_DENOMINATOR;
+        uint256 numer1 = Math.square(numer0);
+        uint256 numer2 = 4 * Math.square(ONE - data.fee) * amountIn * data.reserve0;
+
+        uint256 numer = Math.sqrt(numer1 + numer2) - numer0;
+        uint256 denom = 2 * Math.square(ONE - data.fee);
+
+        return numer * FEE_DENOMINATOR / denom;
+    }
+
+    function _getStableZapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) private view returns (uint256) {
+        StableBinarySearchParams memory params = _prepareStableBinarySearchParams(amountIn, data);
+
+        while (!Math.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
+            params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
+            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(
+                params.amountSwapIn,
+                tokenIn
+            );
+
+            params.newReserve0 = _getReserveAfterSwap(
+                params.amountSwapIn,
+                data.reserve0,
+                data.fee
+            );
+            params.newReserve1 = data.reserve1 - params.amount1ToAddLiq;
+            params.amount0ToAddLiq = amountIn - params.amountSwapIn;
+
+            if (
+                params.amount0ToAddLiq * params.newReserve1 <
+                params.amount1ToAddLiq * params.newReserve0
+            ) {
+                params.guessMax = params.amountSwapIn - 1; // need swap less
+            } else {
+                params.guessMin = params.amountSwapIn + 1; // swap more
+            }
+        }
+        return params.guessMin;
+    }
+
+    function _prepareStableBinarySearchParams(
+        uint256 amountIn,
+        ThenaData memory data
+    ) private pure returns (StableBinarySearchParams memory params) {
+        uint256 X = data.reserve0.divDown(data.decimals0);
+        uint256 Y = data.reserve1.divDown(data.decimals1);
+        amountIn = amountIn.divDown(data.decimals0);
+
+        uint256 t = Y.divDown(X + amountIn);
+        uint256 K = X.mulDown(Y).mulDown(X.mulDown(X) + Y.mulDown(Y));
+        uint256 denom = t.mulDown(t).mulDown(t) + t;
+
+        params.guessMin = (_fourthRoot(K.divDown(denom)) - X).mulDown(data.decimals0);
+        params.guessMax = (params.guessMin * FEE_DENOMINATOR) / (FEE_DENOMINATOR - data.fee);
+    }
+
+    function _getReserveAfterSwap(
+        uint256 amountIn,
+        uint256 reserve,
+        uint256 fee
+    ) internal pure returns (uint256) {
+        return reserve + amountIn - (amountIn * fee) / FEE_DENOMINATOR;
+    }
+
+    // this returns the fourthRoot of y in base 18
+    function _fourthRoot(uint256 y) private pure returns (uint256) {
+        uint256 root = Math.sqrt(y) * (10 ** 9);
+        return Math.sqrt(root) * (10 ** 9);
+    }
+}

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/oracles/PendleLpOracleLib.sol

@@ -3,34 +3,42 @@ pragma solidity 0.8.17;
 
 import "./PendlePtOracleLib.sol";
 
-// Reference: https://file.notion.so/f/s/15d1406b-0d81-41a4-8ac3-9b56e30fdf50/LP_Oracle_Doc.pdf?id=201fc56f-959b-4836-9511-73852e166816&table=block&spaceId=33abd05a-56a2-4ce6-8673-929c5984a0fd&expirationTimestamp=1683863581610&signature=IY3jlxvXkWRJZhsccYpQdQaKlm1_NUIb1ypDmuaR7hI&downloadName=LP_Oracle_Doc.pdf
-
 library PendleLpOracleLib {
     using PendlePtOracleLib for IPMarket;
-    using PYIndexLib for PYIndex;
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
 
     /**
-     * This function returns the approximated twap rate LP/Asset on market
+      * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
-     *
      */
-    function getLpToAssetRate(
+    function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
+        return (lpToAssetRateRaw * syIndex) / pyIndex;
+    }
+
+    function _getLpToAssetRateRaw(
         IPMarket market,
-        uint32 duration
-    ) internal view returns (uint256 lpToAssetRate) {
+        uint32 duration,
+        uint256 pyIndex
+    ) private view returns (uint256 lpToAssetRateRaw) {
         MarketState memory state = market.readState(address(0));
-        MarketPreCompute memory comp = _getMarketPreCompute(market, state);
+
+        MarketPreCompute memory comp = state.getMarketPreCompute(
+            PYIndex.wrap(pyIndex),
+            block.timestamp
+        );
 
         int256 totalHypotheticalAsset;
         if (state.expiry <= block.timestamp) {
             // 1 PT = 1 Asset post-expiry
             totalHypotheticalAsset = state.totalPt + comp.totalAsset;
         } else {
-            (int256 rateOracle, int256 rateHypTrade) = _getPtRates(market, state, duration);
+            (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
             int256 cParam = LogExpMath.exp(
                 comp.rateScalar.mulDown((rateOracle - comp.rateAnchor))
             );
@@ -45,46 +53,19 @@ library PendleLpOracleLib {
                 (state.totalPt + tradeSize).divDown(rateOracle);
         }
 
-        lpToAssetRate = _calcLpPrice(totalHypotheticalAsset, state.totalLp).Uint();
+        lpToAssetRateRaw = totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
-    function _getMarketPreCompute(
-        IPMarket market,
-        MarketState memory state
-    ) private view returns (MarketPreCompute memory) {
-        return state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
-    }
-
-    function _getPYIndexCurrent(IPMarket market) private view returns (PYIndex) {
-        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
-        uint256 ytIndex = YT.pyIndexStored();
-        uint256 pyIndexCurrent;
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            pyIndexCurrent = ytIndex;
-        } else {
-            uint256 syIndex = SY.exchangeRate();
-            pyIndexCurrent = Math.max(syIndex, ytIndex);
-        }
-        return PYIndex.wrap(pyIndexCurrent);
-    }
-
-    function _getPtRates(
+    function _getPtRatesRaw(
         IPMarket market,
         MarketState memory state,
         uint32 duration
     ) private view returns (int256 rateOracle, int256 rateHypTrade) {
-        rateOracle = Math.IONE.divDown(market.getPtToAssetRate(duration).Int());
+        rateOracle = Math.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
         int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(
             state.lastLnImpliedRate,
             state.expiry - block.timestamp
         );
         rateHypTrade = (rateLastTrade + rateOracle) / 2;
     }
-
-    function _calcLpPrice(
-        int256 totalHypotheticalAsset,
-        int256 totalLp
-    ) private pure returns (int256) {
-        return totalHypotheticalAsset.divDown(totalLp);
-    }
 }