@pendle/core-v2 4.4.6 → 4.5.0-beta-2

package/contracts/core/StandardizedYield/implementations/PendleERC20WithSupplyCapSY.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleERC20SY.sol";
+
+contract PendleERC20WithSupplyCapSY is PendleERC20SY {
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(string memory _name, string memory _symbol, address _erc20, uint256 _initialSupplyCap) PendleERC20SY(_name, _symbol, _erc20) {
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        uint256 _newSupply = totalSupply() + amountTokenToDeposit;
+        uint256 _supplyCap = supplyCap;
+
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+
+        return amountTokenToDeposit;
+    }
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    // @dev: whenNotPaused not needed as it has already been added to beforeTransfer
+    function _afterTokenTransfer(address from, address, uint256) internal virtual override {
+        // only check for minting case
+        // saving gas on user->user transfers
+        // skip supply cap checking on burn to allow lowering supply cap
+        if (from != address(0)) {
+            return;
+        }
+
+        uint256 _supply = totalSupply();
+        uint256 _supplyCap = supplyCap;
+        if (_supply > _supplyCap) {
+            revert SupplyCapExceeded(_supply, _supplyCap);
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Tensorplex/PendleStTAOSY.sol

@@ -25,7 +25,7 @@ contract PendleStTAOSY is SYBaseUpg {
         wTAO = ITensorplexStTAO(stTAO).wrappedToken();
     }
 
-    function initialize() initializer external {
+    function initialize() external initializer {
         __SYBaseUpg_init("SY Tensorplex Staked TAO", "SY-stTAO");
         _safeApproveInf(wTAO, stTAO);
     }

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";

package/contracts/interfaces/IPActionStorageV4.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPActionStorageV4 {
+    struct SelectorsToFacet {
+        address facet;
+        bytes4[] selectors;
+    }
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    event SelectorToFacetSet(bytes4 indexed selector, address indexed facet);
+
+    function owner() external view returns (address);
+
+    function pendingOwner() external view returns (address);
+
+    function transferOwnership(address newOwner, bool direct, bool renounce) external;
+
+    function claimOwnership() external;
+
+    function setSelectorToFacets(SelectorsToFacet[] calldata arr) external;
+
+    function selectorToFacet(bytes4 selector) external view returns (address);
+}

package/contracts/interfaces/IPAllActionV3.sol

@@ -7,7 +7,7 @@ import "./IPActionSwapPTV3.sol";
 import "./IPActionSwapYTV3.sol";
 import "./IPActionMiscV3.sol";
 import "./IPActionCallbackV3.sol";
-import "./IDiamondLoupe.sol";
+import "./IPActionStorageV4.sol";
 
 interface IPAllActionV3 is
     IPActionAddRemoveLiqV3,
@@ -15,5 +15,5 @@ interface IPAllActionV3 is
     IPActionSwapYTV3,
     IPActionMiscV3,
     IPActionCallbackV3,
-    IDiamondLoupe
+    IPActionStorageV4
 {}

package/contracts/interfaces/IPMiniDiamond.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
 interface IPMiniDiamond {

package/contracts/limit/LimitRouterBase.sol

@@ -30,6 +30,7 @@ abstract contract LimitRouterBase is
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
     uint256 internal constant NEW_PRIME = 12421;
+    bytes private constant EMPTY_BYTES = abi.encode();
 
     address public feeRecipient;
 
@@ -62,7 +63,9 @@ abstract contract LimitRouterBase is
         bytes calldata /*optData*/,
         bytes memory callback
     ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
-        _validateOrdersSkipSig(params);
+        params = _validateSkipSigAndFilterOrders(params);
+        if (params.length == 0) return fillNoOrders(callback);
+
         OrderType orderType = params[0].order.orderType;
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
             return fillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
@@ -81,6 +84,13 @@ abstract contract LimitRouterBase is
         bytes callback;
     }
 
+    function fillNoOrders(
+        bytes memory callback
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
+        callbackReturn = callbackIfNeeded(0, 0, 0, callback);
+        return (0, 0, 0, callbackReturn);
+    }
+
     function fillTokenForPY(
         Args memory a
     ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
@@ -98,14 +108,7 @@ abstract contract LimitRouterBase is
         _transferOut(SY, a.receiver, actualMaking);
 
         // callback to Taker
-        if (a.callback.length > 0) {
-            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
-                actualMaking,
-                actualTaking,
-                totalFee,
-                a.callback
-            );
-        }
+        callbackReturn = callbackIfNeeded(actualMaking, actualTaking, totalFee, a.callback);
 
         // Taker => Makers
         address pyToMaker = (a.orderType == OrderType.SY_FOR_PT) ? PT : YT;
@@ -133,14 +136,7 @@ abstract contract LimitRouterBase is
         _transferFromMakers(IERC20(pyFromMaker), a.params, a.receiver, out.netMakings);
 
         // callback to Taker
-        if (a.callback.length > 0) {
-            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
-                actualMaking,
-                actualTaking,
-                totalFee,
-                a.callback
-            );
-        }
+        callbackReturn = callbackIfNeeded(actualMaking, actualTaking, totalFee, a.callback);
 
         // Taker => This
         _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
@@ -156,22 +152,33 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- verify & convert functions -----------------
-    function _validateOrdersSkipSig(FillOrderParams[] memory params) internal view {
+    function _validateSkipSigAndFilterOrders(
+        FillOrderParams[] memory params
+    ) internal view returns (FillOrderParams[] memory res) {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
         (address YT, OrderType orderType) = (params[0].order.YT, params[0].order.orderType);
+        require(block.timestamp < IPYieldToken(YT).expiry(), "LOP: PY expired");
 
-        uint256 expiry = IPYieldToken(YT).expiry();
-        require(block.timestamp < expiry, "LOP: PY expired");
-
+        uint256 skipped = 0;
         for (uint256 i = 0; i < len; i++) {
             Order memory order = params[i].order;
+            require(order.orderType == orderType && order.YT == YT, "LOP: mismatch types");
+
+            if (!(block.timestamp < order.expiry && order.nonce >= nonce[order.maker])) {
+                skipped++;
+                params[i].signature = EMPTY_BYTES;
+            }
+        }
 
-            require(order.orderType == orderType, "LOP: not same orderType");
-            require(order.YT == YT, "LOP: not same YT");
-            require(block.timestamp < order.expiry, "LOP: order expired");
-            require(order.nonce >= nonce[order.maker], "LOP: order invalidated");
+        res = new FillOrderParams[](len - skipped);
+        uint256 iter = 0;
+        for (uint256 i = 0; i < len; i++) {
+            if (params[i].signature.length != 0) {
+                res[iter] = params[i];
+                iter++;
+            }
         }
     }
 
@@ -235,6 +242,22 @@ abstract contract LimitRouterBase is
         }
     }
 
+    function callbackIfNeeded(
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        bytes memory callback
+    ) internal returns (bytes memory callbackReturn) {
+        if (callback.length > 0) {
+            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                totalFee,
+                callback
+            );
+        }
+    }
+
     function _checkSig(
         Order memory order,
         bytes memory signature

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -29,14 +29,14 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         (, , netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(netSyInterm, netPtDesired, block.timestamp);
 
         if (netSyInterm != netSyUsed) {
-            revert Errors.RouterNotAllSyUsed(netSyInterm, netSyUsed);
+            revert("Slippage: NOT_ALL_SY_USED");
         }
 
         // SY has been minted and transferred to the market
         _transferFrom(PT, msg.sender, market, netPtUsed);
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
 
         emit AddLiquidityDualTokenAndPt(
             msg.sender,
@@ -70,7 +70,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         _transferFrom(PT, msg.sender, market, netPtUsed);
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
 
         emit AddLiquidityDualSyAndPt(msg.sender, market, receiver, netSyUsed, netPtUsed, netLpOut);
     }
@@ -118,7 +118,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         // execute the addLiquidity
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyReceived, netPtLeft);
 
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
 
         emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
     }
@@ -231,7 +231,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyLeft, netPtReceived);
 
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
     }
 
     // ------------------ ADD LIQUIDITY SINGLE TOKEN KEEP YT ------------------
@@ -324,8 +324,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
 
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
     }
 
     // ------------------ REMOVE LIQUIDITY DUAL ------------------
@@ -343,7 +343,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
         (netSyInterm, netPtOut) = IPMarket(market).burn(address(SY), receiver, netLpToRemove);
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
 
         // redeem SY to token
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
@@ -370,8 +370,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
         (netSyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
 
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
 
         emit RemoveLiquidityDualSyAndPt(msg.sender, market, receiver, netLpToRemove, netPtOut, netSyOut);
     }
@@ -408,7 +408,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         netPtOut += netPtOutSwap;
         netSyFee += netSyFeeSwap;
 
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
 
         emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
     }
@@ -468,7 +468,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         } else {
             (netSyOut, netSyFee) = __removeLpToSyBeforeExpiry(receiver, market, netLpToRemove, limit);
         }
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
     function __removeLpToSyAfterExpiry(

package/contracts/router/ActionCallbackV3.sol

@@ -31,14 +31,19 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
     function limitRouterCallback(
         uint256 actualMaking,
         uint256 actualTaking,
-        uint256,
-        /*totalFee*/ bytes memory data
+        uint256 totalFee,
+        bytes memory data
     )
         external
         returns (
             bytes memory // encode as netTransferToLimit, netOutputFromLimit
         )
     {
+        bool isEmptyFill = (actualMaking == 0 && actualTaking == 0 && totalFee == 0);
+        if (isEmptyFill) {
+            return abi.encode(0, 0);
+        }
+
         (OrderType orderType, IPYieldToken YT, uint256 netRemaining, address receiver) = abi.decode(
             data,
             (OrderType, IPYieldToken, uint256, address)
@@ -49,7 +54,7 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
             uint256 totalSyToMintPy = index.assetToSyUp(actualTaking);
             uint256 additionalSyToMint = totalSyToMintPy - actualMaking;
 
-            require(additionalSyToMint <= netRemaining, "Router: Max SY to pull exceeded");
+            require(additionalSyToMint <= netRemaining, "Slippage: INSUFFICIENT_SY_LIMIT");
 
             _transferOut(YT.SY(), address(YT), additionalSyToMint);
 
@@ -64,7 +69,7 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
 
             return abi.encode(additionalSyToMint, netPyToReceiver);
         } else {
-            require(actualMaking <= netRemaining, "Router: Max PY to pull exceeded");
+            require(actualMaking <= netRemaining, "Slippage: INSUFFICIENT_PY_LIMIT");
 
             if (orderType == OrderType.PT_FOR_SY) {
                 _transferOut(address(YT), address(YT), actualMaking);
@@ -74,7 +79,7 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
 
             uint256 netSyRedeemed = IPYieldToken(YT).redeemPY(address(this));
 
-            require(actualTaking <= netSyRedeemed, "Router: Insufficient SY redeemed");
+            require(actualTaking <= netSyRedeemed, "Slippage: INSUFFICIENT_PY_REDEEM");
 
             uint256 netSyToReceiver = netSyRedeemed - actualTaking;
 
@@ -93,7 +98,7 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
         uint256 ptOwed = ptToAccount.abs();
         uint256 netPyOut = YT.mintPY(msg.sender, receiver);
 
-        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
+        if (netPyOut < ptOwed) revert("Slippage: INSUFFICIENT_PT_REPAY");
     }
 
     function _callbackSwapYtForSy(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
@@ -116,10 +121,8 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
         uint256 netPtOwed = ptToAccount.abs();
 
         uint256 netPyOut = YT.mintPY(msg.sender, receiver);
-        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
-        if (exactPtIn + netPyOut < netPtOwed) {
-            revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
-        }
+        if (netPyOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+        if (exactPtIn + netPyOut < netPtOwed) revert("Slippage: INSUFFICIENT_PT_REPAY");
     }
 
     function _callbackSwapExactYtForPt(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
@@ -132,9 +135,7 @@ contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelpe
 
         uint256 netSyToMarket = YT.redeemPY(msg.sender);
 
-        if (netSyToMarket < netSyOwed) {
-            revert Errors.RouterInsufficientSyRepay(netSyToMarket, netSyOwed);
-        }
+        if (netSyToMarket < netSyOwed) revert("Slippage: INSUFFICIENT_SY_REPAY");
 
         _transferOut(address(PT), receiver, netPtOut);
     }

package/contracts/router/ActionMiscV3.sol

@@ -102,9 +102,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         _swapTokenInput(inp);
 
         netTokenOut = _selfBalance(inp.tokenMintSy);
-        if (netTokenOut < minTokenOut) {
-            revert Errors.RouterInsufficientTokenOut(netTokenOut, minTokenOut);
-        }
+        if (netTokenOut < minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
 
         _transferOut(inp.tokenMintSy, receiver, netTokenOut);
     }

package/contracts/router/ActionStorageV4.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPActionStorageV4.sol";
+import "./RouterStorage.sol";
+
+contract ActionStorageV4 is RouterStorage, IPActionStorageV4 {
+    modifier onlyOwner() {
+        require(msg.sender == owner(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function owner() public view returns (address) {
+        return _getCoreStorage().owner;
+    }
+
+    function pendingOwner() public view returns (address) {
+        return _getCoreStorage().pendingOwner;
+    }
+
+    function setSelectorToFacets(SelectorsToFacet[] calldata arr) external onlyOwner {
+        CoreStorage storage $ = _getCoreStorage();
+
+        for (uint256 i = 0; i < arr.length; i++) {
+            SelectorsToFacet memory s = arr[i];
+            for (uint256 j = 0; j < s.selectors.length; j++) {
+                $.selectorToFacet[s.selectors[j]] = s.facet;
+                emit SelectorToFacetSet(s.selectors[j], s.facet);
+            }
+        }
+    }
+
+    function selectorToFacet(bytes4 selector) external view returns (address) {
+        CoreStorage storage $ = _getCoreStorage();
+        return $.selectorToFacet[selector];
+    }
+
+    // Ownable
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
+        CoreStorage storage $ = _getCoreStorage();
+
+        if (direct) {
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            emit OwnershipTransferred($.owner, newOwner);
+            $.owner = newOwner;
+            $.pendingOwner = address(0);
+        } else {
+            $.pendingOwner = newOwner;
+        }
+    }
+
+    function claimOwnership() external {
+        CoreStorage storage $ = _getCoreStorage();
+
+        address _pendingOwner = $.pendingOwner;
+
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        emit OwnershipTransferred($.owner, _pendingOwner);
+        $.owner = _pendingOwner;
+        $.pendingOwner = address(0);
+    }
+}

package/contracts/router/ActionSwapYTV3.sol

@@ -94,7 +94,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
             netSyFee += netSyFeeMarket;
         }
 
-        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
     }
 
     // ------------------ SWAP TOKEN FOR TOKEN ------------------
@@ -175,7 +175,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
             netSyOut += SY.balanceOf(receiver) - preSyBalance;
         }
 
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
     // ------------------ SWAP PT FOR YT ------------------
@@ -226,7 +226,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
             guessTotalPtFromSwap
         );
 
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
 
         _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
         IPMarket(market).swapSyForExactPt(

package/contracts/router/PendleRouterV4.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../interfaces/IPActionStorageV4.sol";
+import "./RouterStorage.sol";
+
+contract PendleRouterV4 is Proxy, RouterStorage {
+    constructor(address _owner, address actionStorage) {
+        RouterStorage.CoreStorage storage $ = _getCoreStorage();
+        $.owner = _owner;
+        $.selectorToFacet[IPActionStorageV4.setSelectorToFacets.selector] = actionStorage;
+    }
+
+    function _implementation() internal view override returns (address) {
+        RouterStorage.CoreStorage storage $ = _getCoreStorage();
+        address facet = $.selectorToFacet[msg.sig];
+        require(facet != address(0), "INVALID_SELECTOR");
+        return facet;
+    }
+
+    receive() external payable override {}
+}

package/contracts/router/RouterStorage.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+abstract contract RouterStorage {
+    struct CoreStorage {
+        address owner;
+        address pendingOwner;
+        mapping(bytes4 => address) selectorToFacet;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("pendle.routerv4.Core")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant CORE_STORAGE_LOCATION = 0xf168c5b0cb4aca9a68f931815c18a144c61ad01d6dd7ca15bd6741672a0ab800;
+
+    function _getCoreStorage() internal pure returns (CoreStorage storage $) {
+        assembly {
+            $.slot := CORE_STORAGE_LOCATION
+        }
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -101,9 +101,7 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
             _transferOut(out.tokenOut, receiver, netTokenOut);
         }
 
-        if (netTokenOut < out.minTokenOut) {
-            revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
-        }
+        if (netTokenOut < out.minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
     }
 
     function __redeemSy(
@@ -133,7 +131,7 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
         }
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
-        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
+        if (netPyOut < minPyOut) revert("Slippage: INSUFFICIENT_PT_YT_OUT");
     }
 
     function _redeemPyToSy(
@@ -150,7 +148,7 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
         if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
 
         netSyOut = IPYieldToken(YT).redeemPY(receiver);
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
     // ----------------- HELPER -----------------
@@ -195,7 +193,7 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
     function _entry_swapExactSyForPt(address market, LimitOrderData calldata limit) internal view returns (address) {
@@ -235,7 +233,7 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
     }
 
     // ----------------- LIMIT ORDERS -----------------