@pendle/core-v2 2.18.1 → 2.20.0

package/contracts/offchain-helpers/BoringLpSeller.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../interfaces/IPMarket.sol";
+
+abstract contract BoringLpSeller {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() {}
+
+    /// @dev slippage control should be done on a higher level with the returned parameter
+    /// @param market market address
+    /// @param netLpIn amount of Lp to sell
+    /// @param tokenOut should be included in SY.getTokensOut()
+    /// @return netTokenOut amount of token out
+    function _sellLpForToken(
+        address market,
+        uint256 netLpIn,
+        address tokenOut
+    ) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        IPMarket(market).transfer(market, netLpIn);
+
+        uint256 netSyToRedeem;
+
+        if (PT.isExpired()) {
+            (uint256 netSyRemoved, ) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
+            uint256 netSyFromPt = YT.redeemPY(address(SY));
+            netSyToRedeem = netSyRemoved + netSyFromPt;
+        } else {
+            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(
+                address(SY),
+                market,
+                netLpIn
+            );
+            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY),
+                netPtRemoved,
+                EMPTY_BYTES
+            );
+            netSyToRedeem = netSyRemoved + netSySwappedOut;
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyToRedeem, tokenOut, 0, true);
+    }
+}

package/contracts/offchain-helpers/BulkSellerOffchain.sol

@@ -3,15 +3,16 @@ pragma solidity 0.8.17;
 
 import "../core/BulkSeller/BulkSellerMathCore.sol";
 import "../core/BulkSeller/BulkSeller.sol";
-import "hardhat/console.sol";
 
 contract BulkSellerOffchain {
     using BulkSellerMathCore for BulkSellerState;
     using Math for uint256;
 
-    function calcCurrentRates(
-        IPBulkSeller bulk
-    ) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
+    function calcCurrentRates(IPBulkSeller bulk)
+        external
+        view
+        returns (uint256 rateTokenToSy, uint256 rateSyToToken)
+    {
         BulkSellerState memory state = bulk.readState();
         address SY = bulk.SY();
         address token = bulk.token();
@@ -30,12 +31,14 @@ contract BulkSellerOffchain {
         }
     }
 
-    function getCurrentState(
-        IPBulkSeller bulk
-    )
+    function getCurrentState(IPBulkSeller bulk)
         external
         view
-        returns (BulkSellerState memory state, uint256 tokenProp, uint256 hypoTokenBal)
+        returns (
+            BulkSellerState memory state,
+            uint256 tokenProp,
+            uint256 hypoTokenBal
+        )
     {
         state = bulk.readState();
 

package/contracts/offchain-helpers/PtAndLpToAsset.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../core/libraries/math/Math.sol";
+import "../core/Market/MarketMathCore.sol";
+
+contract PtAndLpToAsset {
+    using Math for int256;
+    using Math for uint256;
+    using MarketMathCore for MarketState;
+
+    function getLpToAssetRate(IPMarket market) public view returns (uint256 lpToAssetRate) {
+        MarketState memory state = market.readState(address(0));
+        uint256 pyIndexCurrent = _getPYIndexCurrent(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(
+            PYIndex.wrap(pyIndexCurrent),
+            block.timestamp
+        );
+
+        int256 totalHypotheticalAsset = comp.totalAsset +
+            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+
+        lpToAssetRate = uint256(totalHypotheticalAsset.divDown(state.totalLp));
+    }
+
+    function getPtToAssetRate(IPMarket market) public view returns (uint256 ptToAssetRate) {
+        MarketState memory state = market.readState(address(0));
+        return _getPtToAssetRate(market, state, _getPYIndexCurrent(market));
+    }
+
+    function _getPtToAssetRate(
+        IPMarket market,
+        MarketState memory state,
+        uint256 pyIndexCurrent
+    ) internal view returns (uint256 ptToAssetRate) {
+        if (state.expiry <= block.timestamp) {
+            (IStandardizedYield SY, , ) = market.readTokens();
+            return (SY.exchangeRate().divDown(pyIndexCurrent));
+        }
+        uint256 timeToExpiry = state.expiry - block.timestamp;
+        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(
+            state.lastLnImpliedRate,
+            timeToExpiry
+        );
+
+        ptToAssetRate = uint256(Math.IONE.divDown(assetToPtRate));
+    }
+
+    function _getPYIndexCurrent(IPMarket market) private view returns (uint256) {
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexStored = YT.pyIndexStored();
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            return pyIndexStored;
+        } else {
+            return Math.max(syIndex, pyIndexStored);
+        }
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -21,9 +21,11 @@ contract ActionInfoStatic is IPActionInfoStatic {
     }
 
     /// can be SY, PY or Market
-    function getTokensInOut(
-        address token
-    ) external view returns (address[] memory tokensIn, address[] memory tokensOut) {
+    function getTokensInOut(address token)
+        external
+        view
+        returns (address[] memory tokensIn, address[] memory tokensOut)
+    {
         try IStandardizedYield(token).getTokensIn() returns (address[] memory res) {
             return (res, IStandardizedYield(token).getTokensOut());
         } catch {}
@@ -78,10 +80,10 @@ contract ActionInfoStatic is IPActionInfoStatic {
         res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
     }
 
-    function getUserMarketInfo(
-        address market,
-        address user
-    ) external returns (UserMarketInfo memory res) {
+    function getUserMarketInfo(address market, address user)
+        external
+        returns (UserMarketInfo memory res)
+    {
         IPMarket _market = IPMarket(market);
         MarketState memory state = _market.readState(address(this));
 
@@ -105,10 +107,11 @@ contract ActionInfoStatic is IPActionInfoStatic {
         res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
     }
 
-    function _zipTokenAmounts(
-        address[] memory tokens,
-        uint256[] memory amounts
-    ) internal pure returns (TokenAmount[] memory res) {
+    function _zipTokenAmounts(address[] memory tokens, uint256[] memory amounts)
+        internal
+        pure
+        returns (TokenAmount[] memory res)
+    {
         res = new TokenAmount[](tokens.length);
 
         for (uint256 i = 0; i < tokens.length; i++) {

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -13,10 +13,9 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
-    function getMarketState(
-        address market
-    )
+    function getMarketState(address market)
         public
+        view
         returns (
             address pt,
             address yt,
@@ -26,9 +25,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
             MarketState memory state
         )
     {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
-
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = _readTokens(market);
         pt = address(PT);
         yt = address(YT);
         sy = address(SY);
@@ -37,10 +34,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         marketExchangeRateExcludeFee = getTradeExchangeRateExcludeFee(market, state);
     }
 
-    function getTradeExchangeRateExcludeFee(
-        address market,
-        MarketState memory state
-    ) public returns (uint256) {
+    function getTradeExchangeRateExcludeFee(address market, MarketState memory state)
+        public
+        view
+        returns (uint256)
+    {
         if (IPMarket(market).isExpired()) return Math.ONE;
 
         MarketPreCompute memory comp = state.getMarketPreCompute(
@@ -57,10 +55,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return preFeeExchangeRate.Uint();
     }
 
-    function getTradeExchangeRateIncludeFee(
-        address market,
-        int256 netPtOut
-    ) public returns (uint256) {
+    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
+        public
+        view
+        returns (uint256)
+    {
         if (IPMarket(market).isExpired()) return Math.ONE;
 
         int256 netPtToAccount = netPtOut;
@@ -88,19 +87,21 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         }
     }
 
-    function calcPriceImpactPt(
-        address market,
-        int256 netPtOut
-    ) public returns (uint256 priceImpact) {
+    function calcPriceImpactPt(address market, int256 netPtOut)
+        public
+        view
+        returns (uint256 priceImpact)
+    {
         uint256 preTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
         uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
         priceImpact = _calculateImpact(preTradeRate, tradedRate);
     }
 
-    function calcPriceImpactYt(
-        address market,
-        int256 netPtOut
-    ) public returns (uint256 priceImpact) {
+    function calcPriceImpactYt(address market, int256 netPtOut)
+        public
+        view
+        returns (uint256 priceImpact)
+    {
         uint256 ytPreTradeRate = _calcVirtualYTPrice(
             getTradeExchangeRateIncludeFee(market, _getSign(netPtOut))
         );
@@ -110,10 +111,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         priceImpact = _calculateImpact(ytPreTradeRate, ytTradedRate);
     }
 
-    function calcPriceImpactPY(
-        address market,
-        int256 netPtOut
-    ) public returns (uint256 priceImpact) {
+    function calcPriceImpactPY(address market, int256 netPtOut)
+        public
+        view
+        returns (uint256 priceImpact)
+    {
         uint256 ptPreTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
         uint256 ytPreTradeRate = _calcVirtualYTPrice(ptPreTradeRate);
         uint256 ptTradeRate = getTradeExchangeRateIncludeFee(market, netPtOut);
@@ -124,6 +126,50 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
     }
 
+    function getLpToSyRate(address market) public view returns (uint256) {
+        (IStandardizedYield SY, , ) = _readTokens(market);
+        return getLpToAssetRate(market).divDown(SY.exchangeRate());
+    }
+
+    function getPtToSyRate(address market) public view returns (uint256) {
+        (IStandardizedYield SY, , ) = _readTokens(market);
+        return getPtToAssetRate(market).divDown(SY.exchangeRate());
+    }
+
+    function getLpToAssetRate(address market) public view returns (uint256) {
+        MarketState memory state = _readState(market);
+        PYIndex pyIndexCurrent = _pyIndex(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
+
+        int256 totalHypotheticalAsset = comp.totalAsset +
+            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+
+        return uint256(totalHypotheticalAsset.divDown(state.totalLp));
+    }
+
+    function getPtToAssetRate(address market) public view returns (uint256) {
+        MarketState memory state = _readState(market);
+        return _getPtToAssetRate(market, state, _pyIndex(market));
+    }
+
+    function _getPtToAssetRate(
+        address market,
+        MarketState memory state,
+        PYIndex pyIndexCurrent
+    ) internal view returns (uint256 ptToAssetRate) {
+        if (state.expiry <= block.timestamp) {
+            (IStandardizedYield SY, , ) = _readTokens(market);
+            return (SY.exchangeRate().divDown(PYIndex.unwrap(pyIndexCurrent)));
+        }
+        uint256 timeToExpiry = state.expiry - block.timestamp;
+        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(
+            state.lastLnImpliedRate,
+            timeToExpiry
+        );
+
+        ptToAssetRate = uint256(Math.IONE.divDown(assetToPtRate));
+    }
+
     function _getPtImpliedYield(address market) internal view returns (int256) {
         MarketState memory state = _readState(market);
 
@@ -131,9 +177,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return lnImpliedRate.exp();
     }
 
-    function _calcVirtualYTPrice(
-        uint256 ptAssetExchangeRate
-    ) private pure returns (uint256 ytAssetExchangeRate) {
+    function _calcVirtualYTPrice(uint256 ptAssetExchangeRate)
+        private
+        pure
+        returns (uint256 ytAssetExchangeRate)
+    {
         // 1 asset = EX pt
         // 1 pt = 1/EX Asset
         // 1 yt + 1/EX Asset = 1 Asset
@@ -146,20 +194,31 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return IPMarket(market).readState(address(this));
     }
 
+    function _readTokens(address market)
+        internal
+        view
+        returns (
+            IStandardizedYield _SY,
+            IPPrincipalToken _PT,
+            IPYieldToken _YT
+        )
+    {
+        return IPMarket(market).readTokens();
+    }
+
     function _getSign(int256 netPtOut) private pure returns (int256) {
         return netPtOut > 0 ? int256(1) : int256(-1);
     }
 
-    function _calculateImpact(
-        uint256 rateBefore,
-        uint256 rateTraded
-    ) private pure returns (uint256 impact) {
+    function _calculateImpact(uint256 rateBefore, uint256 rateTraded)
+        private
+        pure
+        returns (uint256 impact)
+    {
         impact = (rateBefore.Int() - rateTraded.Int()).abs().divDown(rateBefore);
     }
 
-    function _pyIndex(address market) internal returns (PYIndex index) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        return YT.newIndex();
+    function _pyIndex(address market) private view returns (PYIndex) {
+        return PYIndex.wrap(IPRouterStatic(address(this)).pyIndexCurrentViewMarket(market));
     }
 }