@pendle/core-v2 3.0.0-beta-2 → 3.0.0-beta-4

package/contracts/router/{PendleRouter.sol → PendleRouterV3.sol}

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/proxy/Proxy.sol";
-import "../interfaces/IPAllAction.sol";
+import "../interfaces/IPAllActionV3.sol";
 import "../interfaces/IDiamondLoupe.sol";
 import "../interfaces/IDiamondCut.sol";
 
 // solhint-disable no-empty-blocks
-contract PendleRouter is Proxy, IDiamondLoupe {
+contract PendleRouterV3 is Proxy, IDiamondLoupe {
     address internal immutable ACTION_ADD_REMOVE_LIQ;
     address internal immutable ACTION_SWAP_PT;
     address internal immutable ACTION_SWAP_YT;
@@ -74,47 +74,49 @@ contract PendleRouter is Proxy, IDiamondLoupe {
         }
         if (facet == ACTION_ADD_REMOVE_LIQ) {
             res = new bytes4[](12);
-            res[0] = 0x17eb5cce; // addLiquiditySingleToken
-            res[1] = 0x1ab7a03e; // removeLiquiditySingleSy
-            res[2] = 0x2756ce06; // addLiquidityDualTokenAndPt
-            res[3] = 0x30f9e6c8; // addLiquiditySinglePt
-            res[4] = 0x3dbe1c55; // addLiquiditySingleTokenKeepYt
-            res[5] = 0x5d8e6054; // removeLiquiditySingleToken
-            res[6] = 0x844384aa; // addLiquiditySingleSyKeepYt
-            res[7] = 0x888a2843; // addLiquiditySingleSy
-            res[8] = 0x97ee279e; // addLiquidityDualSyAndPt
-            res[9] = 0xb00f09d7; // removeLiquidityDualTokenAndPt
-            res[10] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
-            res[11] = 0xbce3faa7; // removeLiquiditySinglePt
+            res[0] = 0x237287c8; // removeLiquiditySinglePt
+            res[1] = 0x2756ce06; // addLiquidityDualTokenAndPt
+            res[2] = 0x3dbe1c55; // addLiquiditySingleTokenKeepYt
+            res[3] = 0x587e3950; // removeLiquiditySingleToken
+            res[4] = 0x5a245eef; // addLiquiditySingleSy
+            res[5] = 0x844384aa; // addLiquiditySingleSyKeepYt
+            res[6] = 0x97ee279e; // addLiquidityDualSyAndPt
+            res[7] = 0x9cb6711e; // addLiquiditySingleToken
+            res[8] = 0xb00f09d7; // removeLiquidityDualTokenAndPt
+            res[9] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
+            res[10] = 0xe81560a4; // removeLiquiditySingleSy
+            res[11] = 0xef03bda7; // addLiquiditySinglePt
         }
         if (facet == ACTION_SWAP_YT) {
             res = new bytes4[](7);
-            res[0] = 0x233548e7; // swapExactSyForYt
-            res[1] = 0x287b21a2; // swapExactYtForToken
-            res[2] = 0x423a1dac; // swapExactTokenForYt
-            res[3] = 0x448b9b95; // swapExactYtForPt
+            res[0] = 0x0a793c62; // swapExactYtForSy
+            res[1] = 0x448b9b95; // swapExactYtForPt
+            res[2] = 0x7e0646c4; // swapExactYtForToken
+            res[3] = 0x9c1010ec; // swapExactTokenForYt
             res[4] = 0xc861a898; // swapExactPtForYt
-            res[5] = 0xd91a37b0; // swapExactYtForSy
+            res[5] = 0xf80915bc; // swapExactSyForYt
             res[6] = 0xfa483e72; // swapCallback
         }
         if (facet == ACTION_SWAP_PT) {
-            res = new bytes4[](4);
-            res[0] = 0x18300b27; // swapExactTokenForPt
-            res[1] = 0x71ea75aa; // swapExactSyForPt
-            res[2] = 0x82064435; // swapExactPtForSy
-            res[3] = 0xf392f08d; // swapExactPtForToken
+            res = new bytes4[](6);
+            res[0] = 0x12c15afc; // swapExactSyForPt
+            res[1] = 0x32aea98a; // swapExactTokenForPt
+            res[2] = 0x5d3e105c; // swapTokenToToken
+            res[3] = 0x7a95dddd; // swapExactPtForSy
+            res[4] = 0xa89eba4a; // swapTokenToTokenViaSy
+            res[5] = 0xc245e48d; // swapExactPtForToken
         }
         if (facet == ACTION_MISC) {
             res = new bytes4[](11);
             res[0] = 0x1a8631b2; // mintPyFromSy
-            res[1] = 0x2e071dc6; // mintSyFromToken
-            res[2] = 0x339748cb; // redeemPyToSy
-            res[3] = 0x339a5572; // redeemSyToToken
-            res[4] = 0x47f1de22; // redeemPyToToken
-            res[5] = 0x60fc8466; // multicall
-            res[6] = 0x7ad2c7af; // multicallRevert
-            res[7] = 0x8ee52744; // callThenRevert
-            res[8] = 0xacdb32df; // approveInf
+            res[1] = 0x1cf0f536; // callThenRevert
+            res[2] = 0x2d8f9d8d; // boostMarkets
+            res[3] = 0x2e071dc6; // mintSyFromToken
+            res[4] = 0x339748cb; // redeemPyToSy
+            res[5] = 0x339a5572; // redeemSyToToken
+            res[6] = 0x47f1de22; // redeemPyToToken
+            res[7] = 0x60fc8466; // multicall
+            res[8] = 0x657b87d8; // multicallRevert
             res[9] = 0xd0f42385; // mintPyFromToken
             res[10] = 0xf7e375e8; // redeemDueInterestAndRewards
         }
@@ -122,84 +124,92 @@ contract PendleRouter is Proxy, IDiamondLoupe {
 
     function facetAddress(bytes4 sig) public view returns (address) {
         if (sig < 0x7a0ed627) {
-            if (sig < 0x339748cb) {
-                if (sig < 0x233548e7) {
-                    if (sig == 0x17eb5cce) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
-                    if (sig == 0x18300b27) return ACTION_SWAP_PT; //swapExactTokenForPt
-                    if (sig == 0x1a8631b2) return ACTION_MISC; //mintPyFromSy
-                    if (sig == 0x1ab7a03e) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
+            if (sig < 0x339a5572) {
+                if (sig < 0x2756ce06) {
+                    if (sig < 0x1a8631b2) {
+                        if (sig == 0x0a793c62) return ACTION_SWAP_YT; //swapExactYtForSy
+                        if (sig == 0x12c15afc) return ACTION_SWAP_PT; //swapExactSyForPt
+                    } else {
+                        if (sig == 0x1a8631b2) return ACTION_MISC; //mintPyFromSy
+                        if (sig == 0x1cf0f536) return ACTION_MISC; //callThenRevert
+                        if (sig == 0x237287c8) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
+                    }
                 } else {
-                    if (sig < 0x287b21a2) {
-                        if (sig == 0x233548e7) return ACTION_SWAP_YT; //swapExactSyForYt
+                    if (sig < 0x2e071dc6) {
                         if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                        if (sig == 0x2d8f9d8d) return ACTION_MISC; //boostMarkets
                     } else {
-                        if (sig == 0x287b21a2) return ACTION_SWAP_YT; //swapExactYtForToken
                         if (sig == 0x2e071dc6) return ACTION_MISC; //mintSyFromToken
-                        if (sig == 0x30f9e6c8) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
+                        if (sig == 0x32aea98a) return ACTION_SWAP_PT; //swapExactTokenForPt
+                        if (sig == 0x339748cb) return ACTION_MISC; //redeemPyToSy
                     }
                 }
             } else {
-                if (sig < 0x47f1de22) {
-                    if (sig < 0x3dbe1c55) {
-                        if (sig == 0x339748cb) return ACTION_MISC; //redeemPyToSy
+                if (sig < 0x587e3950) {
+                    if (sig < 0x448b9b95) {
                         if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
-                    } else {
                         if (sig == 0x3dbe1c55) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleTokenKeepYt
-                        if (sig == 0x423a1dac) return ACTION_SWAP_YT; //swapExactTokenForYt
+                    } else {
                         if (sig == 0x448b9b95) return ACTION_SWAP_YT; //swapExactYtForPt
-                    }
-                } else {
-                    if (sig < 0x5d8e6054) {
                         if (sig == 0x47f1de22) return ACTION_MISC; //redeemPyToToken
                         if (sig == 0x52ef6b2c) return address(this); //facetAddresses
+                    }
+                } else {
+                    if (sig < 0x5d3e105c) {
+                        if (sig == 0x587e3950) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
+                        if (sig == 0x5a245eef) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
                     } else {
-                        if (sig == 0x5d8e6054) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
+                        if (sig == 0x5d3e105c) return ACTION_SWAP_PT; //swapTokenToToken
                         if (sig == 0x60fc8466) return ACTION_MISC; //multicall
-                        if (sig == 0x71ea75aa) return ACTION_SWAP_PT; //swapExactSyForPt
+                        if (sig == 0x657b87d8) return ACTION_MISC; //multicallRevert
                     }
                 }
             }
         } else {
-            if (sig < 0xb00f09d7) {
-                if (sig < 0x888a2843) {
-                    if (sig == 0x7a0ed627) return address(this); //facets
-                    if (sig == 0x7ad2c7af) return ACTION_MISC; //multicallRevert
-                    if (sig == 0x82064435) return ACTION_SWAP_PT; //swapExactPtForSy
-                    if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
-                } else {
-                    if (sig < 0x97ee279e) {
-                        if (sig == 0x888a2843) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
-                        if (sig == 0x8ee52744) return ACTION_MISC; //callThenRevert
+            if (sig < 0xb7d75b8b) {
+                if (sig < 0x9c1010ec) {
+                    if (sig < 0x7e0646c4) {
+                        if (sig == 0x7a0ed627) return address(this); //facets
+                        if (sig == 0x7a95dddd) return ACTION_SWAP_PT; //swapExactPtForSy
                     } else {
+                        if (sig == 0x7e0646c4) return ACTION_SWAP_YT; //swapExactYtForToken
+                        if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
                         if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
-                        if (sig == 0xacdb32df) return ACTION_MISC; //approveInf
+                    }
+                } else {
+                    if (sig < 0xa89eba4a) {
+                        if (sig == 0x9c1010ec) return ACTION_SWAP_YT; //swapExactTokenForYt
+                        if (sig == 0x9cb6711e) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
+                    } else {
+                        if (sig == 0xa89eba4a) return ACTION_SWAP_PT; //swapTokenToTokenViaSy
                         if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
+                        if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
                     }
                 }
             } else {
-                if (sig < 0xd0f42385) {
-                    if (sig < 0xbce3faa7) {
-                        if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
+                if (sig < 0xe81560a4) {
+                    if (sig < 0xc861a898) {
                         if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
+                        if (sig == 0xc245e48d) return ACTION_SWAP_PT; //swapExactPtForToken
                     } else {
-                        if (sig == 0xbce3faa7) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
                         if (sig == 0xc861a898) return ACTION_SWAP_YT; //swapExactPtForYt
                         if (sig == 0xcdffacc6) return address(this); //facetAddress
+                        if (sig == 0xd0f42385) return ACTION_MISC; //mintPyFromToken
                     }
                 } else {
-                    if (sig < 0xf392f08d) {
-                        if (sig == 0xd0f42385) return ACTION_MISC; //mintPyFromToken
-                        if (sig == 0xd91a37b0) return ACTION_SWAP_YT; //swapExactYtForSy
+                    if (sig < 0xf7e375e8) {
+                        if (sig == 0xe81560a4) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
+                        if (sig == 0xef03bda7) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
                     } else {
-                        if (sig == 0xf392f08d) return ACTION_SWAP_PT; //swapExactPtForToken
                         if (sig == 0xf7e375e8) return ACTION_MISC; //redeemDueInterestAndRewards
+                        if (sig == 0xf80915bc) return ACTION_SWAP_YT; //swapExactSyForYt
                         if (sig == 0xfa483e72) return ACTION_SWAP_YT; //swapCallback
                     }
                 }
             }
         }
         revert Errors.RouterInvalidAction(sig);
-        // NUM_FUNC: 38 AVG:4.74 WORST_CASE:6 STOP_BRANCH:4
+        // NUM_FUNC: 40 AVG:4.80 WORST_CASE:6 STOP_BRANCH:3
     }
 
     function facetAddresses() public view returns (address[] memory) {

package/contracts/router/base/ActionBase.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 import "../../core/libraries/TokenHelper.sol";
 import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
-import "../../interfaces/IPAllActionType.sol";
+import "../../interfaces/IPAllActionTypeV3.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../router/base/MarketApproxLib.sol";
 
@@ -57,6 +57,7 @@ abstract contract ActionBase is TokenHelper {
         returns (uint256 netSyOut)
     {
         uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
+        _safeApproveInf(inp.tokenMintSy, SY);
         netSyOut = IStandardizedYield(SY).deposit{value: netNative}(receiver, inp.tokenMintSy, netTokenMintSy, minSyOut);
     }
 
@@ -152,7 +153,7 @@ abstract contract ActionBase is TokenHelper {
         bool doMarketOrder = true;
 
         if (!_isEmptyLimit(limit)) {
-            (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netPtLeft, limit);
+            (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, PT, netPtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(PT), market, netPtLeft);
             }
@@ -186,7 +187,7 @@ abstract contract ActionBase is TokenHelper {
         bool doMarketOrder = true;
 
         if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netSyLeft, limit);
+            (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), market, netSyLeft);
             }
@@ -206,13 +207,15 @@ abstract contract ActionBase is TokenHelper {
     }
 
     // ----------------- LIMIT ORDERS -----------------
-    function _fillLimit(address receiver, uint256 netInput, LimitOrderData calldata lim)
+    function _fillLimit(address receiver, IERC20 tokenIn, uint256 netInput, LimitOrderData calldata lim)
         internal
         returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder)
     {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
+        _safeApproveInf(address(tokenIn), lim.limitRouter);
+
         if (lim.normalFills.length != 0) {
             (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) =
                 router.normalFill(lim.normalFills, receiver, netLeft, EMPTY_BYTES);

package/contracts/router/base/MarketApproxLib.sol

@@ -195,7 +195,7 @@ library MarketApproxPtInLib {
         // it is desired that
         // (netSyOut + netSyHolding) / newTotalSy = netPtRemaining / newTotalPt
         // which is equivalent to
-        // netSyOut * newTotalPt = netPtRemaining * newTotalSy
+        // (netSyOut + netSyHolding) * newTotalPt = netPtRemaining * newTotalSy
 
         syNumerator = (netSyOut + netSyHolding) * newTotalPt;
         ptNumerator = (totalPtIn - guess) * newTotalSy;

package/contracts/router/base/SimulateHelper.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../core/libraries/Errors.sol";
+
+abstract contract SimulateHelper {
+    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
+        public
+        payable
+        virtual
+        returns (bytes[] memory res, uint256[] memory gasUsed)
+    {
+        uint256 length = callDatas.length;
+        res = new bytes[](length);
+        gasUsed = new uint256[](length);
+        for (uint256 i = 0; i < length;) {
+            uint256 gasBefore = gasleft();
+            (, res[i]) = address(this).delegatecall{gas: gasLimit}(
+                abi.encodeWithSignature("callThenRevert(bytes)", callDatas[i])
+            );
+            gasUsed[i] = gasBefore - gasleft();
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function callThenRevert(bytes memory callData) public payable virtual {
+        (bool success, bytes memory resp) = address(this).delegatecall(callData);
+        revert Errors.CallThenRevertError(success, resp);
+    }
+}

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";

package/deployments/42161-core.json

@@ -18,9 +18,9 @@
     "PENDLE": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
     "yieldContractFactory": "0x28dE02Ac3c3F5ef427e55c321F73fDc7F192e8E4",
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
-    "router": "0x704Af9c4D6F19fb4EEdC746Ec5FB0Ed489Baf485",
+    "router": "0xAEDbe69A168422A8fCd9F5C14B208A02e431419A",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0x38812c3ac3563bf200482ac9d096952d7cb55f9b",
+    "pendleSwap": "0x0F1b0bb4bBC9d12C6e3f63e3318D0f4F8789B616",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0x1f6Cee6740e1492C279532348137FF40E0f23D05",
     "liquiditySeedingHelper": "0x5e5A839443f59776a789C40506A63C0c70071008",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "3.0.0-beta-2",
+  "version": "3.0.0-beta-4",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,14 +25,14 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.18.0",
+    "hardhat": "^2.19.0",
     "hardhat-contract-sizer": "^2.10.0",
-    "prettier": "^3.0.3",
-    "prettier-plugin-solidity": "^1.1.3",
-    "solc": "^0.8.21",
-    "solhint": "^3.6.2",
+    "prettier": "^3.1.0",
+    "prettier-plugin-solidity": "^1.2.0",
+    "solc": "^0.8.23-fixed",
+    "solhint": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typechain": "^8.3.1",
+    "typechain": "^8.3.2",
     "typescript": "^5.2.2"
   },
   "scripts": {