@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/router/ActionSwapYTV3.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "./base/ActionBaseCallback.sol";
+import "./base/CallbackHelper.sol";
 import "../interfaces/IPActionSwapYTV3.sol";
 
-contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
+contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
     using PMath for uint256;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
@@ -21,13 +21,19 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(_entry_swapExactSyForYt(YT, limit), address(SY), 1, input);
         (netYtOut, netSyFee) = _swapExactSyForYt(receiver, market, SY, YT, netSyInterm, minYtOut, guessYtOut, limit);
 
         emit SwapYtAndToken(
-            msg.sender, market, input.tokenIn, receiver, netYtOut.Int(), input.netTokenIn.neg(), netSyInterm
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netYtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
         );
     }
 
@@ -39,7 +45,7 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         ApproxParams calldata guessYtOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(SY, msg.sender, _entry_swapExactSyForYt(YT, limit), exactSyIn);
 
         (netYtOut, netSyFee) = _swapExactSyForYt(receiver, market, SY, YT, exactSyIn, minYtOut, guessYtOut, limit);
@@ -71,8 +77,12 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         }
 
         if (doMarketOrder) {
-            (uint256 netYtOutMarket,) =
-                _readMarket(market).approxSwapExactSyForYt(YT.newIndex(), netSyLeft, block.timestamp, guessYtOut);
+            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessYtOut
+            );
 
             (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
                 address(YT),
@@ -96,7 +106,7 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         TokenOutput calldata output,
         LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
 
         (netSyInterm, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, exactYtIn, 0, limit);
@@ -104,7 +114,13 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
         emit SwapYtAndToken(
-            msg.sender, market, output.tokenOut, receiver, exactYtIn.neg(), netTokenOut.Int(), netSyInterm
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            exactYtIn.neg(),
+            netTokenOut.Int(),
+            netSyInterm
         );
     }
 
@@ -115,7 +131,7 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         uint256 minSyOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
 
         (netSyOut, netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, exactYtIn, minSyOut, limit);
@@ -174,13 +190,19 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 totalPtToSwap;
-        (netYtOut, totalPtToSwap, netSyFee) =
-            _readMarket(market).approxSwapExactPtForYt(YT.newIndex(), exactPtIn, block.timestamp, guessTotalPtToSwap);
+        (netYtOut, totalPtToSwap, netSyFee) = _readMarket(market).approxSwapExactPtForYt(
+            YT.newIndex(),
+            exactPtIn,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
 
         _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
 
         IPMarket(market).swapExactPtForSy(
-            address(YT), totalPtToSwap, _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
+            address(YT),
+            totalPtToSwap,
+            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
         );
 
         emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
@@ -197,14 +219,20 @@ contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 totalPtFromSwap;
-        (netPtOut, totalPtFromSwap, netSyFee) =
-            _readMarket(market).approxSwapExactYtForPt(YT.newIndex(), exactYtIn, block.timestamp, guessTotalPtFromSwap);
+        (netPtOut, totalPtFromSwap, netSyFee) = _readMarket(market).approxSwapExactYtForPt(
+            YT.newIndex(),
+            exactYtIn,
+            block.timestamp,
+            guessTotalPtFromSwap
+        );
 
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
         IPMarket(market).swapSyForExactPt(
-            address(this), totalPtFromSwap, _encodeSwapExactYtForPt(receiver, netPtOut, PT, YT)
+            address(this),
+            totalPtFromSwap,
+            _encodeSwapExactYtForPt(receiver, netPtOut, PT, YT)
         );
 
         emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());

package/contracts/router/PendleRouterHelper.sol

@@ -42,7 +42,15 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         _wrap_unwrap_ETH(NATIVE, WETH, input.netTokenIn);
         (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(receiver, market, minLpOut, minYtOut, input);
 
-        emit AddLiquiditySingleTokenKeepYt(msg.sender, market, NATIVE, msg.sender, input.netTokenIn, netLpOut, netYtOut);
+        emit AddLiquiditySingleTokenKeepYt(
+            msg.sender,
+            market,
+            NATIVE,
+            msg.sender,
+            input.netTokenIn,
+            netLpOut,
+            netYtOut
+        );
     }
 
     function transferLiquidityDifferentSyNormal(
@@ -77,16 +85,18 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyZapIn);
     }
 
-    function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
-        public
-        returns (uint256 netTokenOut, uint256 netSyFee)
-    {
+    function removeLiquiditySingleToken(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket
+    ) public returns (uint256 netTokenOut, uint256 netSyFee) {
         _transferFrom(IERC20(fromMarket.market), msg.sender, address(this), fromMarket.netLpToRemove);
 
         _safeApproveInf(fromMarket.market, address(ROUTER));
 
         (netTokenOut, netSyFee) = ROUTER.removeLiquiditySingleToken(
-            address(this), fromMarket.market, fromMarket.netLpToRemove, fromMarket.output
+            address(this),
+            fromMarket.market,
+            fromMarket.netLpToRemove,
+            fromMarket.output
         );
 
         if (fromMarket.doRedeemRewards) {
@@ -94,20 +104,28 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         }
 
         emit RemoveLiquiditySingleToken(
-            msg.sender, fromMarket.market, fromMarket.output.tokenOut, msg.sender, fromMarket.netLpToRemove, netTokenOut
+            msg.sender,
+            fromMarket.market,
+            fromMarket.output.tokenOut,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netTokenOut
         );
     }
 
-    function removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
-        public
-        returns (uint256 netSyOut, uint256 netSyFee)
-    {
+    function removeLiquiditySingleSy(
+        RemoveLiquiditySingleSyStruct calldata fromMarket
+    ) public returns (uint256 netSyOut, uint256 netSyFee) {
         _transferFrom(IERC20(fromMarket.market), msg.sender, address(this), fromMarket.netLpToRemove);
 
         _safeApproveInf(fromMarket.market, address(ROUTER));
 
-        (netSyOut, netSyFee) =
-            ROUTER.removeLiquiditySingleSy(address(this), fromMarket.market, fromMarket.netLpToRemove, 0);
+        (netSyOut, netSyFee) = ROUTER.removeLiquiditySingleSy(
+            address(this),
+            fromMarket.market,
+            fromMarket.netLpToRemove,
+            0
+        );
 
         if (fromMarket.doRedeemRewards) {
             IPMarket(fromMarket.market).redeemRewards(msg.sender);
@@ -139,11 +157,11 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         emit AddLiquiditySingleToken(msg.sender, toMarket.market, tokenToZapIn, msg.sender, actualNetTokenIn, netLpOut);
     }
 
-    function _addLiquiditySingleSy(AddLiquiditySingleSyStruct calldata toMarket, uint256 actualNetSyIn)
-        internal
-        returns (uint256 netLpOut, uint256 netSyFee)
-    {
-        (IStandardizedYield SY,,) = IPMarket(toMarket.market).readTokens();
+    function _addLiquiditySingleSy(
+        AddLiquiditySingleSyStruct calldata toMarket,
+        uint256 actualNetSyIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
 
         _safeApproveInf(address(SY), address(ROUTER));
 
@@ -179,20 +197,30 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         );
 
         emit AddLiquiditySingleTokenKeepYt(
-            msg.sender, toMarket.market, tokenToZapIn, msg.sender, actualNetTokenIn, netLpOut, netYtOut
+            msg.sender,
+            toMarket.market,
+            tokenToZapIn,
+            msg.sender,
+            actualNetTokenIn,
+            netLpOut,
+            netYtOut
         );
     }
 
-    function _addLiquiditySingleSyKeepYt(AddLiquiditySingleSyKeepYtStruct calldata toMarket, uint256 actualNetSyIn)
-        internal
-        returns (uint256 netLpOut, uint256 netYtOut)
-    {
-        (IStandardizedYield SY,,) = IPMarket(toMarket.market).readTokens();
+    function _addLiquiditySingleSyKeepYt(
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket,
+        uint256 actualNetSyIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
 
         _safeApproveInf(address(SY), address(ROUTER));
 
         (netLpOut, netYtOut) = ROUTER.addLiquiditySingleSyKeepYt(
-            msg.sender, toMarket.market, actualNetSyIn, toMarket.minLpOut, toMarket.minYtOut
+            msg.sender,
+            toMarket.market,
+            actualNetSyIn,
+            toMarket.minLpOut,
+            toMarket.minYtOut
         );
 
         emit AddLiquiditySingleSyKeepYt(msg.sender, toMarket.market, msg.sender, actualNetSyIn, netLpOut, netYtOut);
@@ -207,23 +235,24 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
     }
 
     /// @dev either SY or Token here is good since token->sy conversion is almost linearly proportional
-    function _scaleApproxParams(ApproxParams calldata params, uint256 guessNetTokenIn, uint256 actualNetTokenIn)
-        internal
-        pure
-        returns (ApproxParams memory)
-    {
+    function _scaleApproxParams(
+        ApproxParams calldata params,
+        uint256 guessNetTokenIn,
+        uint256 actualNetTokenIn
+    ) internal pure returns (ApproxParams memory) {
         if (params.guessOffchain == 0) {
             require(params.guessMin == 0 && params.guessMax == type(uint256).max, "invalid guess");
             return params;
         }
 
-        return ApproxParams({
-            guessMin: (params.guessMin * actualNetTokenIn) / guessNetTokenIn,
-            guessMax: (params.guessMax * actualNetTokenIn) / guessNetTokenIn,
-            guessOffchain: (params.guessOffchain * actualNetTokenIn) / guessNetTokenIn,
-            maxIteration: params.maxIteration,
-            eps: params.eps
-        });
+        return
+            ApproxParams({
+                guessMin: (params.guessMin * actualNetTokenIn) / guessNetTokenIn,
+                guessMax: (params.guessMax * actualNetTokenIn) / guessNetTokenIn,
+                guessOffchain: (params.guessOffchain * actualNetTokenIn) / guessNetTokenIn,
+                maxIteration: params.maxIteration,
+                eps: params.eps
+            });
     }
 }
 
@@ -260,9 +289,12 @@ interface RouterV2InterfaceForRouterHelper {
         TokenInput calldata input
     ) external returns (uint256 netLpOut, uint256 netYtOut);
 
-    function removeLiquiditySingleSy(address receiver, address market, uint256 netLpToRemove, uint256 minSyOut)
-        external
-        returns (uint256 netSyOut, uint256 netSyFee);
+    function removeLiquiditySingleSy(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function removeLiquiditySingleToken(
         address receiver,

package/contracts/router/PendleRouterV3.sol

@@ -12,6 +12,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
     address internal immutable ACTION_SWAP_PT;
     address internal immutable ACTION_SWAP_YT;
     address internal immutable ACTION_MISC;
+    address internal immutable ACTION_CALLBACK;
 
     event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
 
@@ -19,12 +20,14 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         address _ACTION_ADD_REMOVE_LIQ,
         address _ACTION_SWAP_PT,
         address _ACTION_SWAP_YT,
-        address _ACTION_MISC
+        address _ACTION_MISC,
+        address _ACTION_CALLBACK
     ) {
         ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
         ACTION_SWAP_PT = _ACTION_SWAP_PT;
         ACTION_SWAP_YT = _ACTION_SWAP_YT;
         ACTION_MISC = _ACTION_MISC;
+        ACTION_CALLBACK = _ACTION_CALLBACK;
         _emitEvents();
     }
 
@@ -34,7 +37,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         uint256 nFacets = facets_.length;
 
         IDiamondCut.FacetCut[] memory cuts = new IDiamondCut.FacetCut[](nFacets);
-        for (uint256 i; i < nFacets;) {
+        for (uint256 i; i < nFacets; ) {
             cuts[i].facetAddress = facets_[i].facetAddress;
             cuts[i].action = IDiamondCut.FacetCutAction.Add;
             cuts[i].functionSelectors = facets_[i].functionSelectors;
@@ -55,7 +58,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         uint256 numFacets = facetAddresses_.length;
 
         facets_ = new Facet[](numFacets);
-        for (uint256 i; i < numFacets;) {
+        for (uint256 i; i < numFacets; ) {
             facets_[i].facetAddress = facetAddresses_[i];
             facets_[i].functionSelectors = facetFunctionSelectors(facetAddresses_[i]);
             unchecked {
@@ -74,136 +77,139 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         }
         if (facet == ACTION_ADD_REMOVE_LIQ) {
             res = new bytes4[](12);
-            res[0] = 0x237287c8; // removeLiquiditySinglePt
+            res[0] = 0x12599ac6; // addLiquiditySingleToken
             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
+            res[3] = 0x4e390267; // addLiquiditySinglePt
+            res[4] = 0x58bda475; // addLiquiditySingleSy
+            res[5] = 0x60da0860; // removeLiquiditySingleToken
+            res[6] = 0x6b77ac9e; // removeLiquiditySinglePt
+            res[7] = 0x844384aa; // addLiquiditySingleSyKeepYt
+            res[8] = 0x97ee279e; // addLiquidityDualSyAndPt
+            res[9] = 0xb00f09d7; // removeLiquidityDualTokenAndPt
+            res[10] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
+            res[11] = 0xd13b4fdc; // removeLiquiditySingleSy
         }
         if (facet == ACTION_SWAP_YT) {
-            res = new bytes4[](7);
-            res[0] = 0x0a793c62; // swapExactYtForSy
+            res = new bytes4[](6);
+            res[0] = 0x05eb5327; // swapExactYtForToken
             res[1] = 0x448b9b95; // swapExactYtForPt
-            res[2] = 0x7e0646c4; // swapExactYtForToken
-            res[3] = 0x9c1010ec; // swapExactTokenForYt
+            res[2] = 0x7b8b4b95; // swapExactSyForYt
+            res[3] = 0x80c4d566; // swapExactYtForSy
             res[4] = 0xc861a898; // swapExactPtForYt
-            res[5] = 0xf80915bc; // swapExactSyForYt
-            res[6] = 0xfa483e72; // swapCallback
+            res[5] = 0xed48907e; // swapExactTokenForYt
         }
         if (facet == ACTION_SWAP_PT) {
             res = new bytes4[](4);
-            res[0] = 0x12c15afc; // swapExactSyForPt
-            res[1] = 0x32aea98a; // swapExactTokenForPt
-            res[2] = 0x7a95dddd; // swapExactPtForSy
-            res[3] = 0xc245e48d; // swapExactPtForToken
+            res[0] = 0x2a50917c; // swapExactSyForPt
+            res[1] = 0x3346d3a3; // swapExactPtForSy
+            res[2] = 0x594a88cc; // swapExactPtForToken
+            res[3] = 0xc81f847a; // swapExactTokenForPt
+        }
+        if (facet == ACTION_CALLBACK) {
+            res = new bytes4[](2);
+            res[0] = 0xeb3a7d47; // limitRouterCallback
+            res[1] = 0xfa483e72; // swapCallback
         }
         if (facet == ACTION_MISC) {
-            res = new bytes4[](13);
+            res = new bytes4[](12);
             res[0] = 0x1a8631b2; // mintPyFromSy
-            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] = 0x5d3e105c; // swapTokenToToken
-            res[8] = 0x60fc8466; // multicall
-            res[9] = 0x657b87d8; // multicallRevert
-            res[10] = 0xa89eba4a; // swapTokenToTokenViaSy
-            res[11] = 0xd0f42385; // mintPyFromToken
-            res[12] = 0xf7e375e8; // redeemDueInterestAndRewards
+            res[1] = 0x2d8f9d8d; // boostMarkets
+            res[2] = 0x2e071dc6; // mintSyFromToken
+            res[3] = 0x339748cb; // redeemPyToSy
+            res[4] = 0x339a5572; // redeemSyToToken
+            res[5] = 0x47f1de22; // redeemPyToToken
+            res[6] = 0x5d3e105c; // swapTokenToToken
+            res[7] = 0x60fc8466; // multicall
+            res[8] = 0xa89eba4a; // swapTokenToTokenViaSy
+            res[9] = 0xbd61951d; // simulate
+            res[10] = 0xd0f42385; // mintPyFromToken
+            res[11] = 0xf7e375e8; // redeemDueInterestAndRewards
         }
     }
 
     function facetAddress(bytes4 sig) public view returns (address) {
-        if (sig < 0x7a0ed627) {
-            if (sig < 0x339a5572) {
-                if (sig < 0x2756ce06) {
+        if (sig < 0x6b77ac9e) {
+            if (sig < 0x3dbe1c55) {
+                if (sig < 0x2d8f9d8d) {
                     if (sig < 0x1a8631b2) {
-                        if (sig == 0x0a793c62) return ACTION_SWAP_YT; //swapExactYtForSy
-                        if (sig == 0x12c15afc) return ACTION_SWAP_PT; //swapExactSyForPt
+                        if (sig == 0x05eb5327) return ACTION_SWAP_YT; //swapExactYtForToken
+                        if (sig == 0x12599ac6) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
                     } else {
                         if (sig == 0x1a8631b2) return ACTION_MISC; //mintPyFromSy
-                        if (sig == 0x1cf0f536) return ACTION_MISC; //callThenRevert
-                        if (sig == 0x237287c8) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
+                        if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                        if (sig == 0x2a50917c) return ACTION_SWAP_PT; //swapExactSyForPt
                     }
                 } else {
-                    if (sig < 0x2e071dc6) {
-                        if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                    if (sig < 0x3346d3a3) {
                         if (sig == 0x2d8f9d8d) return ACTION_MISC; //boostMarkets
-                    } else {
                         if (sig == 0x2e071dc6) return ACTION_MISC; //mintSyFromToken
-                        if (sig == 0x32aea98a) return ACTION_SWAP_PT; //swapExactTokenForPt
+                    } else {
+                        if (sig == 0x3346d3a3) return ACTION_SWAP_PT; //swapExactPtForSy
                         if (sig == 0x339748cb) return ACTION_MISC; //redeemPyToSy
+                        if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
                     }
                 }
             } else {
-                if (sig < 0x587e3950) {
-                    if (sig < 0x448b9b95) {
-                        if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
+                if (sig < 0x58bda475) {
+                    if (sig < 0x47f1de22) {
                         if (sig == 0x3dbe1c55) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleTokenKeepYt
-                    } else {
                         if (sig == 0x448b9b95) return ACTION_SWAP_YT; //swapExactYtForPt
+                    } else {
                         if (sig == 0x47f1de22) return ACTION_MISC; //redeemPyToToken
+                        if (sig == 0x4e390267) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
                         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
+                        if (sig == 0x58bda475) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
+                        if (sig == 0x594a88cc) return ACTION_SWAP_PT; //swapExactPtForToken
                     } else {
                         if (sig == 0x5d3e105c) return ACTION_MISC; //swapTokenToToken
+                        if (sig == 0x60da0860) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
                         if (sig == 0x60fc8466) return ACTION_MISC; //multicall
-                        if (sig == 0x657b87d8) return ACTION_MISC; //multicallRevert
                     }
                 }
             }
         } else {
-            if (sig < 0xb7d75b8b) {
-                if (sig < 0x9c1010ec) {
-                    if (sig < 0x7e0646c4) {
+            if (sig < 0xbd61951d) {
+                if (sig < 0x97ee279e) {
+                    if (sig < 0x7b8b4b95) {
+                        if (sig == 0x6b77ac9e) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
                         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 == 0x7b8b4b95) return ACTION_SWAP_YT; //swapExactSyForYt
+                        if (sig == 0x80c4d566) return ACTION_SWAP_YT; //swapExactYtForSy
                         if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
-                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
                     }
                 } else {
-                    if (sig < 0xa89eba4a) {
-                        if (sig == 0x9c1010ec) return ACTION_SWAP_YT; //swapExactTokenForYt
-                        if (sig == 0x9cb6711e) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
-                    } else {
+                    if (sig < 0xadfca15e) {
+                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
                         if (sig == 0xa89eba4a) return ACTION_MISC; //swapTokenToTokenViaSy
+                    } else {
                         if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
                         if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
+                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
                     }
                 }
             } else {
-                if (sig < 0xe81560a4) {
+                if (sig < 0xd13b4fdc) {
                     if (sig < 0xc861a898) {
-                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
-                        if (sig == 0xc245e48d) return ACTION_SWAP_PT; //swapExactPtForToken
+                        if (sig == 0xbd61951d) return ACTION_MISC; //simulate
+                        if (sig == 0xc81f847a) return ACTION_SWAP_PT; //swapExactTokenForPt
                     } else {
                         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 < 0xf7e375e8) {
-                        if (sig == 0xe81560a4) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
-                        if (sig == 0xef03bda7) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
+                    if (sig < 0xed48907e) {
+                        if (sig == 0xd13b4fdc) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
+                        if (sig == 0xeb3a7d47) return ACTION_CALLBACK; //limitRouterCallback
                     } else {
+                        if (sig == 0xed48907e) return ACTION_SWAP_YT; //swapExactTokenForYt
                         if (sig == 0xf7e375e8) return ACTION_MISC; //redeemDueInterestAndRewards
-                        if (sig == 0xf80915bc) return ACTION_SWAP_YT; //swapExactSyForYt
-                        if (sig == 0xfa483e72) return ACTION_SWAP_YT; //swapCallback
+                        if (sig == 0xfa483e72) return ACTION_CALLBACK; //swapCallback
                     }
                 }
             }
@@ -213,12 +219,13 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
     }
 
     function facetAddresses() public view returns (address[] memory) {
-        address[] memory res = new address[](5);
+        address[] memory res = new address[](6);
         res[0] = address(this);
         res[1] = ACTION_ADD_REMOVE_LIQ;
         res[2] = ACTION_SWAP_YT;
         res[3] = ACTION_SWAP_PT;
-        res[4] = ACTION_MISC;
+        res[4] = ACTION_CALLBACK;
+        res[5] = ACTION_MISC;
         return res;
     }