@pendle/core-v2 0.11.8-testnet → 0.11.10-testnet

package/build/artifacts/contracts/offchain-helpers/SSTORE2DeployerContract.sol/SSTORE2DeployerContract.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/20ebeca750412294184becd43b05ac5c.json"
+  "buildInfo": "../../../build-info/d246d0fd3945c2c082231b431b6c99e6.json"
 }

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -119,7 +119,12 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - _totalSupply & lastSlopeChangeAppliedAt is updated
      */
-    function totalSupplyCurrent() public virtual override returns (uint128) {
+    function totalSupplyCurrent()
+        public
+        virtual
+        override(IPVeToken, VotingEscrowTokenBase)
+        returns (uint128)
+    {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }

package/contracts/core/PendleRouter.sol

@@ -17,6 +17,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
     address public immutable ACTION_ADD_REMOVE_LIQ;
     address public immutable ACTION_SWAP_PT;
     address public immutable ACTION_SWAP_YT;
+    address public immutable ACTION_SWAP_PTYT;
     address public immutable ACTION_CALLBACK;
     address public immutable ACTION_MISC;
 
@@ -25,6 +26,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         address _ACTION_ADD_REMOVE_LIQ,
         address _ACTION_SWAP_PT,
         address _ACTION_SWAP_YT,
+        address _ACTION_SWAP_PTYT,
         address _ACTION_CALLBACK,
         address _ACTION_MISC
     ) initializer {
@@ -32,6 +34,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
         ACTION_SWAP_PT = _ACTION_SWAP_PT;
         ACTION_SWAP_YT = _ACTION_SWAP_YT;
+        ACTION_SWAP_PTYT = _ACTION_SWAP_PTYT;
         ACTION_CALLBACK = _ACTION_CALLBACK;
         ACTION_MISC = _ACTION_MISC;
     }
@@ -48,7 +51,8 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
             sig == IPActionMintRedeem.redeemPyToToken.selector ||
             sig == IPActionMintRedeem.mintPyFromScy.selector ||
             sig == IPActionMintRedeem.redeemPyToScy.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector
+            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector ||
+            sig == IPActionMintRedeem.redeemDueInterestAndRewardsThenSwapAll.selector
         ) {
             return ACTION_MINT_REDEEM;
         } else if (
@@ -82,6 +86,11 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
             sig == IPActionSwapYT.swapYtForExactScy.selector
         ) {
             return ACTION_SWAP_YT;
+        } else if (
+            sig == IPActionSwapPTYT.swapExactPtForYt.selector ||
+            sig == IPActionSwapPTYT.swapExactYtForPt.selector
+        ) {
+            return ACTION_SWAP_PTYT;
         } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
             return ACTION_CALLBACK;
         } else if (sig == IPActionMisc.consult.selector) {

package/contracts/core/actions/ActionAddRemoveLiq.sol

@@ -369,6 +369,29 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address market,
         uint256 netLpToRemove,
         uint256 minScyOut
+    ) internal returns (uint256 netScyOut) {
+        if (IPMarket(market).isExpired()) {
+            netScyOut = __removeLpToScyAfterExpiry(receiver, market, netLpToRemove);
+        } else {
+            netScyOut = __removeLpToScyBeforeExpiry(receiver, market, netLpToRemove);
+        }
+        require(netScyOut >= minScyOut, "insufficient lp out");
+    }
+
+    function __removeLpToScyAfterExpiry(
+        address receiver,
+        address market,
+        uint256 netLpToRemove
+    ) internal returns (uint256 netScyOut) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (uint256 scyFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
+        netScyOut = scyFromBurn + IPYieldToken(YT).redeemPY(receiver);
+    }
+
+    function __removeLpToScyBeforeExpiry(
+        address receiver,
+        address market,
+        uint256 netLpToRemove
     ) internal returns (uint256 netScyOut) {
         (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(
             receiver,
@@ -380,8 +403,6 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             ptFromBurn,
             EMPTY_BYTES
         );
-
-        require(scyFromBurn + scyFromSwap >= minScyOut, "insufficient lp out");
         netScyOut = scyFromBurn + scyFromSwap;
     }
 }

package/contracts/core/actions/ActionCallback.sol

@@ -15,6 +15,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
     using Math for uint256;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
+    using SafeERC20 for IPPrincipalToken;
     using SafeERC20 for IERC20;
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
@@ -48,6 +49,10 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
             _callbackSwapScyForExactYt(market, ptToAccount, scyToAccount, data);
         } else if (swapType == ActionType.SwapYtForScy) {
             _callbackSwapYtForScy(market, ptToAccount, scyToAccount, data);
+        } else if (swapType == ActionType.SwapExactYtForPt) {
+            _callbackSwapExactYtForPt(market, ptToAccount, scyToAccount, data);
+        } else if (swapType == ActionType.SwapExactPtForYt) {
+            _callbackSwapExactPtForYt(market, ptToAccount, scyToAccount, data);
         } else {
             require(false, "unknown swapType");
         }
@@ -137,4 +142,38 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         uint256[] memory amountScyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
         require(amountScyOuts[1] >= minScyOut, "insufficient SCY out");
     }
+
+    function _callbackSwapExactPtForYt(
+        address market,
+        int256 ptToAccount,
+        int256, /*scyToAccount*/
+        bytes calldata data
+    ) internal {
+        (address receiver, uint256 exactPtIn, uint256 minYtOut) = _decodeSwapExactPtForYt(data);
+        uint256 netPtOwed = ptToAccount.abs();
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netPyOut = YT.mintPY(market, receiver);
+        require(netPyOut >= minYtOut, "insufficient YT out");
+        require(exactPtIn + netPyOut >= netPtOwed, "insufficient PT to pay");
+    }
+
+    function _callbackSwapExactYtForPt(
+        address market,
+        int256 ptToAccount,
+        int256 scyToAccount,
+        bytes calldata data
+    ) internal {
+        (address receiver, uint256 exactYtIn, uint256 minPtOut) = _decodeSwapExactYtForPt(data);
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netScyOwed = scyToAccount.abs();
+
+        PT.safeTransfer(address(YT), exactYtIn);
+        uint256 netScyToMarket = YT.redeemPY(market);
+
+        require(netScyToMarket >= netScyOwed, "insufficient SCY to pay");
+        require(ptToAccount.Uint() - exactYtIn >= minPtOut, "insufficient PT out");
+        PT.safeTransfer(receiver, ptToAccount.Uint() - exactYtIn);
+    }
 }

package/contracts/core/actions/ActionSwapPTYT.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../interfaces/IPActionSwapPTYT.sol";
+import "../../interfaces/IPMarket.sol";
+import "./base/CallbackHelper.sol";
+
+contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using MarketApproxPtOutLib for MarketState;
+    using Math for uint256;
+    using Math for int256;
+    using SafeERC20 for IERC20;
+    using PYIndexLib for IPYieldToken;
+    using SafeERC20 for ISuperComposableYield;
+    using SafeERC20 for IPYieldToken;
+    using SafeERC20 for IPPrincipalToken;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor() //solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState();
+
+        PT.safeTransferFrom(msg.sender, market, exactPtIn);
+
+        uint256 totalPtToSwap;
+        (netYtOut, , totalPtToSwap, ) = state.approxSwapExactPtForYt(
+            YT.newIndex(),
+            exactPtIn,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        require(netYtOut >= minYtOut, "insufficient YT out");
+        IPMarket(market).swapExactPtForScy(
+            address(YT),
+            totalPtToSwap,
+            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
+    }
+
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtSwapped
+    ) external returns (uint256 netPtOut) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState();
+
+        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
+
+        uint256 totalPtSwapped;
+        (netPtOut, , totalPtSwapped, ) = state.approxSwapExactYtForPt(
+            YT.newIndex(),
+            exactYtIn,
+            block.timestamp,
+            guessTotalPtSwapped
+        );
+
+        require(netPtOut >= minPtOut, "insufficient PT out");
+
+        IPMarket(market).swapScyForExactPt(
+            address(this),
+            totalPtSwapped,
+            _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());
+    }
+}

package/contracts/core/actions/base/CallbackHelper.sol

@@ -5,7 +5,9 @@ abstract contract CallbackHelper {
     enum ActionType {
         SwapScyForExactYt,
         SwapExactScyForYt,
-        SwapYtForScy
+        SwapYtForScy,
+        SwapExactYtForPt,
+        SwapExactPtForYt
     }
 
     /// ------------------------------------------------------------
@@ -72,6 +74,52 @@ abstract contract CallbackHelper {
         (, receiver, minScyOut) = abi.decode(data, (ActionType, address, uint256));
     }
 
+    function _encodeSwapExactYtForPt(
+        address receiver,
+        uint256 exactYtIn,
+        uint256 minPtOut
+    ) internal pure returns (bytes memory) {
+        return abi.encode(ActionType.SwapExactYtForPt, receiver, exactYtIn, minPtOut);
+    }
+
+    function _decodeSwapExactYtForPt(bytes memory data)
+        internal
+        pure
+        returns (
+            address receiver,
+            uint256 exactYtIn,
+            uint256 minPtOut
+        )
+    {
+        (, receiver, exactYtIn, minPtOut) = abi.decode(
+            data,
+            (ActionType, address, uint256, uint256)
+        );
+    }
+
+    function _encodeSwapExactPtForYt(
+        address receiver,
+        uint256 exactPtIn,
+        uint256 minYtOut
+    ) internal pure returns (bytes memory) {
+        return abi.encode(ActionType.SwapExactPtForYt, receiver, exactPtIn, minYtOut);
+    }
+
+    function _decodeSwapExactPtForYt(bytes memory data)
+        internal
+        pure
+        returns (
+            address receiver,
+            uint256 exactPtIn,
+            uint256 minYtOut
+        )
+    {
+        (, receiver, exactPtIn, minYtOut) = abi.decode(
+            data,
+            (ActionType, address, uint256, uint256)
+        );
+    }
+
     /// ------------------------------------------------------------
     /// Misc functions
     /// ------------------------------------------------------------

package/contracts/interfaces/IPActionSwapPTYT.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
+
+interface IPActionSwapPTYT {
+    event SwapPtAndYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netYtToAccount
+    );
+
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut);
+
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtSwapped
+    ) external returns (uint256 netPtOut);
+}

package/contracts/interfaces/IPAllAction.sol

@@ -5,6 +5,7 @@ pragma solidity 0.8.15;
 import "./IPActionAddRemoveLiq.sol";
 import "./IPActionSwapPT.sol";
 import "./IPActionSwapYT.sol";
+import "./IPActionSwapPTYT.sol";
 import "./IPActionMintRedeem.sol";
 import "./IPActionMisc.sol";
 
@@ -12,6 +13,7 @@ interface IPAllAction is
     IPActionAddRemoveLiq,
     IPActionSwapPT,
     IPActionSwapYT,
+    IPActionSwapPTYT,
     IPActionMintRedeem,
     IPActionMisc
 {}

package/contracts/interfaces/IPVotingEscrow.sol

@@ -5,7 +5,7 @@ pragma solidity 0.8.15;
 import "./IPVeToken.sol";
 import "../libraries/VeBalanceLib.sol";
 
-interface IPVotingEscrow {
+interface IPVotingEscrow is IPVeToken {
     event NewLockPosition(address indexed user, uint128 amount, uint128 expiry);
 
     event Withdraw(address indexed user, uint128 amount);

package/contracts/libraries/math/MarketApproxLib.sol

@@ -272,6 +272,64 @@ library MarketApproxPtInLib {
         revert("approx fail");
     }
 
+    struct Args7 {
+        MarketState market;
+        PYIndex index;
+        uint256 maxPtIn;
+        uint256 blockTime;
+    }
+
+    function approxSwapExactPtForYt(
+        MarketState memory _market,
+        PYIndex _index,
+        uint256 _maxPtIn,
+        uint256 _blockTime,
+        ApproxParams memory _approx // approx for totalPtToSwap
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netYtOut*/
+            uint256, /*netPtIn*/
+            uint256, /*totalPtToSwap*/
+            uint256 /*netScyToReserve*/
+        )
+    {
+        Args7 memory arg = Args7(_market, _index, _maxPtIn, _blockTime);
+
+        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
+        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, comp.totalAsset);
+
+        p.guessMin = Math.max(p.guessMin, arg.maxPtIn);
+
+        for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
+            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, arg.market.totalPt, iter);
+
+            if (!isGoodSlope) {
+                p.guessMax = guess;
+                continue;
+            }
+
+            (uint256 netAssetOut, uint256 netAssetToReserve) = calcAssetOut(
+                arg.market,
+                comp,
+                guess
+            );
+
+            uint256 netPtPayable = netAssetOut + arg.maxPtIn;
+            if (guess <= netPtPayable) {
+                p.guessMin = guess;
+                uint256 netPtIn = guess - netAssetOut; // guess >= netAssetOut (market invariant)
+                if (Math.isASmallerApproxB(netPtIn, arg.maxPtIn, p.eps)) {
+                    return (netAssetOut, netPtIn, guess, arg.index.assetToScy(netAssetToReserve));
+                }
+            } else {
+                p.guessMax = guess - 1;
+            }
+        }
+        revert("approx fail");
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
 
     function calcAssetOut(
@@ -569,6 +627,65 @@ library MarketApproxPtOutLib {
         revert("approx fail");
     }
 
+    struct Args8 {
+        MarketState market;
+        PYIndex index;
+        uint256 maxYtIn;
+        uint256 blockTime;
+        uint256 maxScyRedeemableFromPY;
+    }
+
+    function approxSwapExactYtForPt(
+        MarketState memory _market,
+        PYIndex _index,
+        uint256 _maxYtIn,
+        uint256 _blockTime,
+        ApproxParams memory _approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netPtOut*/
+            uint256, /*netYtIn*/
+            uint256, /*totalPtSwapped*/
+            uint256 /*netScyToReserve*/
+        )
+    {
+        Args8 memory arg = Args8(
+            _market,
+            _index,
+            _maxYtIn,
+            _blockTime,
+            _index.assetToScy(_maxYtIn)
+        );
+        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
+        ApproxParamsPtOut memory p = newApproxParamsPtOut(_approx, comp, arg.market.totalPt);
+
+        p.guessMin = Math.max(p.guessMin, arg.maxYtIn);
+
+        for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
+            uint256 guess = nextGuess(p, iter);
+
+            (uint256 netAssetIn, uint256 netAssetToReserve) = calcAssetIn(arg.market, comp, guess);
+            uint256 netScyIn = arg.index.assetToScyUp(netAssetIn);
+
+            if (netScyIn <= arg.maxScyRedeemableFromPY) {
+                p.guessMin = guess;
+                if (Math.isASmallerApproxB(netAssetIn, arg.maxYtIn, p.eps)) {
+                    return (
+                        guess - arg.maxYtIn,
+                        arg.maxYtIn,
+                        guess,
+                        arg.index.assetToScy(netAssetToReserve)
+                    );
+                }
+            } else {
+                p.guessMax = guess - 1;
+            }
+        }
+        revert("approx fail");
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
 
     function calcAssetIn(

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -233,15 +233,22 @@ library MarketMathStatic {
         MarketState memory state = IPMarket(market).readState();
 
         (uint256 scyFromBurn, uint256 ptFromBurn) = state.removeLiquidity(lpToRemove);
-        uint256 scyFromSwap;
-        (scyFromSwap, netScyFee) = state.swapExactPtForScy(
-            pyIndex(market),
-            ptFromBurn,
-            block.timestamp
-        );
 
-        netScyOut = scyFromBurn + scyFromSwap;
-        priceImpact = calcPriceImpact(market, ptFromBurn.neg());
+        if (IPMarket(market).isExpired()) {
+            (,, IPYieldToken YT) = IPMarket(market).readTokens(); 
+            PYIndex index = PYIndex.wrap(YT.pyIndexCurrent());
+            netScyOut = scyFromBurn + index.assetToScy(ptFromBurn);
+        } else {
+            uint256 scyFromSwap;
+            (scyFromSwap, netScyFee) = state.swapExactPtForScy(
+                pyIndex(market),
+                ptFromBurn,
+                block.timestamp
+            );
+
+            netScyOut = scyFromBurn + scyFromSwap;
+            priceImpact = calcPriceImpact(market, ptFromBurn.neg());
+        }
     }
 
     function removeLiquiditySingleBaseTokenStatic(
@@ -529,6 +536,59 @@ library MarketMathStatic {
             );
     }
 
+    // totalPtToSwap is the param to approx
+    function swapExactPtForYt(
+        address market,
+        uint256 exactPtIn,
+        ApproxParams memory approxParams
+    )
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 totalPtToSwap,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
+        MarketState memory state = IPMarket(market).readState();
+        PYIndex index = pyIndex(market);
+
+        (netYtOut, , totalPtToSwap, netScyFee) = state.approxSwapExactPtForYt(
+            index,
+            exactPtIn,
+            block.timestamp,
+            approxParams
+        );
+        priceImpact = calcPriceImpact(market, totalPtToSwap.neg());
+    }
+
+    // totalPtSwapped is the param to approx
+    function swapExactYtForPt(
+        address market,
+        uint256 exactYtIn,
+        ApproxParams memory approxParams
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 totalPtSwapped,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
+        MarketState memory state = IPMarket(market).readState();
+        PYIndex index = pyIndex(market);
+
+        (netPtOut, , totalPtSwapped, netScyFee) = state.approxSwapExactYtForPt(
+            index,
+            exactYtIn,
+            block.timestamp,
+            approxParams
+        );
+
+        priceImpact = calcPriceImpact(market, totalPtSwapped.Int());
+    }
+
     function pyIndex(address market) public returns (PYIndex index) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -543,6 +603,7 @@ library MarketMathStatic {
         public
         returns (uint256)
     {
+        if (IPMarket(market).isExpired()) return Math.ONE; 
         int256 netPtToAccount = netPtOut;
         MarketState memory state = IPMarket(market).readState();
         MarketPreCompute memory comp = state.getMarketPreCompute(pyIndex(market), block.timestamp);