@pendle/core-v2 5.1.1 → 5.1.2-beta-2

package/contracts/interfaces/IPAllActionV3.sol

@@ -9,6 +9,7 @@ import "./IPActionMiscV3.sol";
 import "./IPActionCallbackV3.sol";
 import "./IPActionStorageV4.sol";
 import "./IPActionSimple.sol";
+import "./IPActionSwapLimitV3.sol";
 
 interface IPAllActionV3 is
     IPActionAddRemoveLiqV3,
@@ -17,5 +18,6 @@ interface IPAllActionV3 is
     IPActionMiscV3,
     IPActionCallbackV3,
     IPActionStorageV4,
-    IPActionSimple
+    IPActionSimple,
+    IPActionSwapLimitV3
 {}

package/contracts/interfaces/IPAllEventsV3.sol

@@ -265,10 +265,53 @@ interface IPActionStorageEvents {
     event SelectorToFacetSet(bytes4 indexed selector, address indexed facet);
 }
 
+interface IPActionSwapLimitV3Events {
+    event SwapMaxPtForTokenLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 maxPtIn,
+        uint256 netTokenOut,
+        uint256 netSyInterm,
+        uint256 netPtReturned
+    );
+
+    event SwapMaxPtForSyLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 maxPtIn,
+        uint256 netSyOut,
+        uint256 netPtReturned
+    );
+
+    event SwapMaxTokenForYtLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 maxTokenIn,
+        uint256 netYtOut,
+        uint256 netSyInterm,
+        uint256 netSyReturned
+    );
+
+    event SwapMaxSyForYtLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 maxSyIn,
+        uint256 netYtOut,
+        uint256 netSyReturned
+    );
+}
+
 interface IPAllEventsV3 is
     IPActionAddRemoveLiqV3Events,
     IPActionSwapPTV3Events,
     IPActionSwapYTV3Events,
     IPActionMiscV3Events,
-    IPActionStorageEvents
+    IPActionStorageEvents,
+    IPActionSwapLimitV3Events
 {}

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -70,7 +70,7 @@ contract ActionInfoStatic is IPActionInfoStatic {
 
     function getUserMarketInfo(address market, address user) external returns (UserMarketInfo memory res) {
         IPMarket _market = IPMarket(market);
-        MarketState memory state = _market.readState(address(this));
+        MarketState memory state = IPRouterStatic(address(this)).readMarketState(market);
 
         if (uint256(state.totalLp) == 0) return res; // market not initialized
 

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -342,7 +342,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     }
 
     function _readState(address market) internal view returns (MarketState memory) {
-        return IPMarket(market).readState(address(this));
+        return IPRouterStatic(address(this)).readMarketState(market);
     }
 
     function _readTokens(

package/contracts/offchain-helpers/router-static/base/ActionMarketCoreStatic.sol

@@ -18,6 +18,8 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
 
     // ============ ADD REMOVE LIQUIDITY ============
 
+    address internal constant ROUTER_V4 = 0x888888888889758F76e7103c6CbF23ABbF58F946;
+
     function addLiquidityDualSyAndPtStatic(
         address market,
         uint256 netSyDesired,
@@ -625,6 +627,14 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
         exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
     }
 
+    function readMarketState(address market) public view returns (MarketState memory) {
+        return _readState(market);
+    }
+
+    function _readState(address market) internal view returns (MarketState memory) {
+        return IPMarket(market).readState(ROUTER_V4);
+    }
+
     function _calcPriceImpactPY(address market, int256 netPtOut) internal view returns (uint256) {
         return IPRouterStatic(address(this)).calcPriceImpactPY(market, netPtOut);
     }
@@ -657,10 +667,6 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
         return IPRouterStatic(address(this)).getTradeExchangeRateExcludeFee(market, state);
     }
 
-    function _readState(address market) internal view returns (MarketState memory) {
-        return IPMarket(market).readState(address(this));
-    }
-
     function _pyIndex(address market) private view returns (PYIndex) {
         return PYIndex.wrap(IPRouterStatic(address(this)).pyIndexCurrentViewMarket(market));
     }

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -88,7 +88,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netPtIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtSwapToSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtSwapToSy, limit)) {
             return delegateToAddLiquiditySinglePtSimple(receiver, market, netPtIn, minLpOut);
@@ -140,7 +140,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToAddLiquiditySingleTokenSimple(receiver, market, minLpOut, input);
@@ -179,7 +179,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netSyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToAddLiquiditySingleSySimple(receiver, market, netSyIn, minLpOut);
@@ -211,7 +211,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netSyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netLpOut, uint256 netSyFee) {
         uint256 netSyLeft = netSyIn;
         uint256 netPtReceived;
@@ -397,7 +397,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netLpToRemove,
         uint256 minPtOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToRemoveLiquiditySinglePtSimple(receiver, market, netLpToRemove, minPtOut);
@@ -439,7 +439,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
@@ -466,7 +466,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
@@ -481,7 +481,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         if (IPMarket(market).isExpired()) {
             netSyOut = __removeLpToSyAfterExpiry(receiver, market, netLpToRemove);
@@ -505,7 +505,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address receiver,
         address market,
         uint256 netLpToRemove,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         uint256 netPtLeft;
 

package/contracts/router/ActionMiscV3.sol

@@ -205,20 +205,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
     }
 
-    /// @dev Deprecated, please use swapTokensToTokens which support unwrapping ETH too
-    function swapTokenToToken(
-        address receiver,
-        uint256 minTokenOut,
-        TokenInput calldata inp
-    ) external payable returns (uint256 netTokenOut) {
-        _swapTokenInput(inp);
-
-        netTokenOut = _selfBalance(inp.tokenMintSy);
-        if (netTokenOut < minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
-
-        _transferOut(inp.tokenMintSy, receiver, netTokenOut);
-    }
-
     /// @dev The interface might change in the future, check with Pendle team before use
     function swapTokenToTokenViaSy(
         address receiver,
@@ -239,7 +225,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netYtIn,
         uint256 netLpIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
         IStandardizedYield SY;
 
@@ -257,7 +243,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netYtIn,
         uint256 netLpIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (ExitPreExpReturnParams memory params) {
         (, params) = _exitPreExpToSy(false, receiver, market, netPtIn, netYtIn, netLpIn, limit);
         require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
@@ -272,7 +258,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (IStandardizedYield SY, ExitPreExpReturnParams memory p) {
         IPPrincipalToken PT;
         IPYieldToken YT;

package/contracts/router/ActionSwapLimitV3.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./base/ActionBase.sol";
+import "../interfaces/IPActionSwapLimitV3.sol";
+
+contract ActionSwapLimitV3 is IPActionSwapLimitV3, ActionBase {
+    using PMath for uint256;
+
+    function swapMaxPtForTokenLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxPtIn,
+        uint256 minTokenPtRate,
+        TokenOutput calldata output,
+        LimitOrderData memory limit
+    ) external returns (uint256 netTokenOut, uint256 netPtReturned, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, address(this), maxPtIn);
+
+        (netSyInterm, netPtReturned, netSyFee) = _swapMaxPtForSyLimitOnly(address(SY), PT, maxPtIn, 0, limit);
+
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
+
+        uint256 netPtUsed = maxPtIn - netPtReturned;
+        if (netTokenOut.divDown(netPtUsed) < minTokenPtRate) revert("Slippage LO: INSUFFICIENT_TOKEN_OUT");
+
+        emit SwapMaxPtForTokenLimitOnly(
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            maxPtIn,
+            netTokenOut,
+            netSyInterm,
+            netPtReturned
+        );
+    }
+
+    function swapMaxPtForSyLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxPtIn,
+        uint256 minSyPtRate,
+        LimitOrderData memory limit
+    ) external returns (uint256 netSyOut, uint256 netPtReturned, uint256 netSyFee) {
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, address(this), maxPtIn);
+
+        (netSyOut, netPtReturned, netSyFee) = _swapMaxPtForSyLimitOnly(receiver, PT, maxPtIn, minSyPtRate, limit);
+
+        emit SwapMaxPtForSyLimitOnly(msg.sender, market, receiver, maxPtIn, netSyOut, netPtReturned);
+    }
+
+    function swapMaxTokenForYtLimitOnly(
+        address receiver,
+        address market,
+        uint256 minSyInterm,
+        uint256 minYtSyRate,
+        TokenInput calldata input,
+        LimitOrderData memory limit
+    ) external payable returns (uint256 netYtOut, uint256 netSyReturned, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        netSyInterm = _mintSyFromToken(address(this), address(SY), minSyInterm, input);
+        (netYtOut, netSyReturned, netSyFee) = _swapMaxSyForYtLimitOnly(receiver, SY, netSyInterm, minYtSyRate, limit);
+
+        emit SwapMaxTokenForYtLimitOnly(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netYtOut,
+            netSyInterm,
+            netSyReturned
+        );
+    }
+
+    function swapMaxSyForYtLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxSyIn,
+        uint256 minYtSyRate,
+        LimitOrderData memory limit
+    ) external returns (uint256 netYtOut, uint256 netSyReturned, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        _transferFrom(SY, msg.sender, address(this), maxSyIn);
+        (netYtOut, netSyReturned, netSyFee) = _swapMaxSyForYtLimitOnly(receiver, SY, maxSyIn, minYtSyRate, limit);
+
+        emit SwapMaxSyForYtLimitOnly(msg.sender, market, receiver, maxSyIn, netYtOut, netSyReturned);
+    }
+
+    function _swapMaxPtForSyLimitOnly(
+        address receiver,
+        IPPrincipalToken PT,
+        uint256 maxPtIn,
+        uint256 minSyPtRate,
+        LimitOrderData memory limit
+    ) internal returns (uint256 netSyOut, uint256 netPtReturned, uint256 netSyFee) {
+        (netPtReturned, netSyOut, netSyFee, ) = _fillLimit(receiver, PT, maxPtIn, limit);
+        if (netSyOut == 0) revert("Slippage LO: NO_ORDER_FILLED");
+
+        uint256 netPtUsed = maxPtIn - netPtReturned;
+        if (netSyOut.divDown(netPtUsed) < minSyPtRate) revert("Slippage LO: INSUFFICIENT_SY_OUT");
+
+        _transferOut(address(PT), msg.sender, netPtReturned);
+    }
+
+    function _swapMaxSyForYtLimitOnly(
+        address receiver,
+        IStandardizedYield SY,
+        uint256 maxSyIn,
+        uint256 minYtSyRate,
+        LimitOrderData memory limit
+    ) internal returns (uint256 netYtOut, uint256 netSyReturned, uint256 netSyFee) {
+        (netSyReturned, netYtOut, netSyFee, ) = _fillLimit(receiver, SY, maxSyIn, limit);
+        if (netYtOut == 0) revert("Slippage LO: NO_ORDER_FILLED");
+
+        uint256 netSyUsed = maxSyIn - netSyReturned;
+        if (netYtOut.divDown(netSyUsed) < minYtSyRate) revert("Slippage LO: INSUFFICIENT_YT_OUT");
+
+        _transferOut(address(SY), msg.sender, netSyReturned);
+    }
+}

package/contracts/router/ActionSwapPTV3.sol

@@ -16,7 +16,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessPtOut, limit)) {
             return delegateToSwapExactTokenForPtSimple(receiver, market, minPtOut, input);
@@ -44,7 +44,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtOut, limit)) {
             return delegateToSwapExactSyForPtSimple(receiver, market, exactSyIn, minPtOut);
@@ -63,7 +63,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
@@ -89,7 +89,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         address market,
         uint256 exactPtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);

package/contracts/router/ActionSwapYTV3.sol

@@ -21,7 +21,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessYtOut, limit)) {
             return delegateToSwapExactTokenForYtSimple(receiver, market, minYtOut, input);
@@ -50,7 +50,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessYtOut, limit)) {
             return delegateToSwapExactSyForYtSimple(receiver, market, exactSyIn, minYtOut);
@@ -71,7 +71,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         address market,
         uint256 exactYtIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
@@ -97,7 +97,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         address market,
         uint256 exactYtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);

package/contracts/router/base/ActionBase.sol

@@ -161,7 +161,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
 
     // ----------------- PT SWAP -----------------
 
-    function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
+    function _entry_swapExactPtForSy(address market, LimitOrderData memory limit) internal view returns (address) {
         return _entry_swapExactPtForSy(market, !_isEmptyLimit(limit));
     }
 
@@ -174,7 +174,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         address market,
         uint256 exactPtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
@@ -202,7 +202,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
-    function _entry_swapExactSyForPt(address market, LimitOrderData calldata limit) internal view returns (address) {
+    function _entry_swapExactSyForPt(address market, LimitOrderData memory limit) internal view returns (address) {
         return _entry_swapExactSyForPt(market, !_isEmptyLimit(limit));
     }
 
@@ -216,7 +216,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netPtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         uint256 netSyLeft = exactSyIn;
@@ -248,7 +248,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
 
     // ----------------- YT SWAP -----------------
 
-    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData memory limit) internal view returns (address) {
         return _entry_swapExactYtForSy(YT, !_isEmptyLimit(limit));
     }
 
@@ -263,7 +263,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         IPYieldToken YT,
         uint256 exactYtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         uint256 netYtLeft = exactYtIn;
         bool doMarketOrder = true;
@@ -292,7 +292,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
-    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData memory limit) internal view returns (address) {
         return _entry_swapExactSyForYt(YT, !_isEmptyLimit(limit));
     }
 
@@ -308,7 +308,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal returns (uint256 netYtOut, uint256 netSyFee) {
         uint256 netSyLeft = exactSyIn;
         bool doMarketOrder = true;
@@ -346,8 +346,15 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         address receiver,
         IERC20 tokenIn,
         uint256 netInput,
-        LimitOrderData calldata lim
+        LimitOrderData memory lim
     ) internal returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder) {
+        {
+            if (lim.optData.length != 0) {
+                LimitOrder_OptData_V1 memory optData = abi.decode(lim.optData, (LimitOrder_OptData_V1));
+                _scaleLimitOrderData(lim, netInput, optData.netOffchain);
+            }
+        }
+
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
@@ -386,13 +393,13 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);
     }
 
-    function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
+    function _isEmptyLimit(LimitOrderData memory a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }
 
     // ----------------- ADD & REMOVE LIQUIDITY -----------------
 
-    function _entry_addLiquiditySinglePt(address market, LimitOrderData calldata lim) internal view returns (address) {
+    function _entry_addLiquiditySinglePt(address market, LimitOrderData memory lim) internal view returns (address) {
         return _entry_addLiquiditySinglePt(market, !_isEmptyLimit(lim));
     }
 
@@ -400,7 +407,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         return hasLimitOrder ? address(this) : market;
     }
 
-    function _entry_addLiquiditySingleSy(address market, LimitOrderData calldata lim) internal view returns (address) {
+    function _entry_addLiquiditySingleSy(address market, LimitOrderData memory lim) internal view returns (address) {
         return _entry_addLiquiditySingleSy(market, !_isEmptyLimit(lim));
     }
 
@@ -423,4 +430,20 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             }
         }
     }
+
+    function _scaleLimitOrderData(
+        LimitOrderData memory limit,
+        uint256 onchainAmount,
+        uint256 offchainAmount
+    ) private pure {
+        // we can't scale up. If it's equal, skip
+        if (onchainAmount >= offchainAmount) return;
+
+        for (uint256 i = 0; i < limit.normalFills.length; i++) {
+            limit.normalFills[i].makingAmount = (limit.normalFills[i].makingAmount * onchainAmount) / offchainAmount;
+        }
+        for (uint256 i = 0; i < limit.flashFills.length; i++) {
+            limit.flashFills[i].makingAmount = (limit.flashFills[i].makingAmount * onchainAmount) / offchainAmount;
+        }
+    }
 }

package/contracts/router/base/ActionDelegateBase.sol

@@ -120,7 +120,7 @@ contract ActionDelegateBase is ActionBase {
 
     function canUseOnchainApproximation(
         ApproxParams calldata approx,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) internal pure returns (bool) {
         return approx.guessOffchain == 0 && _isEmptyLimit(limit);
     }

package/deployments/1-markets/RSETH-MAINNET-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY ETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0x9335A7A9208cdA49f287Ea9af7B3D1faAdfcfe80",
+    "PT": "0xE08C45F3cfE70f4e03668Dc6E84Af842bEE95A68",
+    "market": "0xfD482179DdEe989C45eaB19991852F80fF31457a",
+    "expiry": 1750896000,
+    "scalarRoot": "89241410861000000000",
+    "initAnchor": "1029050450000000000",
+    "lnFeeRateRoot": "499875041000000",
+    "deployTxHash": "0x95046b375a4f59baa5e3edabc749a43c02091e94ed7c8b2cc2b3f26289c273fd",
+    "deployBlockNumber": 21126538,
+    "reversedFee": 0.04999999993486881
+}

package/deployments/1-markets/WEETH-MAINNET-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY ETH",
+    "SY": "0xac0047886a985071476a1186be89222659970d65",
+    "YT": "0x08AEfe9dFe7818CaaedD94E38e910d2155b7d2b0",
+    "PT": "0xEF6122835a2Bbf575D0117D394fDa24aB7d09d4E",
+    "market": "0xF4Cf59259D007a96C641B41621aB52C93b9691B1",
+    "expiry": 1750896000,
+    "scalarRoot": "89316496353000000000",
+    "initAnchor": "1028180525000000000",
+    "lnFeeRateRoot": "499875041000000",
+    "deployTxHash": "0x07a9014ad4f589dbe9b9a965fd8a23a05aff6e8776212a9112ebd5b3f8ea5593",
+    "deployBlockNumber": 21132911,
+    "reversedFee": 0.04999999993486881
+}

package/deployments/42161-markets/RSETH-ARBITRUM-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY ETH",
+    "SY": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "YT": "0x8fEDCa9DE6c792275335B41D0ef74D3A03361733",
+    "PT": "0x8Db96f2FcCf7Cdd74a60e8eFf5801df043cd11dE",
+    "market": "0x816F59FfA2239Fd7106F94eAbdC0a9547a892F2f",
+    "expiry": 1750896000,
+    "scalarRoot": "89241410861000000000",
+    "initAnchor": "1029050450000000000",
+    "lnFeeRateRoot": "499875041000000",
+    "deployTxHash": "0x649b34fdb1b9340268445324873c2b8cf65101dd53fb709b6ba503931f59e88b",
+    "deployBlockNumber": 271511094,
+    "reversedFee": 0.04999999993486881
+}

package/deployments/42161-markets/SPSILO-ARBITRUM-MAR2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY spSILO",
+    "SY": "0x374C07997B3C0Df6DB0f370Ed8561404b729A43A",
+    "YT": "0xD29151dE7fBf87c068E715FAd113Bdd5EE556318",
+    "PT": "0x0AB24eCB207602983A20cfCF0E3045c08C651778",
+    "market": "0x3be83Cc235455Ae1B624Cf6e326505769AD8f9eA",
+    "expiry": 1743033600,
+    "scalarRoot": "12129893540000000000",
+    "initAnchor": "1104433417000000000",
+    "lnFeeRateRoot": "4987541511000000",
+    "deployTxHash": "0x28b7e4f3f49b27f81b49e406662f23948e7935f15e4011eadeb3edb90d87ae15",
+    "deployBlockNumber": 271599840,
+    "reversedFee": 0.49999999999608136
+}