@pendle/core-v2 2.15.1 → 2.15.2

package/contracts/offchain-helpers/MarketExchangeRateLib.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../core/Market/MarketMathCore.sol";
+import "../interfaces/IPMarket.sol";
+
+library MarketExchangeRateLib {
+    using Math for int256;
+    using MarketMathCore for MarketState;
+    using MarketMathCore for MarketPreCompute;
+
+    function getMarketExchangeRate(address market) internal view returns (uint256) {
+        MarketState memory state = IPMarket(market).readState(address(0));
+        MarketPreCompute memory comp = state.getMarketPreCompute(
+            _getPYIndexCurrent(market),
+            block.timestamp
+        );
+
+        return
+            MarketMathCore
+                ._getExchangeRate(
+                    state.totalPt,
+                    comp.totalAsset,
+                    comp.rateScalar,
+                    comp.rateAnchor,
+                    0
+                )
+                .Uint();
+    }
+
+    function _getPYIndexCurrent(address market) private view returns (PYIndex) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 ytIndex = YT.pyIndexStored();
+        uint256 pyIndexCurrent;
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            pyIndexCurrent = ytIndex;
+        } else {
+            uint256 syIndex = SY.exchangeRate();
+            pyIndexCurrent = Math.max(syIndex, ytIndex);
+        }
+        return PYIndex.wrap(pyIndexCurrent);
+    }
+}

package/contracts/router/swap-aggregator/{PendleSwapEthereum.sol → PendleSwap.sol}

@@ -1,22 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts/utils/Address.sol";
 import "../../core/libraries/TokenHelper.sol";
-import "../../core/libraries/Errors.sol";
 import "./IPSwapAggregator.sol";
-import "./1inch/OneInchAggregationRouterHelper.sol";
-import "./kyberswap/ethereum/KyberHelperEthereum.sol";
+import "./kyberswap/KyberInputScalingHelper.sol";
 
-contract PendleSwapEthereum is
-    IPSwapAggregator,
-    TokenHelper,
-    KyberHelperEthereum,
-    OneInchAggregationRouterHelper
-{
+contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper {
     using Address for address;
 
-    function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
+    function swap(
+        address tokenIn,
+        uint256 amountIn,
+        SwapData calldata data
+    ) external payable {
         _safeApproveInf(tokenIn, data.extRouter);
         data.extRouter.functionCallWithValue(
             data.needScale
@@ -34,7 +30,7 @@ contract PendleSwapEthereum is
         if (swapType == SwapType.KYBERSWAP) {
             scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
         } else if (swapType == SwapType.ONE_INCH) {
-            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
+            revert("not supported");
         } else {
             assert(false);
         }

package/contracts/router/swap-aggregator/kyberswap/{arbitrum/IExecutorHelper1.sol → IExecutorHelper.sol}

@@ -1,9 +1,22 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import "./IHashflow.sol";
+interface IExecutorHelper {
+    struct Swap {
+        bytes data;
+        bytes4 functionSelector;
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
 
-interface IExecutorHelper1 {
     struct UniSwap {
         address pool;
         address tokenIn;
@@ -51,15 +64,6 @@ interface IExecutorHelper1 {
         uint160 sqrtPriceLimitX96;
         bool isUniV3; // true = UniV3, false = ProMM
     }
-    struct SwapCallbackData {
-        bytes path;
-        address payer;
-    }
-    struct SwapCallbackDataPath {
-        address pool;
-        address tokenIn;
-        address tokenOut;
-    }
 
     struct BalancerV2 {
         address vault;
@@ -70,14 +74,6 @@ interface IExecutorHelper1 {
         uint256 limit;
     }
 
-    struct KyberRFQ {
-        address rfq;
-        bytes order;
-        bytes signature;
-        uint256 amount;
-        address payable target;
-    }
-
     struct DODO {
         address recipient;
         address pool;
@@ -110,9 +106,27 @@ interface IExecutorHelper1 {
         bool useAtomicExchange;
     }
 
-    struct Hashflow {
+    struct Platypus {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+        uint256 limitReturnAmount;
+    }
+
+    struct PSM {
         address router;
-        IHashflow.Quote quote;
+        address tokenIn;
+        address tokenOut;
+        uint256 amountIn;
+        address recipient;
+    }
+
+    struct WSTETH {
+        address pool;
+        uint256 amount;
+        bool isWrapping;
     }
 
     function executeUniSwap(
@@ -175,6 +189,18 @@ interface IExecutorHelper1 {
         uint256 previousAmountOut
     ) external payable returns (uint256);
 
+    function executePlatypusSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeWrappedstETHSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
     function executeSynthetixSwap(
         uint256 index,
         bytes memory data,
@@ -187,9 +213,27 @@ interface IExecutorHelper1 {
         uint256 previousAmountOut
     ) external payable returns (uint256);
 
+    function executePSMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeFraxSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
     function executeCamelotSwap(
         uint256 index,
         bytes memory data,
         uint256 previousAmountOut
     ) external payable returns (uint256);
+
+    function executeKyberLimitOrder(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
 }

package/contracts/router/swap-aggregator/kyberswap/{arbitrum/IMetaAggregationRouterV2.sol → IMetaAggregationRouterV2.sol}

@@ -28,9 +28,10 @@ interface IMetaAggregationRouterV2 {
         bytes clientData;
     }
 
-    function swap(
-        SwapExecutionParams calldata execution
-    ) external payable returns (uint256, uint256);
+    function swap(SwapExecutionParams calldata execution)
+        external
+        payable
+        returns (uint256, uint256);
 
     function swapSimpleMode(
         IAggregationExecutor caller,

package/contracts/router/swap-aggregator/kyberswap/KyberInputScalingHelper.sol

@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+import "./IMetaAggregationRouterV2.sol";
+import "./IHashflow.sol";
+import "./IExecutorHelper.sol";
+import "./ScalingDataLib.sol";
+
+abstract contract KyberInputScalingHelper {
+    uint256 private constant _PARTIAL_FILL = 0x01;
+    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
+    uint256 private constant _SHOULD_CLAIM = 0x04;
+    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
+    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
+    uint256 private constant _SIMPLE_SWAP = 0x20;
+
+    // fee data in case taking in dest token
+    struct PositiveSlippageFeeData {
+        uint256 partnerPSInfor; // [partnerReceiver (160 bit) + partnerPercent(96bits)]
+        uint256 expectedReturnAmount;
+    }
+
+    struct Swap {
+        bytes data;
+        bytes4 functionSelector;
+    }
+
+    struct SimpleSwapData {
+        address[] firstPools;
+        uint256[] firstSwapAmounts;
+        bytes[] swapDatas;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
+    function _getKyberScaledInputData(bytes calldata inputData, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        bytes4 selector = bytes4(inputData[:4]);
+        bytes calldata dataToDecode = inputData[4:];
+
+        if (selector == IMetaAggregationRouterV2.swap.selector) {
+            IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
+                dataToDecode,
+                (IMetaAggregationRouterV2.SwapExecutionParams)
+            );
+
+            (params.desc, params.targetData) = _getScaledInputDataV2(
+                params.desc,
+                params.targetData,
+                newAmount,
+                _flagsChecked(params.desc.flags, _SIMPLE_SWAP)
+            );
+            return abi.encodeWithSelector(selector, params);
+        } else if (selector == IMetaAggregationRouterV2.swapSimpleMode.selector) {
+            (
+                address callTarget,
+                IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+                bytes memory targetData,
+                bytes memory clientData
+            ) = abi.decode(
+                    dataToDecode,
+                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
+                );
+
+            (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
+            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
+        } else revert("InputScalingHelper: Invalid selector");
+    }
+
+    function _getScaledInputDataV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        bytes memory executorData,
+        uint256 newAmount,
+        bool isSimpleMode
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory, bytes memory) {
+        uint256 oldAmount = desc.amount;
+        if (oldAmount == newAmount) {
+            return (desc, executorData);
+        }
+
+        // simple mode swap
+        if (isSimpleMode) {
+            return (
+                _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
+            );
+        }
+
+        //normal mode swap
+        return (
+            _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
+        );
+    }
+
+    /// @dev Scale the swap description
+    function _scaledSwapDescriptionV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory) {
+        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
+        if (desc.minReturnAmount == 0) desc.minReturnAmount = 1;
+        desc.amount = newAmount;
+
+        uint256 nReceivers = desc.srcReceivers.length;
+        for (uint256 i = 0; i < nReceivers; ) {
+            desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
+            unchecked {
+                ++i;
+            }
+        }
+        return desc;
+    }
+
+    /// @dev Scale the executorData in case swapSimpleMode
+    function _scaledSimpleSwapData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
+
+        uint256 nPools = swapData.firstPools.length;
+        for (uint256 i = 0; i < nPools; ) {
+            swapData.firstSwapAmounts[i] = (swapData.firstSwapAmounts[i] * newAmount) / oldAmount;
+            unchecked {
+                ++i;
+            }
+        }
+        swapData.positiveSlippageData = _scaledPositiveSlippageFeeData(
+            swapData.positiveSlippageData,
+            oldAmount,
+            newAmount
+        );
+        return abi.encode(swapData);
+    }
+
+    /// @dev Scale the executorData in case normal swap
+    function _scaledExecutorCallBytesData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
+        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
+        executorDesc.positiveSlippageData = _scaledPositiveSlippageFeeData(
+            executorDesc.positiveSlippageData,
+            oldAmount,
+            newAmount
+        );
+
+        uint256 nSequences = executorDesc.swapSequences.length;
+        for (uint256 i = 0; i < nSequences; ) {
+            Swap memory swap = executorDesc.swapSequences[i][0];
+            bytes4 functionSelector = swap.functionSelector;
+
+            if (functionSelector == IExecutorHelper.executeUniSwap.selector) {
+                swap.data = ScalingDataLib.newUniSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeStableSwap.selector) {
+                swap.data = ScalingDataLib.newStableSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeCurveSwap.selector) {
+                swap.data = ScalingDataLib.newCurveSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeKyberDMMSwap.selector) {
+                swap.data = ScalingDataLib.newKyberDMM(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeUniV3ProMMSwap.selector) {
+                swap.data = ScalingDataLib.newUniV3ProMM(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeRfqSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (functionSelector == IExecutorHelper.executeBalV2Swap.selector) {
+                swap.data = ScalingDataLib.newBalancerV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeWrappedstETHSwap.selector) {
+                swap.data = ScalingDataLib.newWrappedstETHSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeDODOSwap.selector) {
+                swap.data = ScalingDataLib.newDODO(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeVelodromeSwap.selector) {
+                swap.data = ScalingDataLib.newVelodrome(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeGMXSwap.selector) {
+                swap.data = ScalingDataLib.newGMX(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeSynthetixSwap.selector) {
+                swap.data = ScalingDataLib.newSynthetix(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeHashflowSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (functionSelector == IExecutorHelper.executeCamelotSwap.selector) {
+                swap.data = ScalingDataLib.newCamelot(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeKyberLimitOrder.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (functionSelector == IExecutorHelper.executePSMSwap.selector) {
+                swap.data = ScalingDataLib.newPSM(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeFraxSwap.selector) {
+                swap.data = ScalingDataLib.newFrax(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executePlatypusSwap.selector) {
+                swap.data = ScalingDataLib.newPlatypus(swap.data, oldAmount, newAmount);
+            } else revert("AggregationExecutor: Dex type not supported");
+            unchecked {
+                ++i;
+            }
+        }
+        return abi.encode(executorDesc);
+    }
+
+    function _scaledPositiveSlippageFeeData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory newData) {
+        if (data.length > 32) {
+            PositiveSlippageFeeData memory psData = abi.decode(data, (PositiveSlippageFeeData));
+            psData.expectedReturnAmount = (psData.expectedReturnAmount * newAmount) / oldAmount;
+            data = abi.encode(psData);
+        } else if (data.length == 32) {
+            uint256 expectedReturnAmount = abi.decode(data, (uint256));
+            expectedReturnAmount = (expectedReturnAmount * newAmount) / oldAmount;
+            data = abi.encode(expectedReturnAmount);
+        }
+        return data;
+    }
+
+    function _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
+        return number & flag != 0;
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/{arbitrum/ScaleDataHelperArbitrum.sol → ScalingDataLib.sol}

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import { IExecutorHelper1 } from "./IExecutorHelper1.sol";
+import "./IExecutorHelper.sol";
 
-library ScaleDataHelperArbitrum {
+library ScalingDataLib {
     function newUniSwap(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelper1.UniSwap));
+        IExecutorHelper.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelper.UniSwap));
         uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(uniSwap);
     }
@@ -19,9 +19,9 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.StableSwap memory stableSwap = abi.decode(
+        IExecutorHelper.StableSwap memory stableSwap = abi.decode(
             data,
-            (IExecutorHelper1.StableSwap)
+            (IExecutorHelper.StableSwap)
         );
         stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
         return abi.encode(stableSwap);
@@ -32,10 +32,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.CurveSwap memory curveSwap = abi.decode(
-            data,
-            (IExecutorHelper1.CurveSwap)
-        );
+        IExecutorHelper.CurveSwap memory curveSwap = abi.decode(data, (IExecutorHelper.CurveSwap));
         curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
         return abi.encode(curveSwap);
     }
@@ -45,10 +42,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.UniSwap memory kyberDMMSwap = abi.decode(
-            data,
-            (IExecutorHelper1.UniSwap)
-        );
+        IExecutorHelper.UniSwap memory kyberDMMSwap = abi.decode(data, (IExecutorHelper.UniSwap));
         kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(kyberDMMSwap);
     }
@@ -58,9 +52,9 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+        IExecutorHelper.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
             data,
-            (IExecutorHelper1.UniSwapV3ProMM)
+            (IExecutorHelper.UniSwapV3ProMM)
         );
         uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
 
@@ -72,9 +66,9 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.BalancerV2 memory balancerV2 = abi.decode(
+        IExecutorHelper.BalancerV2 memory balancerV2 = abi.decode(
             data,
-            (IExecutorHelper1.BalancerV2)
+            (IExecutorHelper.BalancerV2)
         );
         balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
         return abi.encode(balancerV2);
@@ -85,7 +79,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.DODO memory dodo = abi.decode(data, (IExecutorHelper1.DODO));
+        IExecutorHelper.DODO memory dodo = abi.decode(data, (IExecutorHelper.DODO));
         dodo.amount = (dodo.amount * newAmount) / oldAmount;
         return abi.encode(dodo);
     }
@@ -95,7 +89,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.UniSwap memory velodrome = abi.decode(data, (IExecutorHelper1.UniSwap));
+        IExecutorHelper.UniSwap memory velodrome = abi.decode(data, (IExecutorHelper.UniSwap));
         velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
         return abi.encode(velodrome);
     }
@@ -105,7 +99,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.GMX memory gmx = abi.decode(data, (IExecutorHelper1.GMX));
+        IExecutorHelper.GMX memory gmx = abi.decode(data, (IExecutorHelper.GMX));
         gmx.amount = (gmx.amount * newAmount) / oldAmount;
         return abi.encode(gmx);
     }
@@ -115,10 +109,7 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.Synthetix memory synthetix = abi.decode(
-            data,
-            (IExecutorHelper1.Synthetix)
-        );
+        IExecutorHelper.Synthetix memory synthetix = abi.decode(data, (IExecutorHelper.Synthetix));
         synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
         return abi.encode(synthetix);
     }
@@ -128,8 +119,48 @@ library ScaleDataHelperArbitrum {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper1.UniSwap memory camelot = abi.decode(data, (IExecutorHelper1.UniSwap));
+        IExecutorHelper.UniSwap memory camelot = abi.decode(data, (IExecutorHelper.UniSwap));
         camelot.collectAmount = (camelot.collectAmount * newAmount) / oldAmount;
         return abi.encode(camelot);
     }
+
+    function newPlatypus(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.Platypus memory platypus = abi.decode(data, (IExecutorHelper.Platypus));
+        platypus.collectAmount = (platypus.collectAmount * newAmount) / oldAmount;
+        return abi.encode(platypus);
+    }
+
+    function newWrappedstETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.WSTETH memory wstEthData = abi.decode(data, (IExecutorHelper.WSTETH));
+        wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
+        return abi.encode(wstEthData);
+    }
+
+    function newPSM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.PSM memory psm = abi.decode(data, (IExecutorHelper.PSM));
+        psm.amountIn = (psm.amountIn * newAmount) / oldAmount;
+        return abi.encode(psm);
+    }
+
+    function newFrax(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.UniSwap memory frax = abi.decode(data, (IExecutorHelper.UniSwap));
+        frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
+        return abi.encode(frax);
+    }
 }

package/deployments/1-core.json

@@ -22,7 +22,7 @@
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x38812C3AC3563Bf200482ac9D096952D7cB55f9b",
+    "pendleSwap": "0x5719AcDB9ABBBC6Ba414C9DBFf5B2967342f465d",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0x414d3C8A26157085f286abE3BC6E1bb010733602",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",

package/deployments/42161-core.json

@@ -19,7 +19,7 @@
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0xF0bF560F01d4196773a5c58A09d6D34b6bba4503",
+    "pendleSwap": "0x150DD76FAd24C0715dB375d06f1C2C1d917D7d93",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0x428f2f93afAc3F96B0DE59854038c585e06165C8",
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.15.1",
+  "version": "2.15.2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",