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

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;
     }
@@ -82,6 +85,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/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/libraries/math/MarketApproxLib.sol

@@ -272,6 +272,63 @@ 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) {
+                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 +626,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

@@ -529,6 +529,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();
 

package/contracts/offchain-helpers/RouterStatic.sol

@@ -570,6 +570,30 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             );
     }
 
+    function swapExactPtForYtStatic(address market, uint256 exactPtIn)
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 totalPtToSwap,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
+        return MarketMathStatic.swapExactPtForYt(market, exactPtIn, getDefaultApproxParams());
+    }
+
+    function swapExactYtForPtStatic(address market, uint256 exactYtIn)
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 totalPtSwapped,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
+        return MarketMathStatic.swapExactYtForPt(market, exactYtIn, getDefaultApproxParams());
+    }
+
     // ============= OTHER HELPERS =============
 
     function mintPYFromScyStatic(address YT, uint256 amountScyToMint)

package/deployments/43113-core.json

@@ -7,7 +7,7 @@
     "yieldContractFactory": "0x38E5A1D591553b5FF18b151B587745a4A9B206d2",
     "marketFactory": "0xE646E5425fD448b2f9dDF6de12383CcF5275143B",
     "router": "0xa4C21f51DE870a283f362A7331f0C4f8288c3e41",
-    "routerStatic": "0xc875e3b8aED24cc54C4750D790036D631F6cacbD",
+    "routerStatic": "0x4ea00Cd73C773764A398e27ed2F789f50F168c52",
     "startTime": 1657756800,
     "vePendle": "0x3AE0fee115057cCF8A0B5255751027C26D83B912",
     "votingController": "0x76815E13679C7F18a406f5BA94E352E656BeE378",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.11.8-testnet",
+  "version": "0.11.9-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -37,8 +37,6 @@
     "typescript": "^4.8.2"
   },
   "scripts": {
-    "prepublish": "yarn hardhat compile",
-    "publish": "npm publish",
     "compile": "yarn hardhat compile",
     "size": "yarn hardhat size-contracts",
     "clean": "yarn hardhat clean",