@pendle/core-v2 2.29.3 → 2.30.0

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/InputScalingHelperL2.sol

@@ -0,0 +1,314 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IAggregationExecutorOptimistic as IExecutorHelperL2} from "../interfaces/IAggregationExecutorOptimistic.sol";
+import {IExecutorHelper as IExecutorHelperL1} from "../interfaces/IExecutorHelper.sol";
+import {IMetaAggregationRouterV2} from "../interfaces/IMetaAggregationRouterV2.sol";
+import {ScalingDataL2Lib} from "./ScalingDataL2Lib.sol";
+import {ExecutorReader} from "./ExecutorReader.sol";
+import {CalldataWriter} from "./CalldataWriter.sol";
+
+library InputScalingHelperL2 {
+    using ExecutorReader for bytes;
+    using ScalingDataL2Lib for bytes;
+
+    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;
+
+    struct PositiveSlippageFeeData {
+        uint256 partnerPSInfor;
+        uint256 expectedReturnAmount;
+    }
+
+    enum DexIndex {
+        UNI,
+        KyberDMM,
+        Velodrome,
+        Fraxswap,
+        Camelot,
+        KyberLO,
+        RFQ,
+        Hashflow,
+        StableSwap,
+        Curve,
+        UniswapV3KSElastic,
+        BalancerV2,
+        DODO,
+        GMX,
+        Synthetix,
+        wstETH,
+        stETH,
+        Platypus,
+        PSM,
+        Maverick,
+        SyncSwap,
+        AlgebraV1,
+        BalancerBatch,
+        Mantis,
+        Wombat,
+        iZiSwap,
+        TraderJoeV2,
+        WooFiV2,
+        KyberDSLO,
+        LevelFiV2,
+        GMXGLP,
+        PancakeStableSwap,
+        Vooi,
+        VelocoreV2,
+        Smardex,
+        SolidlyV2,
+        Kokonut
+    }
+
+    function _getScaledInputData(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 = (desc.amount * newAmount) / oldAmount;
+
+        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)
+    {
+        IMetaAggregationRouterV2.SimpleSwapData memory simpleSwapData =
+            abi.decode(data, (IMetaAggregationRouterV2.SimpleSwapData));
+        uint256 nPools = simpleSwapData.firstPools.length;
+        address tokenIn;
+
+        for (uint256 i = 0; i < nPools;) {
+            simpleSwapData.firstSwapAmounts[i] = (simpleSwapData.firstSwapAmounts[i] * newAmount) / oldAmount;
+
+            IExecutorHelperL2.Swap[] memory dexData;
+
+            (dexData, tokenIn) = simpleSwapData.swapDatas[i].readSwapSingleSequence();
+
+            // only need to scale the first dex in each sequence
+            if (dexData.length > 0) {
+                dexData[0] = _scaleDexData(dexData[0], oldAmount, newAmount);
+            }
+
+            simpleSwapData.swapDatas[i] = CalldataWriter._writeSwapSingleSequence(abi.encode(dexData), tokenIn);
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        simpleSwapData.positiveSlippageData =
+            _scaledPositiveSlippageFeeData(simpleSwapData.positiveSlippageData, oldAmount, newAmount);
+
+        return abi.encode(simpleSwapData);
+    }
+
+    /// @dev Scale the executorData in case normal swap
+    function _scaledExecutorCallBytesData(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        IExecutorHelperL2.SwapExecutorDescription memory executorDesc =
+            abi.decode(data.readSwapExecutorDescription(), (IExecutorHelperL2.SwapExecutorDescription));
+
+        executorDesc.positiveSlippageData =
+            _scaledPositiveSlippageFeeData(executorDesc.positiveSlippageData, oldAmount, newAmount);
+
+        uint256 nSequences = executorDesc.swapSequences.length;
+        for (uint256 i = 0; i < nSequences;) {
+            // only need to scale the first dex in each sequence
+            IExecutorHelperL2.Swap memory swap = executorDesc.swapSequences[i][0];
+            executorDesc.swapSequences[i][0] = _scaleDexData(swap, oldAmount, newAmount);
+            unchecked {
+                ++i;
+            }
+        }
+        return CalldataWriter.writeSwapExecutorDescription(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));
+            uint256 left = uint256(psData.expectedReturnAmount >> 128);
+            uint256 right = (uint256(uint128(psData.expectedReturnAmount)) * newAmount) / oldAmount;
+            require(right <= type(uint128).max, "_scaledPositiveSlippageFeeData/Exceeded type range");
+            psData.expectedReturnAmount = right | (left << 128);
+            data = abi.encode(psData);
+        } else if (data.length == 32) {
+            uint256 expectedReturnAmount = abi.decode(data, (uint256));
+            uint256 left = uint256(expectedReturnAmount >> 128);
+            uint256 right = (uint256(uint128(expectedReturnAmount)) * newAmount) / oldAmount;
+            require(right <= type(uint128).max, "_scaledPositiveSlippageFeeData/Exceeded type range");
+            expectedReturnAmount = right | (left << 128);
+            data = abi.encode(expectedReturnAmount);
+        }
+        return data;
+    }
+
+    function _scaleDexData(IExecutorHelperL2.Swap memory swap, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (IExecutorHelperL2.Swap memory)
+    {
+        uint8 functionSelectorIndex = uint8(uint32(swap.functionSelector));
+
+        if (DexIndex(functionSelectorIndex) == DexIndex.UNI) {
+            swap.data = swap.data.newUniSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.StableSwap) {
+            swap.data = swap.data.newStableSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Curve) {
+            swap.data = swap.data.newCurveSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberDMM) {
+            swap.data = swap.data.newKyberDMM(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.UniswapV3KSElastic) {
+            swap.data = swap.data.newUniswapV3KSElastic(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.RFQ) {
+            revert("InputScalingHelper: Can not scale RFQ swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerV2) {
+            swap.data = swap.data.newBalancerV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.wstETH) {
+            swap.data = swap.data.newWrappedstETHSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.stETH) {
+            swap.data = swap.data.newStETHSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.DODO) {
+            swap.data = swap.data.newDODO(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Velodrome) {
+            swap.data = swap.data.newVelodrome(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.GMX) {
+            swap.data = swap.data.newGMX(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Synthetix) {
+            swap.data = swap.data.newSynthetix(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Hashflow) {
+            revert("InputScalingHelper: Can not scale Hashflow swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Camelot) {
+            swap.data = swap.data.newCamelot(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberLO) {
+            revert("InputScalingHelper: Can not scale KyberLO swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.PSM) {
+            swap.data = swap.data.newPSM(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Fraxswap) {
+            swap.data = swap.data.newFrax(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Platypus) {
+            swap.data = swap.data.newPlatypus(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Maverick) {
+            swap.data = swap.data.newMaverick(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SyncSwap) {
+            swap.data = swap.data.newSyncSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.AlgebraV1) {
+            swap.data = swap.data.newAlgebraV1(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerBatch) {
+            swap.data = swap.data.newBalancerBatch(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Mantis) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Wombat) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.iZiSwap) {
+            swap.data = swap.data.newIziSwap(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.TraderJoeV2) {
+            swap.data = swap.data.newTraderJoeV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.WooFiV2) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberDSLO) {
+            revert("InputScalingHelper: Can not scale KyberDSLO swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.LevelFiV2) {
+            swap.data = swap.data.newLevelFiV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.PancakeStableSwap) {
+            swap.data = swap.data.newCurveSwap(oldAmount, newAmount); // @dev same encoded data as Curve
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.GMXGLP) {
+            swap.data = swap.data.newGMXGLP(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Vooi) {
+            swap.data = swap.data.newVooi(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.VelocoreV2) {
+            swap.data = swap.data.newVelocoreV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Smardex) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SolidlyV2) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Kokonut) {
+            swap.data = swap.data.newKokonut(oldAmount, newAmount);
+        } else {
+            revert("InputScaleHelper: Dex type not supported");
+        }
+        return swap;
+    }
+
+    function _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
+        return number & flag != 0;
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/ScalingDataL2Lib.sol

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IExecutorHelper} from "../interfaces/IExecutorHelper.sol";
+import {DexScaler} from "./DexScaler.sol";
+
+library ScalingDataL2Lib {
+    using DexScaler for bytes;
+
+    function newUniSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleUniSwap(oldAmount, newAmount);
+    }
+
+    function newStableSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleStableSwap(oldAmount, newAmount);
+    }
+
+    function newCurveSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleCurveSwap(oldAmount, newAmount);
+    }
+
+    function newKyberDMM(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleUniSwap(oldAmount, newAmount);
+    }
+
+    function newUniswapV3KSElastic(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleUniswapV3KSElastic(oldAmount, newAmount);
+    }
+
+    function newBalancerV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleBalancerV2(oldAmount, newAmount);
+    }
+
+    function newDODO(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleDODO(oldAmount, newAmount);
+    }
+
+    function newVelodrome(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleUniSwap(oldAmount, newAmount);
+    }
+
+    function newGMX(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleGMX(oldAmount, newAmount);
+    }
+
+    function newSynthetix(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleSynthetix(oldAmount, newAmount);
+    }
+
+    function newCamelot(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleUniSwap(oldAmount, newAmount);
+    }
+
+    function newPlatypus(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scalePlatypus(oldAmount, newAmount);
+    }
+
+    function newWrappedstETHSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleWrappedstETH(oldAmount, newAmount);
+    }
+
+    function newPSM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scalePSM(oldAmount, newAmount);
+    }
+
+    function newFrax(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleUniSwap(oldAmount, newAmount);
+    }
+
+    function newStETHSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleStETH(oldAmount, newAmount);
+    }
+
+    function newMaverick(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleMaverick(oldAmount, newAmount);
+    }
+
+    function newSyncSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleSyncSwap(oldAmount, newAmount);
+    }
+
+    function newAlgebraV1(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleAlgebraV1(oldAmount, newAmount);
+    }
+
+    function newBalancerBatch(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleBalancerBatch(oldAmount, newAmount);
+    }
+
+    function newMantis(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleMantis(oldAmount, newAmount);
+    }
+
+    function newIziSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleIziSwap(oldAmount, newAmount);
+    }
+
+    function newTraderJoeV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleTraderJoeV2(oldAmount, newAmount);
+    }
+
+    function newLevelFiV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleLevelFiV2(oldAmount, newAmount);
+    }
+
+    function newGMXGLP(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleGMXGLP(oldAmount, newAmount);
+    }
+
+    function newVooi(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleVooi(oldAmount, newAmount);
+    }
+
+    function newVelocoreV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return data.scaleVelocoreV2(oldAmount, newAmount);
+    }
+
+    function newKokonut(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleKokonut(oldAmount, newAmount);
+    }
+}

package/contracts/router/swap-aggregator/oneinch/I1inchAggregationRouterV5.sol

@@ -20,20 +20,14 @@ interface I1inchAggregationRouterV5 {
         uint256 amount,
         uint256 minReturn,
         uint256[] calldata pools
-    ) external payable returns(uint256 returnAmount);
+    ) external payable returns (uint256 returnAmount);
 
     function swap(
         address executor,
         SwapDescription calldata desc,
         bytes calldata permit,
         bytes calldata data
-    )
-        external
-        payable
-        returns (
-            uint256 returnAmount,
-            uint256 spentAmount
-        );
+    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
 
     function unoswapTo(
         address payable recipient,
@@ -41,5 +35,5 @@ interface I1inchAggregationRouterV5 {
         uint256 amount,
         uint256 minReturn,
         uint256[] calldata pools
-    ) external payable returns(uint256 returnAmount);
-}
+    ) external payable returns (uint256 returnAmount);
+}

package/contracts/router/swap-aggregator/oneinch/OneInchAggregationRouterHelper.sol

@@ -5,25 +5,26 @@ import "./I1inchAggregationRouterV5.sol";
 import "../../../core/libraries/Errors.sol";
 
 abstract contract OneInchAggregationRouterHelper {
-    function _rescaleMinAmount(uint256 minAmount, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _rescaleMinAmount(
+        uint256 minAmount,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (uint256) {
         return (minAmount * newAmount) / oldAmount;
     }
 
-    function _get1inchScaledInputData(bytes calldata rawCallData, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function _get1inchScaledInputData(
+        bytes calldata rawCallData,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         bytes4 selector = bytes4(rawCallData[:4]);
         bytes memory args = rawCallData[4:];
 
         if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
-            (address payable recipient, uint256 amount, uint256 minReturn, uint256[] memory pools) =
-                abi.decode(args, (address, uint256, uint256, uint256[]));
+            (address payable recipient, uint256 amount, uint256 minReturn, uint256[] memory pools) = abi.decode(
+                args,
+                (address, uint256, uint256, uint256[])
+            );
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
@@ -42,8 +43,13 @@ abstract contract OneInchAggregationRouterHelper {
         }
 
         if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
-            (address payable recipient, address srcToken, uint256 amount, uint256 minReturn, uint256[] memory pools) =
-                abi.decode(args, (address, address, uint256, uint256, uint256[]));
+            (
+                address payable recipient,
+                address srcToken,
+                uint256 amount,
+                uint256 minReturn,
+                uint256[] memory pools
+            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);

package/deployments/1-core.json

@@ -23,7 +23,7 @@
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x10115a984d69b0a832239a26d1841f10a59e45d8",
+    "pendleSwap": "0x324D838b26Eb73786bDBBc53bb0682F1EBB50603",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "routerHelper2": "0x2ed3af0275a1fd0c53c39d70241a1c14e8ce37d3",
     "ptOracle": "0x14030836AEc15B2ad48bB097bd57032559339c92",

package/deployments/10-core.json

@@ -20,7 +20,7 @@
     "marketFactory": "0x17F100fB4bE2707675c6439468d38249DD993d58",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
-    "pendleSwap": "0x963ddBB35c1AE44e2a159E3b5fb5177E0B32660d",
+    "pendleSwap": "0x85D0C209FC632e6908D78BE08646dE3e39A58453",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "routerHelper2": "0x25e5e9E134ddAf1D378fcB0Ec8dbd3F148cb55FD",
     "ptOracle": "0x4106FC9811a792130502Bb3A5b693894cca7bD8e",

package/deployments/42161-core.json

@@ -20,7 +20,7 @@
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0x38812c3ac3563bf200482ac9d096952d7cb55f9b",
+    "pendleSwap": "0x8e09Aa43885d99701AB047dA2aC98aECC13807B0",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "routerHelper2": "0x64e50365eb97a199d71b15e32761c4b9147cd0f0",
     "ptOracle": "0x1f6Cee6740e1492C279532348137FF40E0f23D05",
@@ -28,5 +28,6 @@
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
     "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00",
-    "arbMerkleDistribution": "0x23a102e78D1FF1645a3666691495174764a5FCAF"
+    "arbMerkleDistribution": "0x23a102e78D1FF1645a3666691495174764a5FCAF",
+    "linearDistributor": "0x83d85AEDD308261d847C3eb8d7146457bD8F38E8"
 }

package/deployments/42161-markets/ARBSILO-USDC-FEB2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY sUSDC-ARBSilo",
+    "SY": "0x60955a190dec0dB9a45ABe553ad2994126EfdFcc",
+    "YT": "0x2591bC78d50d777CAC68AedDA0e8BC928A89A538",
+    "PT": "0xBFd3A44f673f4d4dF9b1Ec126C4a5F602F0380Ad",
+    "market": "0x9bC62257Ffe7D0f7c52A019E6Fc0AF3102F8F44E",
+    "expiry": 1706745600,
+    "scalarRoot": "77329115195000000000",
+    "initAnchor": "1013174833000000000"
+}

package/deployments/42161-markets/GM-ARB-USDC-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY GM ARB-USDC",
+    "SY": "0xC5b5d60EccB76C4a53F7DBE7cE3cb5D92557EFfF",
+    "YT": "0x1B33c8D479Ce5596fF9756a3010E70a7412938E2",
+    "PT": "0x81f2c7b56f34290D2261F15883F2F80d78981b68",
+    "market": "0x1C3330F1886D8B7eEC8af75C66fB6Fd6CCbe28b5",
+    "expiry": 1711584000,
+    "scalarRoot": "31533820064000000000",
+    "initAnchor": "1043835748000000000"
+}

package/deployments/42161-markets/MLP-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY MUXLP",
+    "SY": "0x4B3f79Ce3D5d752064288FD2Be968A1c21b3ba37",
+    "YT": "0xf31B528d724354575c0c65Ab17D6dEcde29d2900",
+    "PT": "0xF0A219e14D4c058022A828b16Af9888b143ab5aD",
+    "market": "0x65819E4Ee91923499934c86e93357f633033CB0b",
+    "expiry": 1711584000,
+    "scalarRoot": "7804354537000000000",
+    "initAnchor": "1146830265000000000"
+}

package/deployments/56-core.json

@@ -20,7 +20,7 @@
     "marketFactory": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
     "router": "0x00000000025EFaDc0b8d17d3d87aB5056e3D2510",
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0x59f0c4a186744b573f15fbbc3737014f7f3da835",
+    "pendleSwap": "0xD85d2F484DF4329746325e7398f3fC3E1915a173",
     "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
     "routerHelper2": "0x46aCbe071f580bfC09C6F48326f01148991DB107",
     "ptOracle": "0xA48A88EbF6683324bAf17aEB51A6d89294D4bedc",