@pendle/core-v2 1.2.0-mainnet → 1.2.0-testnet

package/contracts/router/ActionMisc.sol

@@ -1,25 +1,51 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../interfaces/IPMarket.sol";
 import "../interfaces/IPActionMisc.sol";
-import "../core/libraries/Errors.sol";
-
-contract ActionMisc is IPActionMisc {
-    using Math for uint256;
-
-    function consult(address market, uint32 secondsAgo)
-        external
-        view
-        returns (uint96 lnImpliedRateMean)
-    {
-        if (secondsAgo == 0) revert Errors.RouterTimeRangeZero();
-        uint32[] memory secondsAgos = new uint32[](2);
-        secondsAgos[0] = secondsAgo;
-        secondsAgos[1] = 0;
-        uint216[] memory lnImpliedRateCumulatives = IPMarket(market).observe(secondsAgos);
-        return
-            (uint256(lnImpliedRateCumulatives[1] - lnImpliedRateCumulatives[0]) / secondsAgo)
-                .Uint96();
+import "../core/libraries/TokenHelper.sol";
+
+contract ActionMisc is IPActionMisc, TokenHelper {
+    function approveInf(MultiApproval[] calldata arr) external {
+        for (uint256 i = 0; i < arr.length; ) {
+            MultiApproval calldata ele = arr[i];
+            for (uint256 j = 0; j < ele.tokens.length; ) {
+                _safeApproveInf(ele.tokens[j], ele.spender);
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function batchExec(Call3[] calldata calls) external returns (Result[] memory res) {
+        uint256 length = calls.length;
+
+        res = new Result[](length);
+
+        Call3 calldata calli;
+
+        for (uint256 i = 0; i < length; ) {
+            calli = calls[i];
+
+            // delegatecall to itself, it turns allowing invoking functions from other actions
+            (bool success, bytes memory result) = address(this).delegatecall(calli.callData);
+
+            if (!success && !calli.allowFailure) {
+                assembly {
+                    // We use Yul's revert() to bubble up errors from the target contract.
+                    revert(add(32, result), mload(result))
+                }
+            }
+
+            res[i].success = success;
+            res[i].returnData = result;
+
+            unchecked {
+                ++i;
+            }
+        }
     }
 }

package/contracts/router/ActionSwapPT.sol

@@ -15,11 +15,6 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using Math for int256;
     using PYIndexLib for IPYieldToken;
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
-    {}
-
     /**
      * @notice swaps exact amount of PT for SY
      * @param exactPtIn will always consume this exact amount of PT for as much SY as possible

package/contracts/router/ActionSwapYT.sol

@@ -4,11 +4,14 @@ pragma solidity 0.8.17;
 import "./base/ActionBaseMintRedeem.sol";
 import "./base/CallbackHelper.sol";
 import "../interfaces/IPActionSwapYT.sol";
+import "../interfaces/IAddressProvider.sol";
 import "../interfaces/IPMarket.sol";
 import "../core/libraries/Errors.sol";
 
+import "./base/ActionBaseCallback.sol";
+
 /// @dev All swap actions will revert if market is expired
-contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
+contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBaseMintRedeem {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -16,10 +19,11 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
-    {}
+    constructor(IAddressProvider provider, uint256 providerId) ActionBaseCallback(_getMarketFactory(provider,providerId)) {}
+
+    function _getMarketFactory(IAddressProvider provider, uint256 providerId) internal view returns (address) {
+        return provider.get(providerId);
+    }
 
     /**
      * @notice swap exact SY to YT with the help of flashswaps & YT tokenization / redemption
@@ -38,7 +42,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -105,7 +109,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
-            _encodeSwapSyForExactYt(msg.sender, receiver, maxSyIn)
+            _encodeSwapSyForExactYt(msg.sender, receiver, maxSyIn, SY, YT)
         );
 
         netSyIn = preSyBalance - SY.balanceOf(msg.sender);
@@ -129,7 +133,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactSyOut,
         uint256 maxYtIn,
-        ApproxParams memory guessYtIn
+        ApproxParams calldata guessYtIn
     ) external returns (uint256 netYtIn, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState(address(this));
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
@@ -148,7 +152,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
-            _encodeSwapYtForSy(receiver, exactSyOut)
+            _encodeSwapYtForSy(receiver, exactSyOut, YT)
         );
 
         emit SwapYtAndSy(msg.sender, market, receiver, netYtIn.neg(), exactSyOut.Int());
@@ -163,7 +167,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address receiver,
         address market,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut,
+        ApproxParams calldata guessYtOut,
         TokenInput calldata input
     ) external payable returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
@@ -227,13 +231,99 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         );
     }
 
+    /**
+     * @notice swap exact PT to YT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactPtIn` PT is transferred to market contract
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
+        Note that we will owe PT, the amount before is not sufficient
+     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay the rest of the loan, and YT
+        transferred to the receiver
+     * @param exactPtIn will always consume this amount of PT for as much YT as possible
+     * @param guessTotalPtToSwap approximation data for PT used for the PT-to-SY flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+
+        uint256 totalPtToSwap;
+        (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
+            YT.newIndex(),
+            exactPtIn,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+
+        IPMarket(market).swapExactPtForSy(
+            address(YT),
+            totalPtToSwap,
+            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
+    }
+
+    /**
+     * @notice swap exact YT to PT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactYtIn` YT is transferred to yield contract
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to this contract & callback is invoked.
+        Note that we now owe SY
+     - in callback, a portion of PT + YT is used to redeem SY, which is then used to payback the loan. The rest of
+       of the PT is transferred to `receiver`
+     * @param exactYtIn will always consume this amount of YT for as much PT as possible
+     * @param guessTotalPtFromSwap approximation data for PT output of the SY-to-PT flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtFromSwap
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
+
+        uint256 totalPtFromSwap;
+        (netPtOut, totalPtFromSwap, netSyFee) = state.approxSwapExactYtForPt(
+            YT.newIndex(),
+            exactYtIn,
+            block.timestamp,
+            guessTotalPtFromSwap
+        );
+
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+
+        IPMarket(market).swapSyForExactPt(
+            address(this),
+            totalPtFromSwap,
+            _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut, PT, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());
+    }
+
     function _swapExactSyForYt(
         address receiver,
         address market,
         IPYieldToken YT,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) internal returns (uint256 netYtOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState(address(this));
 
@@ -250,7 +340,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             netYtOut, // exactPtIn = netYtOut
-            _encodeSwapExactSyForYt(receiver, minYtOut)
+            _encodeSwapExactSyForYt(receiver, minYtOut, YT)
         );
     }
 
@@ -267,7 +357,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
-            _encodeSwapYtForSy(receiver, minSyOut)
+            _encodeSwapYtForSy(receiver, minSyOut, YT)
         );
 
         netSyOut = SY.balanceOf(receiver) - preSyBalance;

package/contracts/router/PendleRouter.sol

@@ -1,103 +1,242 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../interfaces/IPAllAction.sol";
-import "../interfaces/IPMarketSwapCallback.sol";
-import "../core/libraries/Errors.sol";
-
-/// @dev this contract will be deployed behind an ERC1967 proxy
-/// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
-/// corresponding implementation contracts
+import "../interfaces/IDiamondLoupe.sol";
+import "../interfaces/IDiamondCut.sol";
 
 // solhint-disable no-empty-blocks
-contract PendleRouter is Proxy {
-    address public immutable ACTION_MINT_REDEEM;
-    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;
+contract PendleRouter is Proxy, IDiamondLoupe {
+    address internal immutable ACTION_MINT_REDEEM;
+    address internal immutable ACTION_ADD_REMOVE_LIQ;
+    address internal immutable ACTION_SWAP_PT;
+    address internal immutable ACTION_SWAP_YT;
+    address internal immutable ACTION_MISC;
+
+    event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
 
     constructor(
         address _ACTION_MINT_REDEEM,
         address _ACTION_ADD_REMOVE_LIQ,
         address _ACTION_SWAP_PT,
         address _ACTION_SWAP_YT,
-        address _ACTION_SWAP_PTYT,
-        address _ACTION_CALLBACK,
         address _ACTION_MISC
     ) {
         ACTION_MINT_REDEEM = _ACTION_MINT_REDEEM;
         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;
+        _emitEvents();
+    }
+
+    function _emitEvents() internal {
+        Facet[] memory facets_ = facets();
+
+        uint256 nFacets = facets_.length;
+
+        IDiamondCut.FacetCut[] memory cuts = new IDiamondCut.FacetCut[](nFacets);
+        for (uint256 i; i < nFacets; ) {
+            cuts[i].facetAddress = facets_[i].facetAddress;
+            cuts[i].action = IDiamondCut.FacetCutAction.Add;
+            cuts[i].functionSelectors = facets_[i].functionSelectors;
+            unchecked {
+                ++i;
+            }
+        }
+
+        emit DiamondCut(cuts, address(0), "");
     }
 
     receive() external payable virtual override {}
 
-    function getRouterImplementation(bytes4 sig) public view returns (address) {
-        if (
-            sig == IPActionMintRedeem.mintSyFromToken.selector ||
-            sig == IPActionMintRedeem.redeemSyToToken.selector ||
-            sig == IPActionMintRedeem.mintPyFromToken.selector ||
-            sig == IPActionMintRedeem.redeemPyToToken.selector ||
-            sig == IPActionMintRedeem.mintPyFromSy.selector ||
-            sig == IPActionMintRedeem.redeemPyToSy.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewardsThenSwapAll.selector
-        ) {
-            return ACTION_MINT_REDEEM;
-        } else if (
-            sig == IPActionAddRemoveLiq.addLiquidityDualSyAndPt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquidityDualTokenAndPt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySingleSy.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySingleToken.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquidityDualSyAndPt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquidityDualTokenAndPt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySingleSy.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySingleToken.selector
-        ) {
-            return ACTION_ADD_REMOVE_LIQ;
-        } else if (
-            sig == IPActionSwapPT.swapExactPtForSy.selector ||
-            sig == IPActionSwapPT.swapPtForExactSy.selector ||
-            sig == IPActionSwapPT.swapSyForExactPt.selector ||
-            sig == IPActionSwapPT.swapExactSyForPt.selector ||
-            sig == IPActionSwapPT.swapExactTokenForPt.selector ||
-            sig == IPActionSwapPT.swapExactPtForToken.selector
-        ) {
-            return ACTION_SWAP_PT;
-        } else if (
-            sig == IPActionSwapYT.swapExactYtForSy.selector ||
-            sig == IPActionSwapYT.swapSyForExactYt.selector ||
-            sig == IPActionSwapYT.swapExactSyForYt.selector ||
-            sig == IPActionSwapYT.swapExactTokenForYt.selector ||
-            sig == IPActionSwapYT.swapExactYtForToken.selector ||
-            sig == IPActionSwapYT.swapYtForExactSy.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) {
-            return ACTION_MISC;
+    /// @notice Gets all facet addresses and their four byte function selectors.
+    /// @return facets_ Facet
+    function facets() public view returns (Facet[] memory facets_) {
+        address[] memory facetAddresses_ = facetAddresses();
+        uint256 numFacets = facetAddresses_.length;
+
+        facets_ = new Facet[](numFacets);
+        for (uint256 i; i < numFacets; ) {
+            facets_[i].facetAddress = facetAddresses_[i];
+            facets_[i].functionSelectors = facetFunctionSelectors(facetAddresses_[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetFunctionSelectors(address facet) public view returns (bytes4[] memory res) {
+        if (facet == ACTION_ADD_REMOVE_LIQ) {
+            res = new bytes4[](12);
+            res[0] = 0x97ee279e; // addLiquidityDualSyAndPt
+            res[1] = 0xcb591eb2; // addLiquidityDualTokenAndPt
+            res[2] = 0x3af1f329; // addLiquiditySinglePt
+            res[3] = 0x409c7a89; // addLiquiditySingleSy
+            res[4] = 0x015491d1; // addLiquiditySingleToken
+            res[5] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
+            res[6] = 0xe6eaba01; // removeLiquidityDualTokenAndPt
+            res[7] = 0x694ab559; // removeLiquiditySinglePt
+            res[8] = 0x178d29d3; // removeLiquiditySingleSy
+            res[9] = 0x690807ad; // removeLiquiditySingleToken
+            res[10] = 0xdfbc814e; // addLiquiditySingleTokenKeepYt
+            res[11] = 0x844384aa; // addLiquiditySingleSyKeepYt
+            return res;
+        }
+        if (facet == ACTION_MINT_REDEEM) {
+            res = new bytes4[](7);
+            res[0] = 0x1a8631b2; // mintPyFromSy
+            res[1] = 0x46eb2db6; // mintPyFromToken
+            res[2] = 0x443e6512; // mintSyFromToken
+            res[3] = 0xf7e375e8; // redeemDueInterestAndRewards
+            res[4] = 0x339748cb; // redeemPyToSy
+            res[5] = 0x527df199; // redeemPyToToken
+            res[6] = 0x85b29936; // redeemSyToToken
+            return res;
+        }
+        if (facet == ACTION_SWAP_PT) {
+            res = new bytes4[](6);
+            res[0] = 0x2032aecd; // swapExactPtForSy
+            res[1] = 0xb85f50ba; // swapExactPtForToken
+            res[2] = 0x83c71b69; // swapExactSyForPt
+            res[3] = 0xa5f9931b; // swapExactTokenForPt
+            res[4] = 0xdd371acd; // swapPtForExactSy
+            res[5] = 0x6b8bdf32; // swapSyForExactPt
+            return res;
+        }
+        if (facet == ACTION_SWAP_YT) {
+            res = new bytes4[](9);
+            res[0] = 0xfa483e72; // swapCallback
+            res[1] = 0xc861a898; // swapExactPtForYt
+            res[2] = 0x448b9b95; // swapExactYtForPt
+            res[3] = 0xfdd71f43; // swapExactSyForYt
+            res[4] = 0xc4a9c7de; // swapExactTokenForYt
+            res[5] = 0x357d6540; // swapExactYtForSy
+            res[6] = 0xd6308fa4; // swapExactYtForToken
+            res[7] = 0xbf1bd434; // swapSyForExactYt
+            res[8] = 0xe15cc098; // swapYtForExactSy
+            return res;
+        }
+        if (facet == ACTION_MISC) {
+            res = new bytes4[](2);
+            res[0] = 0xacdb32df; // approveInf
+            res[1] = 0xd617b03b; // batchExec
+            return res;
+        }
+        if (facet == address(this)) {
+            res = new bytes4[](4);
+            res[0] = 0xcdffacc6; // facetAddress
+            res[1] = 0x52ef6b2c; // facetAddresses
+            res[2] = 0xadfca15e; // facetFunctionSelectors
+            res[3] = 0x7a0ed627; // facets
+            return res;
+        }
+        revert Errors.RouterInvalidFacet(facet);
+    }
+
+    function facetAddress(bytes4 sig) public view returns (address) {
+        if (sig < 0x97ee279e) {
+            if (sig < 0x46eb2db6) {
+                if (sig < 0x357d6540) {
+                    if (sig < 0x1a8631b2) {
+                        if (sig == 0x015491d1) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleToken 5
+                        if (sig == 0x178d29d3) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySingleSy 6
+                    } else {
+                        if (sig == 0x1a8631b2) return ACTION_MINT_REDEEM; // mintPyFromSy 5
+                        if (sig == 0x2032aecd) return ACTION_SWAP_PT; // swapExactPtForSy 6
+                        if (sig == 0x339748cb) return ACTION_MINT_REDEEM; // redeemPyToSy 7
+                    }
+                } else {
+                    if (sig < 0x409c7a89) {
+                        if (sig == 0x357d6540) return ACTION_SWAP_YT; // swapExactYtForSy 5
+                        if (sig == 0x3af1f329) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySinglePt 6
+                    } else {
+                        if (sig == 0x409c7a89) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleSy 5
+                        if (sig == 0x443e6512) return ACTION_MINT_REDEEM; // mintSyFromToken 6
+                        if (sig == 0x448b9b95) return ACTION_SWAP_YT; // swapExactYtForPt 7
+                    }
+                }
+            } else {
+                if (sig < 0x6b8bdf32) {
+                    if (sig < 0x52ef6b2c) {
+                        if (sig == 0x46eb2db6) return ACTION_MINT_REDEEM; // mintPyFromToken 5
+                        if (sig == 0x527df199) return ACTION_MINT_REDEEM; // redeemPyToToken 6
+                    } else {
+                        if (sig == 0x690807ad) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySingleToken 5
+                        if (sig == 0x694ab559) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySinglePt 6
+                        if (sig == 0x52ef6b2c) return address(this); // facetAddresses 7
+                    }
+                } else {
+                    if (sig < 0x83c71b69) {
+                        if (sig == 0x6b8bdf32) return ACTION_SWAP_PT; // swapSyForExactPt 5
+                        if (sig == 0x7a0ed627) return address(this); // facets 6
+                    } else {
+                        if (sig == 0x85b29936) return ACTION_MINT_REDEEM; // redeemSyToToken 5
+                        if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleSyKeepYt 6
+                        if (sig == 0x83c71b69) return ACTION_SWAP_PT; // swapExactSyForPt 7
+                    }
+                }
+            }
+        } else {
+            if (sig < 0xcdffacc6) {
+                if (sig < 0xb85f50ba) {
+                    if (sig < 0xacdb32df) {
+                        if (sig == 0xa5f9931b) return ACTION_SWAP_PT; // swapExactTokenForPt 5
+                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; // addLiquidityDualSyAndPt 6
+                    } else {
+                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; // removeLiquidityDualSyAndPt 5
+                        if (sig == 0xacdb32df) return ACTION_MISC; // approveInf 6
+                        if (sig == 0xadfca15e) return address(this); // facetFunctionSelectors 7
+                    }
+                } else {
+                    if (sig < 0xc4a9c7de) {
+                        if (sig == 0xb85f50ba) return ACTION_SWAP_PT; // swapExactPtForToken 5
+                        if (sig == 0xbf1bd434) return ACTION_SWAP_YT; // swapSyForExactYt 6
+                    } else {
+                        if (sig == 0xc4a9c7de) return ACTION_SWAP_YT; // swapExactTokenForYt 5
+                        if (sig == 0xcb591eb2) return ACTION_ADD_REMOVE_LIQ; // addLiquidityDualTokenAndPt 6
+                        if (sig == 0xc861a898) return ACTION_SWAP_YT; // swapExactPtForYt 7
+                    }
+                }
+            } else {
+                if (sig < 0xe15cc098) {
+                    if (sig < 0xd6308fa4) {
+                        if (sig == 0xd617b03b) return ACTION_MISC; // batchExec 5
+                        if (sig == 0xcdffacc6) return address(this); // facetAddress 6
+                    } else {
+                        if (sig == 0xd6308fa4) return ACTION_SWAP_YT; // swapExactYtForToken 5
+                        if (sig == 0xdfbc814e) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleTokenKeepYt 6
+                        if (sig == 0xdd371acd) return ACTION_SWAP_PT; // swapPtForExactSy 7
+                    }
+                } else {
+                    if (sig < 0xf7e375e8) {
+                        if (sig == 0xe6eaba01) return ACTION_ADD_REMOVE_LIQ; // removeLiquidityDualTokenAndPt 5
+                        if (sig == 0xe15cc098) return ACTION_SWAP_YT; // swapYtForExactSy 6
+                    } else {
+                        if (sig == 0xfa483e72) return ACTION_SWAP_YT; // swapCallback 5
+                        if (sig == 0xf7e375e8) return ACTION_MINT_REDEEM; // redeemDueInterestAndRewards 6
+                        if (sig == 0xfdd71f43) return ACTION_SWAP_YT; // swapExactSyForYt 7
+                    }
+                }
+            }
         }
         revert Errors.RouterInvalidAction(sig);
+        // NUM_FUNC: 40 AVG:5.80 STD:0.75 WORST_CASE:7 STOP_BRANCH:3
+    }
+
+    function facetAddresses() public view returns (address[] memory) {
+        address[] memory res = new address[](6);
+        res[0] = ACTION_ADD_REMOVE_LIQ;
+        res[1] = ACTION_MINT_REDEEM;
+        res[2] = ACTION_SWAP_PT;
+        res[3] = ACTION_SWAP_YT;
+        res[4] = ACTION_MISC;
+        res[5] = address(this);
+        return res;
     }
 
     function _implementation() internal view override returns (address) {
-        return getRouterImplementation(msg.sig);
+        return facetAddress(msg.sig);
     }
 }