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

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -21,12 +21,12 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 netPtDesired,
         uint256 minLpOut
     ) external payable returns (uint256 netLpOut, uint256 netPtUsed, uint256 netSyInterm) {
-        (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(market, address(SY), 1, input);
         uint256 netSyUsed;
 
-        (,, netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(netSyInterm, netPtDesired, block.timestamp);
+        (, , netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(netSyInterm, netPtDesired, block.timestamp);
 
         if (netSyInterm != netSyUsed) {
             revert Errors.RouterNotAllSyUsed(netSyInterm, netSyUsed);
@@ -34,12 +34,19 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
         // SY has been minted and transferred to the market
         _transferFrom(PT, msg.sender, market, netPtUsed);
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
         emit AddLiquidityDualTokenAndPt(
-            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netPtUsed, netLpOut, netSyInterm
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netPtUsed,
+            netLpOut,
+            netSyInterm
         );
     }
 
@@ -50,15 +57,18 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 netPtDesired,
         uint256 minLpOut
     ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
-        (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         // calculate the amount of SY and PT to be used
-        (, netLpOut, netSyUsed, netPtUsed) =
-            _readMarket(market).addLiquidity(netSyDesired, netPtDesired, block.timestamp);
+        (, netLpOut, netSyUsed, netPtUsed) = _readMarket(market).addLiquidity(
+            netSyDesired,
+            netPtDesired,
+            block.timestamp
+        );
 
         _transferFrom(SY, msg.sender, market, netSyUsed);
         _transferFrom(PT, msg.sender, market, netPtUsed);
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
@@ -82,24 +92,31 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 netSyReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netPtLeft, netSyReceived, netSyFee,) = _fillLimit(market, PT, netPtLeft, limit);
+            (netPtLeft, netSyReceived, netSyFee, ) = _fillLimit(market, PT, netPtLeft, limit);
             _transferOut(address(PT), market, netPtLeft);
         }
 
-        (uint256 netPtSwapMarket,,) = _readMarket(market).approxSwapPtToAddLiquidity(
-            YT.newIndex(), netPtLeft, netSyReceived, block.timestamp, guessPtSwapToSy
+        (uint256 netPtSwapMarket, , ) = _readMarket(market).approxSwapPtToAddLiquidity(
+            YT.newIndex(),
+            netPtLeft,
+            netSyReceived,
+            block.timestamp,
+            guessPtSwapToSy
         );
 
         // execute the swap
-        (uint256 netSyOutMarket, uint256 netSyFeeMarket) =
-            IPMarket(market).swapExactPtForSy(market, netPtSwapMarket, EMPTY_BYTES);
+        (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+            market,
+            netPtSwapMarket,
+            EMPTY_BYTES
+        );
 
         netPtLeft -= netPtSwapMarket;
         netSyReceived += netSyOutMarket;
         netSyFee += netSyFeeMarket;
 
         // execute the addLiquidity
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyReceived, netPtLeft);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyReceived, netPtLeft);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
@@ -120,15 +137,29 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(_entry_addLiquiditySingleSy(market, limit), address(SY), 1, input);
 
-        (netLpOut, netSyFee) =
-            _addLiquiditySingleSy(receiver, market, SY, YT, netSyInterm, minLpOut, guessPtReceivedFromSy, limit);
+        (netLpOut, netSyFee) = _addLiquiditySingleSy(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyInterm,
+            minLpOut,
+            guessPtReceivedFromSy,
+            limit
+        );
 
         emit AddLiquiditySingleToken(
-            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut, netSyInterm
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut,
+            netSyInterm
         );
     }
 
@@ -140,12 +171,20 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         ApproxParams calldata guessPtReceivedFromSy,
         LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         _transferFrom(SY, msg.sender, _entry_addLiquiditySingleSy(market, limit), netSyIn);
 
-        (netLpOut, netSyFee) =
-            _addLiquiditySingleSy(receiver, market, SY, YT, netSyIn, minLpOut, guessPtReceivedFromSy, limit);
+        (netLpOut, netSyFee) = _addLiquiditySingleSy(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyIn,
+            minLpOut,
+            guessPtReceivedFromSy,
+            limit
+        );
 
         emit AddLiquiditySingleSy(msg.sender, market, receiver, netSyIn, netLpOut);
     }
@@ -168,22 +207,29 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 netPtReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netPtReceived, netSyFee,) = _fillLimit(market, SY, netSyLeft, limit);
+            (netSyLeft, netPtReceived, netSyFee, ) = _fillLimit(market, SY, netSyLeft, limit);
             _transferOut(address(SY), market, netSyLeft);
         }
 
-        (uint256 netPtOutMarket,,) = _readMarket(market).approxSwapSyToAddLiquidity(
-            YT.newIndex(), netSyLeft, netPtReceived, block.timestamp, guessPtReceivedFromSy
+        (uint256 netPtOutMarket, , ) = _readMarket(market).approxSwapSyToAddLiquidity(
+            YT.newIndex(),
+            netSyLeft,
+            netPtReceived,
+            block.timestamp,
+            guessPtReceivedFromSy
         );
 
-        (uint256 netSySwapMarket, uint256 netSyFeeMarket) =
-            IPMarket(market).swapSyForExactPt(market, netPtOutMarket, EMPTY_BYTES);
+        (uint256 netSySwapMarket, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
+            market,
+            netPtOutMarket,
+            EMPTY_BYTES
+        );
 
         netSyLeft -= netSySwapMarket;
         netPtReceived += netPtOutMarket;
         netSyFee += netSyFeeMarket;
 
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyLeft, netPtReceived);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyLeft, netPtReceived);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
@@ -197,15 +243,30 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 minYtOut,
         TokenInput calldata input
     ) external payable returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy, uint256 netSyInterm) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         netSyInterm = _mintSyFromToken(address(this), address(SY), 1, input);
 
-        (netLpOut, netYtOut, netSyMintPy) =
-            _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyInterm, minLpOut, minYtOut);
+        (netLpOut, netYtOut, netSyMintPy) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyInterm,
+            minLpOut,
+            minYtOut
+        );
 
         emit AddLiquiditySingleTokenKeepYt(
-            msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut, netYtOut, netSyMintPy, netSyInterm
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut,
+            netYtOut,
+            netSyMintPy,
+            netSyInterm
         );
     }
 
@@ -216,12 +277,19 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         uint256 minLpOut,
         uint256 minYtOut
     ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         _transferIn(address(SY), msg.sender, netSyIn);
 
-        (netLpOut, netYtOut, netSyMintPy) =
-            _addLiquiditySingleSyKeepYt(receiver, market, SY, YT, netSyIn, minLpOut, minYtOut);
+        (netLpOut, netYtOut, netSyMintPy) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyIn,
+            minLpOut,
+            minYtOut
+        );
 
         emit AddLiquiditySingleSyKeepYt(msg.sender, market, receiver, netSyIn, netSyMintPy, netLpOut, netYtOut);
     }
@@ -240,7 +308,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         PYIndex pyIndex = YT.newIndex();
 
         netSyMintPy =
-            (netSyIn * state.totalPt.Uint()) / (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+            (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
 
         uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
 
@@ -253,7 +322,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         // PT goes to market, YT goes to receiver
         netYtOut = YT.mintPY(market, receiver);
 
-        (netLpOut,,) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
         if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
@@ -268,7 +337,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         TokenOutput calldata output,
         uint256 minPtOut
     ) external returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyInterm) {
-        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
         // burn LP, SY sent to SY, PT sent to receiver
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
@@ -279,7 +348,14 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         // redeem SY to token
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
         emit RemoveLiquidityDualTokenAndPt(
-            msg.sender, market, output.tokenOut, receiver, netLpToRemove, netPtOut, netTokenOut, netSyInterm
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            netLpToRemove,
+            netPtOut,
+            netTokenOut,
+            netSyInterm
         );
     }
 
@@ -313,13 +389,22 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
 
         // execute the burn
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-        (uint256 netSyOutBurn, uint256 netPtOutBurn) =
-            IPMarket(market).burn(_entry_swapExactSyForPt(market, limit), receiver, netLpToRemove);
+        (uint256 netSyOutBurn, uint256 netPtOutBurn) = IPMarket(market).burn(
+            _entry_swapExactSyForPt(market, limit),
+            receiver,
+            netLpToRemove
+        );
         netSyLeft += netSyOutBurn;
         netPtOut += netPtOutBurn;
 
-        (uint256 netPtOutSwap, uint256 netSyFeeSwap) =
-            _swapExactSyForPt(receiver, market, netSyLeft, 0, guessPtReceivedFromSy, limit);
+        (uint256 netPtOutSwap, uint256 netSyFeeSwap) = _swapExactSyForPt(
+            receiver,
+            market,
+            netSyLeft,
+            0,
+            guessPtReceivedFromSy,
+            limit
+        );
         netPtOut += netPtOutSwap;
         netSyFee += netSyFeeSwap;
 
@@ -337,7 +422,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         TokenOutput calldata output,
         LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
@@ -346,7 +431,13 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
         emit RemoveLiquiditySingleToken(
-            msg.sender, market, output.tokenOut, receiver, netLpToRemove, netTokenOut, netSyInterm
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            netLpToRemove,
+            netTokenOut,
+            netSyInterm
         );
     }
 
@@ -380,12 +471,13 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 
-    function __removeLpToSyAfterExpiry(address receiver, address market, uint256 netLpToRemove)
-        internal
-        returns (uint256 netSyOut)
-    {
-        (,, IPYieldToken YT) = IPMarket(market).readTokens();
-        (uint256 syFromBurn,) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
+    function __removeLpToSyAfterExpiry(
+        address receiver,
+        address market,
+        uint256 netLpToRemove
+    ) internal returns (uint256 netSyOut) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (uint256 syFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
         netSyOut = syFromBurn + YT.redeemPY(receiver);
     }
 
@@ -397,8 +489,11 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase {
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         uint256 netPtLeft;
 
-        (uint256 netSyOutBurn, uint256 netPtOutBurn) =
-            IPMarket(market).burn(receiver, _entry_swapExactPtForSy(market, limit), netLpToRemove);
+        (uint256 netSyOutBurn, uint256 netPtOutBurn) = IPMarket(market).burn(
+            receiver,
+            _entry_swapExactPtForSy(market, limit),
+            netLpToRemove
+        );
         netSyOut += netSyOutBurn;
         netPtLeft += netPtOutBurn;
 

package/contracts/router/{base/ActionBaseCallback.sol → ActionCallbackV3.sol}

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IPMarketFactory.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../core/libraries/Errors.sol";
+import "../interfaces/IPActionCallbackV3.sol";
+import "../core/libraries/Errors.sol";
+import "./base/CallbackHelper.sol";
 
-import "./MarketApproxLib.sol";
-import "./CallbackHelper.sol";
-import "../../core/libraries/TokenHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../core/libraries/TokenHelper.sol";
 
-abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
+contract ActionCallbackV3 is IPLimitOrderType, IPActionCallbackV3, CallbackHelper, TokenHelper {
     using PMath for int256;
     using PMath for uint256;
     using PYIndexLib for PYIndex;
@@ -32,6 +28,65 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         }
     }
 
+    function limitRouterCallback(
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256,
+        /*totalFee*/ bytes memory data
+    )
+        external
+        returns (
+            bytes memory // encode as netTransferToLimit, netOutputFromLimit
+        )
+    {
+        (OrderType orderType, IPYieldToken YT, uint256 netRemaining, address receiver) = abi.decode(
+            data,
+            (OrderType, IPYieldToken, uint256, address)
+        );
+
+        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
+            PYIndex index = YT.newIndex();
+            uint256 totalSyToMintPy = index.assetToSyUp(actualTaking);
+            uint256 additionalSyToMint = totalSyToMintPy - actualMaking;
+
+            require(additionalSyToMint <= netRemaining, "Router: Max SY to pull exceeded");
+
+            _transferOut(YT.SY(), address(YT), additionalSyToMint);
+
+            uint256 netPyToReceiver;
+            if (orderType == OrderType.SY_FOR_PT) {
+                netPyToReceiver = YT.mintPY(address(this), receiver);
+                _safeApproveInf(YT.PT(), msg.sender);
+            } else {
+                netPyToReceiver = YT.mintPY(receiver, address(this));
+                _safeApproveInf(address(YT), msg.sender);
+            }
+
+            return abi.encode(additionalSyToMint, netPyToReceiver);
+        } else {
+            require(actualMaking <= netRemaining, "Router: Max PY to pull exceeded");
+
+            if (orderType == OrderType.PT_FOR_SY) {
+                _transferOut(address(YT), address(YT), actualMaking);
+            } else {
+                _transferOut(YT.PT(), address(YT), actualMaking);
+            }
+
+            uint256 netSyRedeemed = IPYieldToken(YT).redeemPY(address(this));
+
+            require(actualTaking <= netSyRedeemed, "Router: Insufficient SY redeemed");
+
+            uint256 netSyToReceiver = netSyRedeemed - actualTaking;
+
+            address SY = YT.SY();
+
+            _transferOut(SY, receiver, netSyToReceiver);
+            _safeApproveInf(SY, msg.sender);
+
+            return abi.encode(actualMaking, netSyToReceiver);
+        }
+    }
+
     function _callbackSwapExactSyForYt(int256 ptToAccount, int256, /*syToAccount*/ bytes calldata data) internal {
         (address receiver, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
 

package/contracts/router/ActionMiscV3.sol

@@ -2,32 +2,35 @@
 pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "./base/SimulateHelper.sol";
 import "../interfaces/IPActionMiscV3.sol";
 
-contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
-    function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
-        external
-        payable
-        returns (uint256 netSyOut)
-    {
+contract ActionMiscV3 is IPActionMiscV3, ActionBase {
+    function mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netSyOut) {
         netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
         emit MintSyFromToken(msg.sender, input.tokenIn, SY, receiver, input.netTokenIn, netSyOut);
     }
 
-    function redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata output)
-        external
-        returns (uint256 netTokenOut)
-    {
+    function redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
         netTokenOut = _redeemSyToToken(receiver, SY, netSyIn, output, true);
         emit RedeemSyToToken(msg.sender, output.tokenOut, SY, receiver, netSyIn, netTokenOut);
     }
 
-    function mintPyFromToken(address receiver, address YT, uint256 minPyOut, TokenInput calldata input)
-        external
-        payable
-        returns (uint256 netPyOut, uint256 netSyInterm)
-    {
+    function mintPyFromToken(
+        address receiver,
+        address YT,
+        uint256 minPyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPyOut, uint256 netSyInterm) {
         address SY = IPYieldToken(YT).SY();
 
         netSyInterm = _mintSyFromToken(YT, SY, 0, input);
@@ -36,10 +39,12 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut, netSyInterm);
     }
 
-    function redeemPyToToken(address receiver, address YT, uint256 netPyIn, TokenOutput calldata output)
-        external
-        returns (uint256 netTokenOut, uint256 netSyInterm)
-    {
+    function redeemPyToToken(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyInterm) {
         address SY = IPYieldToken(YT).SY();
 
         netSyInterm = _redeemPyToSy(SY, YT, netPyIn, 1);
@@ -48,18 +53,22 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut, netSyInterm);
     }
 
-    function mintPyFromSy(address receiver, address YT, uint256 netSyIn, uint256 minPyOut)
-        external
-        returns (uint256 netPyOut)
-    {
+    function mintPyFromSy(
+        address receiver,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut) {
         netPyOut = _mintPyFromSy(receiver, IPYieldToken(YT).SY(), YT, netSyIn, minPyOut, true);
         emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
     }
 
-    function redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
-        external
-        returns (uint256 netSyOut)
-    {
+    function redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut) {
         netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
         emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
     }
@@ -85,11 +94,11 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         }
     }
 
-    function swapTokenToToken(address receiver, uint256 minTokenOut, TokenInput calldata inp)
-        external
-        payable
-        returns (uint256 netTokenOut)
-    {
+    function swapTokenToToken(
+        address receiver,
+        uint256 minTokenOut,
+        TokenInput calldata inp
+    ) external payable returns (uint256 netTokenOut) {
         _swapTokenInput(inp);
 
         netTokenOut = _selfBalance(inp.tokenMintSy);
@@ -114,7 +123,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
     // ----------------- MISC FUNCTIONS -----------------
 
     function boostMarkets(address[] memory markets) external {
-        for (uint256 i = 0; i < markets.length;) {
+        for (uint256 i = 0; i < markets.length; ) {
             IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
             unchecked {
                 i++;
@@ -126,7 +135,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         uint256 length = calls.length;
         res = new Result[](length);
         Call3 calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             // delegatecall to itself, it turns allowing invoking functions from other actions
@@ -148,16 +157,8 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         }
     }
 
-    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
-        public
-        payable
-        override(IPActionMiscV3, SimulateHelper)
-        returns (bytes[] memory res, uint256[] memory gasUsed)
-    {
-        return super.multicallRevert(gasLimit, callDatas);
-    }
-
-    function callThenRevert(bytes memory callData) public payable override(IPActionMiscV3, SimulateHelper) {
-        return super.callThenRevert(callData);
+    function simulate(address target, bytes calldata data) external payable {
+        (bool success, bytes memory result) = target.delegatecall(data);
+        revert Errors.SimulationResults(success, result);
     }
 }

package/contracts/router/ActionSwapPTV3.sol

@@ -16,12 +16,18 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         TokenInput calldata input,
         LimitOrderData calldata limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
         netSyInterm = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
 
         (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, netSyInterm, minPtOut, guessPtOut, limit);
         emit SwapPtAndToken(
-            msg.sender, market, input.tokenIn, receiver, netPtOut.Int(), input.netTokenIn.neg(), netSyInterm
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netPtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
         );
     }
 
@@ -33,7 +39,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         ApproxParams calldata guessPtOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
         _transferFrom(SY, msg.sender, _entry_swapExactSyForPt(market, limit), exactSyIn);
 
         (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, exactSyIn, minPtOut, guessPtOut, limit);
@@ -47,7 +53,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         TokenOutput calldata output,
         LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
-        (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
 
         (netSyInterm, netSyFee) = _swapExactPtForSy(address(SY), market, exactPtIn, 0, limit);
@@ -55,7 +61,13 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
 
         emit SwapPtAndToken(
-            msg.sender, market, output.tokenOut, receiver, exactPtIn.neg(), netTokenOut.Int(), netSyInterm
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            exactPtIn.neg(),
+            netTokenOut.Int(),
+            netSyInterm
         );
     }
 
@@ -66,7 +78,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
         uint256 minSyOut,
         LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
 
         (netSyOut, netSyFee) = _swapExactPtForSy(receiver, market, exactPtIn, minSyOut, limit);