@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/router/PendleRouterV3.sol

@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../interfaces/IPAllActionV3.sol";
+import "../interfaces/IDiamondLoupe.sol";
+import "../interfaces/IDiamondCut.sol";
+
+// solhint-disable no-empty-blocks
+contract PendleRouterV3 is Proxy, IDiamondLoupe {
+    address internal immutable ACTION_ADD_REMOVE_LIQ;
+    address internal immutable ACTION_SWAP_PT;
+    address internal immutable ACTION_SWAP_YT;
+    address internal immutable ACTION_MISC;
+    address internal immutable ACTION_CALLBACK;
+
+    event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
+
+    constructor(
+        address _ACTION_ADD_REMOVE_LIQ,
+        address _ACTION_SWAP_PT,
+        address _ACTION_SWAP_YT,
+        address _ACTION_MISC,
+        address _ACTION_CALLBACK
+    ) {
+        ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
+        ACTION_SWAP_PT = _ACTION_SWAP_PT;
+        ACTION_SWAP_YT = _ACTION_SWAP_YT;
+        ACTION_MISC = _ACTION_MISC;
+        ACTION_CALLBACK = _ACTION_CALLBACK;
+        _emitEvents();
+    }
+
+    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 {}
+
+    /// @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 == address(this)) {
+            res = new bytes4[](4);
+            res[0] = 0x52ef6b2c; // facetAddresses
+            res[1] = 0x7a0ed627; // facets
+            res[2] = 0xadfca15e; // facetFunctionSelectors
+            res[3] = 0xcdffacc6; // facetAddress
+        }
+        if (facet == ACTION_ADD_REMOVE_LIQ) {
+            res = new bytes4[](12);
+            res[0] = 0x12599ac6; // addLiquiditySingleToken
+            res[1] = 0x2756ce06; // addLiquidityDualTokenAndPt
+            res[2] = 0x3dbe1c55; // addLiquiditySingleTokenKeepYt
+            res[3] = 0x4e390267; // addLiquiditySinglePt
+            res[4] = 0x58bda475; // addLiquiditySingleSy
+            res[5] = 0x60da0860; // removeLiquiditySingleToken
+            res[6] = 0x6b77ac9e; // removeLiquiditySinglePt
+            res[7] = 0x844384aa; // addLiquiditySingleSyKeepYt
+            res[8] = 0x97ee279e; // addLiquidityDualSyAndPt
+            res[9] = 0xb00f09d7; // removeLiquidityDualTokenAndPt
+            res[10] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
+            res[11] = 0xd13b4fdc; // removeLiquiditySingleSy
+        }
+        if (facet == ACTION_SWAP_YT) {
+            res = new bytes4[](6);
+            res[0] = 0x05eb5327; // swapExactYtForToken
+            res[1] = 0x448b9b95; // swapExactYtForPt
+            res[2] = 0x7b8b4b95; // swapExactSyForYt
+            res[3] = 0x80c4d566; // swapExactYtForSy
+            res[4] = 0xc861a898; // swapExactPtForYt
+            res[5] = 0xed48907e; // swapExactTokenForYt
+        }
+        if (facet == ACTION_SWAP_PT) {
+            res = new bytes4[](4);
+            res[0] = 0x2a50917c; // swapExactSyForPt
+            res[1] = 0x3346d3a3; // swapExactPtForSy
+            res[2] = 0x594a88cc; // swapExactPtForToken
+            res[3] = 0xc81f847a; // swapExactTokenForPt
+        }
+        if (facet == ACTION_CALLBACK) {
+            res = new bytes4[](2);
+            res[0] = 0xeb3a7d47; // limitRouterCallback
+            res[1] = 0xfa483e72; // swapCallback
+        }
+        if (facet == ACTION_MISC) {
+            res = new bytes4[](12);
+            res[0] = 0x1a8631b2; // mintPyFromSy
+            res[1] = 0x2d8f9d8d; // boostMarkets
+            res[2] = 0x2e071dc6; // mintSyFromToken
+            res[3] = 0x339748cb; // redeemPyToSy
+            res[4] = 0x339a5572; // redeemSyToToken
+            res[5] = 0x47f1de22; // redeemPyToToken
+            res[6] = 0x5d3e105c; // swapTokenToToken
+            res[7] = 0x60fc8466; // multicall
+            res[8] = 0xa89eba4a; // swapTokenToTokenViaSy
+            res[9] = 0xbd61951d; // simulate
+            res[10] = 0xd0f42385; // mintPyFromToken
+            res[11] = 0xf7e375e8; // redeemDueInterestAndRewards
+        }
+    }
+
+    function facetAddress(bytes4 sig) public view returns (address) {
+        if (sig < 0x6b77ac9e) {
+            if (sig < 0x3dbe1c55) {
+                if (sig < 0x2d8f9d8d) {
+                    if (sig < 0x1a8631b2) {
+                        if (sig == 0x05eb5327) return ACTION_SWAP_YT; //swapExactYtForToken
+                        if (sig == 0x12599ac6) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
+                    } else {
+                        if (sig == 0x1a8631b2) return ACTION_MISC; //mintPyFromSy
+                        if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                        if (sig == 0x2a50917c) return ACTION_SWAP_PT; //swapExactSyForPt
+                    }
+                } else {
+                    if (sig < 0x3346d3a3) {
+                        if (sig == 0x2d8f9d8d) return ACTION_MISC; //boostMarkets
+                        if (sig == 0x2e071dc6) return ACTION_MISC; //mintSyFromToken
+                    } else {
+                        if (sig == 0x3346d3a3) return ACTION_SWAP_PT; //swapExactPtForSy
+                        if (sig == 0x339748cb) return ACTION_MISC; //redeemPyToSy
+                        if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
+                    }
+                }
+            } else {
+                if (sig < 0x58bda475) {
+                    if (sig < 0x47f1de22) {
+                        if (sig == 0x3dbe1c55) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleTokenKeepYt
+                        if (sig == 0x448b9b95) return ACTION_SWAP_YT; //swapExactYtForPt
+                    } else {
+                        if (sig == 0x47f1de22) return ACTION_MISC; //redeemPyToToken
+                        if (sig == 0x4e390267) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
+                        if (sig == 0x52ef6b2c) return address(this); //facetAddresses
+                    }
+                } else {
+                    if (sig < 0x5d3e105c) {
+                        if (sig == 0x58bda475) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
+                        if (sig == 0x594a88cc) return ACTION_SWAP_PT; //swapExactPtForToken
+                    } else {
+                        if (sig == 0x5d3e105c) return ACTION_MISC; //swapTokenToToken
+                        if (sig == 0x60da0860) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
+                        if (sig == 0x60fc8466) return ACTION_MISC; //multicall
+                    }
+                }
+            }
+        } else {
+            if (sig < 0xbd61951d) {
+                if (sig < 0x97ee279e) {
+                    if (sig < 0x7b8b4b95) {
+                        if (sig == 0x6b77ac9e) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
+                        if (sig == 0x7a0ed627) return address(this); //facets
+                    } else {
+                        if (sig == 0x7b8b4b95) return ACTION_SWAP_YT; //swapExactSyForYt
+                        if (sig == 0x80c4d566) return ACTION_SWAP_YT; //swapExactYtForSy
+                        if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
+                    }
+                } else {
+                    if (sig < 0xadfca15e) {
+                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
+                        if (sig == 0xa89eba4a) return ACTION_MISC; //swapTokenToTokenViaSy
+                    } else {
+                        if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
+                        if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
+                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
+                    }
+                }
+            } else {
+                if (sig < 0xd13b4fdc) {
+                    if (sig < 0xc861a898) {
+                        if (sig == 0xbd61951d) return ACTION_MISC; //simulate
+                        if (sig == 0xc81f847a) return ACTION_SWAP_PT; //swapExactTokenForPt
+                    } else {
+                        if (sig == 0xc861a898) return ACTION_SWAP_YT; //swapExactPtForYt
+                        if (sig == 0xcdffacc6) return address(this); //facetAddress
+                        if (sig == 0xd0f42385) return ACTION_MISC; //mintPyFromToken
+                    }
+                } else {
+                    if (sig < 0xed48907e) {
+                        if (sig == 0xd13b4fdc) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
+                        if (sig == 0xeb3a7d47) return ACTION_CALLBACK; //limitRouterCallback
+                    } else {
+                        if (sig == 0xed48907e) return ACTION_SWAP_YT; //swapExactTokenForYt
+                        if (sig == 0xf7e375e8) return ACTION_MISC; //redeemDueInterestAndRewards
+                        if (sig == 0xfa483e72) return ACTION_CALLBACK; //swapCallback
+                    }
+                }
+            }
+        }
+        revert Errors.RouterInvalidAction(sig);
+        // NUM_FUNC: 40 AVG:4.80 WORST_CASE:6 STOP_BRANCH:3
+    }
+
+    function facetAddresses() public view returns (address[] memory) {
+        address[] memory res = new address[](6);
+        res[0] = address(this);
+        res[1] = ACTION_ADD_REMOVE_LIQ;
+        res[2] = ACTION_SWAP_YT;
+        res[3] = ACTION_SWAP_PT;
+        res[4] = ACTION_CALLBACK;
+        res[5] = ACTION_MISC;
+        return res;
+    }
+
+    function _implementation() internal view override returns (address) {
+        return facetAddress(msg.sig);
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -0,0 +1,289 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../core/libraries/TokenHelper.sol";
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPAllActionTypeV3.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../router/base/MarketApproxLib.sol";
+
+import "../../core/libraries/Errors.sol";
+import "../swap-aggregator/IPSwapAggregator.sol";
+
+abstract contract ActionBase is TokenHelper, IPLimitOrderType {
+    using MarketApproxPtOutLib for MarketState;
+    using PMath for uint256;
+    using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
+
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    // ----------------- MINT REDEEM SY PY -----------------
+
+    function _mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) internal returns (uint256 netSyOut) {
+        SwapType swapType = inp.swapData.swapType;
+
+        uint256 netTokenMintSy;
+
+        if (swapType == SwapType.NONE) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else if (swapType == SwapType.ETH_WETH) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            _wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else {
+            _swapTokenInput(inp);
+            netTokenMintSy = _selfBalance(inp.tokenMintSy);
+        }
+
+        netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);
+    }
+
+    function _swapTokenInput(TokenInput calldata inp) internal {
+        if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);
+        else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
+
+        IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
+            inp.tokenIn,
+            inp.netTokenIn,
+            inp.swapData
+        );
+    }
+
+    function __mintSy(
+        address receiver,
+        address SY,
+        uint256 netTokenMintSy,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) private returns (uint256 netSyOut) {
+        uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
+        _safeApproveInf(inp.tokenMintSy, SY);
+        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(
+            receiver,
+            inp.tokenMintSy,
+            netTokenMintSy,
+            minSyOut
+        );
+    }
+
+    function _redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) internal returns (uint256 netTokenOut) {
+        SwapType swapType = out.swapData.swapType;
+
+        if (swapType == SwapType.NONE) {
+            netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);
+        } else if (swapType == SwapType.ETH_WETH) {
+            netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull); // ETH:WETH is 1:1
+
+            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        } else {
+            uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);
+
+            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemed, out.swapData);
+
+            netTokenOut = _selfBalance(out.tokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        }
+
+        if (netTokenOut < out.minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
+        }
+    }
+
+    function __redeemSy(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) private returns (uint256 netTokenRedeemed) {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, SY, netSyIn);
+        }
+
+        netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
+    }
+
+    function _mintPyFromSy(
+        address receiver,
+        address SY,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut,
+        bool doPull
+    ) internal returns (uint256 netPyOut) {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
+        }
+
+        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
+        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
+    }
+
+    function _redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
+        address PT = IPYieldToken(YT).PT();
+
+        _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
+
+        netSyOut = IPYieldToken(YT).redeemPY(receiver);
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    // ----------------- HELPER -----------------
+
+    function _readMarket(address market) internal view returns (MarketState memory) {
+        return IPMarket(market).readState(address(this));
+    }
+
+    // ----------------- PT SWAP -----------------
+
+    function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : market;
+    }
+
+    function _swapExactPtForSy(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+
+        uint256 netPtLeft = exactPtIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, PT, netPtLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(PT), market, netPtLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                receiver,
+                netPtLeft,
+                EMPTY_BYTES
+            );
+
+            netSyOut += netSyOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    function _entry_swapExactSyForPt(address market, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : market;
+    }
+
+    function _swapExactSyForPt(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 netSyLeft = exactSyIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(SY), market, netSyLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netPtOutMarket, ) = _readMarket(market).approxSwapExactSyForPt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessPtOut
+            );
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);
+
+            netPtOut += netPtOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+    }
+
+    // ----------------- LIMIT ORDERS -----------------
+    function _fillLimit(
+        address receiver,
+        IERC20 tokenIn,
+        uint256 netInput,
+        LimitOrderData calldata lim
+    ) internal returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder) {
+        IPLimitRouter router = IPLimitRouter(lim.limitRouter);
+        netLeft = netInput;
+
+        if (lim.normalFills.length != 0) {
+            _safeApproveInf(address(tokenIn), lim.limitRouter);
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, ) = router.fill(
+                lim.normalFills,
+                receiver,
+                netLeft,
+                lim.optData,
+                EMPTY_BYTES
+            );
+            netOut += actualMaking;
+            netLeft -= actualTaking;
+            netSyFee += totalFee;
+        }
+
+        if (lim.flashFills.length != 0) {
+            address YT = lim.flashFills[0].order.YT;
+            OrderType orderType = lim.flashFills[0].order.orderType;
+
+            (, , uint256 totalFee, bytes memory ret) = router.fill(
+                lim.flashFills,
+                YT,
+                type(uint256).max,
+                lim.optData,
+                abi.encode(orderType, YT, netLeft, receiver)
+            );
+            (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
+
+            netOut += netReceived;
+            netLeft -= netUse;
+            netSyFee += totalFee;
+        }
+
+        doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);
+    }
+
+    function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
+        return a.normalFills.length == 0 && a.flashFills.length == 0;
+    }
+}

package/contracts/router/base/CallbackHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
+pragma solidity ^0.8.0;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -7,7 +7,6 @@ import "../../interfaces/IStandardizedYield.sol";
 
 abstract contract CallbackHelper {
     enum ActionType {
-        SwapSyForExactYt,
         SwapExactSyForYt,
         SwapYtForSy,
         SwapExactYtForPt,
@@ -18,67 +17,22 @@ abstract contract CallbackHelper {
     /// SwapExactSyForYt
     /// ------------------------------------------------------------
 
-    function _encodeSwapExactSyForYt(
-        address receiver,
-        uint256 minYtOut,
-        IPYieldToken YT
-    ) internal pure returns (bytes memory res) {
-        res = new bytes(128);
+    function _encodeSwapExactSyForYt(address receiver, IPYieldToken YT) internal pure returns (bytes memory res) {
+        res = new bytes(96);
         uint256 actionType = uint256(ActionType.SwapExactSyForYt);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), minYtOut)
-            mstore(add(res, 128), YT)
+            mstore(add(res, 96), YT)
         }
     }
 
-    function _decodeSwapExactSyForYt(
-        bytes calldata data
-    ) internal pure returns (address receiver, uint256 minYtOut, IPYieldToken YT) {
+    function _decodeSwapExactSyForYt(bytes calldata data) internal pure returns (address receiver, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            minYtOut := calldataload(add(data.offset, 64))
-            YT := calldataload(add(data.offset, 96))
-        }
-    }
-
-    /// ------------------------------------------------------------
-    /// SwapSyForExactYt
-    /// ------------------------------------------------------------
-
-    function _encodeSwapSyForExactYt(
-        address payer,
-        address receiver,
-        uint256 maxSyIn,
-        IStandardizedYield SY,
-        IPYieldToken YT
-    ) internal pure returns (bytes memory res) {
-        res = new bytes(192);
-        uint256 actionType = uint256(ActionType.SwapSyForExactYt);
-
-        assembly {
-            mstore(add(res, 32), actionType)
-            mstore(add(res, 64), payer)
-            mstore(add(res, 96), receiver)
-            mstore(add(res, 128), maxSyIn)
-            mstore(add(res, 160), SY)
-            mstore(add(res, 192), YT)
-        }
-    }
-
-    function _decodeSwapSyForExactYt(
-        bytes calldata data
-    ) internal pure returns (address payer, address receiver, uint256 maxSyIn, IStandardizedYield SY, IPYieldToken YT) {
-        assembly {
-            // first 32 bytes is ActionType
-            payer := calldataload(add(data.offset, 32))
-            receiver := calldataload(add(data.offset, 64))
-            maxSyIn := calldataload(add(data.offset, 96))
-            SY := calldataload(add(data.offset, 128))
-            YT := calldataload(add(data.offset, 160))
+            YT := calldataload(add(data.offset, 64))
         }
     }
 
@@ -86,67 +40,52 @@ abstract contract CallbackHelper {
     /// SwapYtForSy (common encode & decode)
     /// ------------------------------------------------------------
 
-    function _encodeSwapYtForSy(
-        address receiver,
-        uint256 minSyOut,
-        IPYieldToken YT
-    ) internal pure returns (bytes memory res) {
-        res = new bytes(128);
+    function _encodeSwapYtForSy(address receiver, IPYieldToken YT) internal pure returns (bytes memory res) {
+        res = new bytes(96);
         uint256 actionType = uint256(ActionType.SwapYtForSy);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), minSyOut)
-            mstore(add(res, 128), YT)
+            mstore(add(res, 96), YT)
         }
     }
 
-    function _decodeSwapYtForSy(
-        bytes calldata data
-    ) internal pure returns (address receiver, uint256 minSyOut, IPYieldToken YT) {
+    function _decodeSwapYtForSy(bytes calldata data) internal pure returns (address receiver, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            minSyOut := calldataload(add(data.offset, 64))
-            YT := calldataload(add(data.offset, 96))
+            YT := calldataload(add(data.offset, 64))
         }
     }
 
     function _encodeSwapExactYtForPt(
         address receiver,
-        uint256 exactYtIn,
-        uint256 minPtOut,
+        uint256 netPtOut,
         IPPrincipalToken PT,
         IPYieldToken YT
     ) internal pure returns (bytes memory res) {
-        res = new bytes(192);
+        res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactYtForPt);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), exactYtIn)
-            mstore(add(res, 128), minPtOut)
-            mstore(add(res, 160), PT)
-            mstore(add(res, 192), YT)
+            mstore(add(res, 96), netPtOut)
+            mstore(add(res, 128), PT)
+            mstore(add(res, 160), YT)
         }
     }
 
     function _decodeSwapExactYtForPt(
         bytes calldata data
-    )
-        internal
-        pure
-        returns (address receiver, uint256 exactYtIn, uint256 minPtOut, IPPrincipalToken PT, IPYieldToken YT)
-    {
+    ) internal pure returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            exactYtIn := calldataload(add(data.offset, 64))
-            minPtOut := calldataload(add(data.offset, 96))
-            PT := calldataload(add(data.offset, 128))
-            YT := calldataload(add(data.offset, 160))
+            netPtOut := calldataload(add(data.offset, 64))
+            PT := calldataload(add(data.offset, 96))
+            YT := calldataload(add(data.offset, 128))
         }
     }