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

package/contracts/router/PendleRouterV3.sol

@@ -37,7 +37,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         uint256 nFacets = facets_.length;
 
         IDiamondCut.FacetCut[] memory cuts = new IDiamondCut.FacetCut[](nFacets);
-        for (uint256 i; i < nFacets;) {
+        for (uint256 i; i < nFacets; ) {
             cuts[i].facetAddress = facets_[i].facetAddress;
             cuts[i].action = IDiamondCut.FacetCutAction.Add;
             cuts[i].functionSelectors = facets_[i].functionSelectors;
@@ -58,7 +58,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         uint256 numFacets = facetAddresses_.length;
 
         facets_ = new Facet[](numFacets);
-        for (uint256 i; i < numFacets;) {
+        for (uint256 i; i < numFacets; ) {
             facets_[i].facetAddress = facetAddresses_[i];
             facets_[i].functionSelectors = facetFunctionSelectors(facetAddresses_[i]);
             unchecked {
@@ -77,38 +77,38 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         }
         if (facet == ACTION_ADD_REMOVE_LIQ) {
             res = new bytes4[](12);
-            res[0] = 0x237287c8; // removeLiquiditySinglePt
+            res[0] = 0x12599ac6; // addLiquiditySingleToken
             res[1] = 0x2756ce06; // addLiquidityDualTokenAndPt
             res[2] = 0x3dbe1c55; // addLiquiditySingleTokenKeepYt
-            res[3] = 0x587e3950; // removeLiquiditySingleToken
-            res[4] = 0x5a245eef; // addLiquiditySingleSy
-            res[5] = 0x844384aa; // addLiquiditySingleSyKeepYt
-            res[6] = 0x97ee279e; // addLiquidityDualSyAndPt
-            res[7] = 0x9cb6711e; // addLiquiditySingleToken
-            res[8] = 0xb00f09d7; // removeLiquidityDualTokenAndPt
-            res[9] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
-            res[10] = 0xe81560a4; // removeLiquiditySingleSy
-            res[11] = 0xef03bda7; // addLiquiditySinglePt
+            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] = 0x0a793c62; // swapExactYtForSy
+            res[0] = 0x05eb5327; // swapExactYtForToken
             res[1] = 0x448b9b95; // swapExactYtForPt
-            res[2] = 0x7e0646c4; // swapExactYtForToken
-            res[3] = 0x9c1010ec; // swapExactTokenForYt
+            res[2] = 0x7b8b4b95; // swapExactSyForYt
+            res[3] = 0x80c4d566; // swapExactYtForSy
             res[4] = 0xc861a898; // swapExactPtForYt
-            res[5] = 0xf80915bc; // swapExactSyForYt
+            res[5] = 0xed48907e; // swapExactTokenForYt
         }
         if (facet == ACTION_SWAP_PT) {
             res = new bytes4[](4);
-            res[0] = 0x12c15afc; // swapExactSyForPt
-            res[1] = 0x32aea98a; // swapExactTokenForPt
-            res[2] = 0x7a95dddd; // swapExactPtForSy
-            res[3] = 0xc245e48d; // swapExactPtForToken
+            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] = 0xb5617576; // normalFillCallback
+            res[0] = 0xeb3a7d47; // limitRouterCallback
             res[1] = 0xfa483e72; // swapCallback
         }
         if (facet == ACTION_MISC) {
@@ -129,86 +129,86 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
     }
 
     function facetAddress(bytes4 sig) public view returns (address) {
-        if (sig < 0x7e0646c4) {
+        if (sig < 0x6b77ac9e) {
             if (sig < 0x3dbe1c55) {
                 if (sig < 0x2d8f9d8d) {
                     if (sig < 0x1a8631b2) {
-                        if (sig == 0x0a793c62) return ACTION_SWAP_YT; //swapExactYtForSy
-                        if (sig == 0x12c15afc) return ACTION_SWAP_PT; //swapExactSyForPt
+                        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 == 0x237287c8) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
                         if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                        if (sig == 0x2a50917c) return ACTION_SWAP_PT; //swapExactSyForPt
                     }
                 } else {
-                    if (sig < 0x32aea98a) {
+                    if (sig < 0x3346d3a3) {
                         if (sig == 0x2d8f9d8d) return ACTION_MISC; //boostMarkets
                         if (sig == 0x2e071dc6) return ACTION_MISC; //mintSyFromToken
                     } else {
-                        if (sig == 0x32aea98a) return ACTION_SWAP_PT; //swapExactTokenForPt
+                        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 < 0x5a245eef) {
+                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
-                        if (sig == 0x587e3950) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
                     }
                 } else {
-                    if (sig < 0x60fc8466) {
-                        if (sig == 0x5a245eef) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
-                        if (sig == 0x5d3e105c) return ACTION_MISC; //swapTokenToToken
+                    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
-                        if (sig == 0x7a0ed627) return address(this); //facets
-                        if (sig == 0x7a95dddd) return ACTION_SWAP_PT; //swapExactPtForSy
                     }
                 }
             }
         } else {
             if (sig < 0xbd61951d) {
-                if (sig < 0xa89eba4a) {
-                    if (sig < 0x97ee279e) {
-                        if (sig == 0x7e0646c4) return ACTION_SWAP_YT; //swapExactYtForToken
-                        if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
+                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 == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
-                        if (sig == 0x9c1010ec) return ACTION_SWAP_YT; //swapExactTokenForYt
-                        if (sig == 0x9cb6711e) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
+                        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 < 0xb00f09d7) {
+                    if (sig < 0xadfca15e) {
+                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
                         if (sig == 0xa89eba4a) return ACTION_MISC; //swapTokenToTokenViaSy
-                        if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
                     } else {
+                        if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
                         if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
-                        if (sig == 0xb5617576) return ACTION_CALLBACK; //normalFillCallback
                         if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
                     }
                 }
             } else {
-                if (sig < 0xe81560a4) {
+                if (sig < 0xd13b4fdc) {
                     if (sig < 0xc861a898) {
                         if (sig == 0xbd61951d) return ACTION_MISC; //simulate
-                        if (sig == 0xc245e48d) return ACTION_SWAP_PT; //swapExactPtForToken
+                        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 < 0xf7e375e8) {
-                        if (sig == 0xe81560a4) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleSy
-                        if (sig == 0xef03bda7) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySinglePt
+                    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 == 0xf80915bc) return ACTION_SWAP_YT; //swapExactSyForYt
                         if (sig == 0xfa483e72) return ACTION_CALLBACK; //swapCallback
                     }
                 }

package/contracts/router/base/ActionBase.sol

@@ -11,7 +11,7 @@ import "../../router/base/MarketApproxLib.sol";
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
 
-abstract contract ActionBase is TokenHelper, IPOrderMixinType {
+abstract contract ActionBase is TokenHelper, IPLimitOrderType {
     using MarketApproxPtOutLib for MarketState;
     using PMath for uint256;
     using PYIndexLib for IPYieldToken;
@@ -21,10 +21,12 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
 
     // ----------------- MINT REDEEM SY PY -----------------
 
-    function _mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata inp)
-        internal
-        returns (uint256 netSyOut)
-    {
+    function _mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) internal returns (uint256 netSyOut) {
         SwapType swapType = inp.swapData.swapType;
 
         uint256 netTokenMintSy;
@@ -49,23 +51,36 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         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
+            inp.tokenIn,
+            inp.netTokenIn,
+            inp.swapData
         );
     }
 
-    function __mintSy(address receiver, address SY, uint256 netTokenMintSy, uint256 minSyOut, TokenInput calldata inp)
-        private
-        returns (uint256 netSyOut)
-    {
+    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);
+        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)
-    {
+    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) {
@@ -91,10 +106,13 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         }
     }
 
-    function __redeemSy(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
-        private
-        returns (uint256 netTokenRedeemed)
-    {
+    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);
         }
@@ -102,10 +120,14 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         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)
-    {
+    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);
         }
@@ -114,10 +136,12 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
-    function _redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
-        internal
-        returns (uint256 netSyOut)
-    {
+    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);
@@ -148,7 +172,7 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         uint256 minSyOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netPtLeft = exactPtIn;
         bool doMarketOrder = true;
@@ -161,8 +185,11 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         }
 
         if (doMarketOrder) {
-            (uint256 netSyOutMarket, uint256 netSyFeeMarket) =
-                IPMarket(market).swapExactPtForSy(receiver, netPtLeft, EMPTY_BYTES);
+            (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                receiver,
+                netPtLeft,
+                EMPTY_BYTES
+            );
 
             netSyOut += netSyOutMarket;
             netSyFee += netSyFeeMarket;
@@ -183,7 +210,7 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         ApproxParams calldata guessPtOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         uint256 netSyLeft = exactSyIn;
         bool doMarketOrder = true;
 
@@ -195,8 +222,12 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
         }
 
         if (doMarketOrder) {
-            (uint256 netPtOutMarket,) =
-                _readMarket(market).approxSwapExactSyForPt(YT.newIndex(), netSyLeft, block.timestamp, guessPtOut);
+            (uint256 netPtOutMarket, ) = _readMarket(market).approxSwapExactSyForPt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessPtOut
+            );
 
             (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);
 
@@ -208,33 +239,45 @@ abstract contract ActionBase is TokenHelper, IPOrderMixinType {
     }
 
     // ----------------- LIMIT ORDERS -----------------
-    function _fillLimit(address receiver, IERC20 tokenIn, uint256 netInput, LimitOrderData calldata lim)
-        internal
-        returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder)
-    {
+    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.normalFill(lim.normalFills, receiver, netLeft, EMPTY_BYTES);
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, ) = router.fill(
+                lim.normalFills,
+                receiver,
+                netLeft,
+                lim.optData,
+                EMPTY_BYTES
+            );
             netOut += actualMaking;
-            netSyFee += totalFee;
             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.normalFill(lim.flashFills, YT, type(uint256).max, abi.encode(orderType, YT, netLeft, receiver));
+            (, , 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;
-            netSyFee += totalFee;
             netLeft -= netUse;
+            netSyFee += totalFee;
         }
 
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);

package/contracts/router/base/CallbackHelper.sol

@@ -59,11 +59,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactYtForPt(address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactYtForPt(
+        address receiver,
+        uint256 netPtOut,
+        IPPrincipalToken PT,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactYtForPt);
 
@@ -76,11 +77,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-    {
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -90,11 +89,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactPtForYt(address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactPtForYt(
+        address receiver,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactPtForYt);
 
@@ -107,11 +107,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-    {
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))