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

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

@@ -0,0 +1,329 @@
+// 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,173 @@
+// 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

@@ -4,6 +4,7 @@
         "chainId": 1,
         "treasury": "0x8270400d528c34e1596EF367eeDEc99080A1b592",
         "governance": "0x8119EC16F0573B7dAc7C0CB94EB504FB32456ee1",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
         "pendle": "0x808507121b80c02388fad14726482e061b8da827",
         "lzEndpoint": "0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675",
         "wrappedNative": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
@@ -21,12 +22,14 @@
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
     "bulkSellerFactory": "0x4B1da107B50529d53e5C906a79eaEcDCbC0E1dE3",
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
-    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
+    "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x324D838b26Eb73786bDBBc53bb0682F1EBB50603",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "routerHelper2": "0x2ed3af0275a1fd0c53c39d70241a1c14e8ce37d3",
-    "ptOracle": "0x14030836AEc15B2ad48bB097bd57032559339c92",
+    "ptOracle": "0xbbd487268A295531d299c125F3e5f749884A3e30",
+    "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
+    "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
     "liquiditySeedingHelper": "0x39cD9CB33dA6b5eb2A22CbE0a07647E2c3C76D23",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",

package/deployments/1-markets/EPENDLE-SEP2024.json

@@ -0,0 +1,12 @@
+{
+    "name": "SY ePendle",
+    "symbol": "SY-ePendle",
+    "doCacheIndex": true,
+    "expiry": 1727308800,
+    "scalarRoot": "22259416476000000000",
+    "initialRateAnchor": "1134651159000000000",
+    "SY": "0x887bdD18D042A85b9c702698eFE71E1C38d5C868",
+    "PT": "0x0Ba11DEe8b63f08EA25d0cc733601e8C15325a8D",
+    "YT": "0x41535fc6AdCb81a7af1bD4669d221983Ed4e33Af",
+    "market": "0x0eB3f11ed8ca69813744868D02D83D4Fbf72841e"
+}

package/deployments/1-markets/SFRAX-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY sFRAX",
+    "SY": "0xb359F0A97Ca269Ae5574dc75be48b0e81eFD1dA2",
+    "YT": "0xDe364a895D4EC08c05A34F6883A8E41C15619Ed8",
+    "PT": "0xBF44fbCc181e297E1532B72c6ca500fe150C5b9E",
+    "market": "0x1806855b73881eD4E435c97C6Da58b01Be5D7390",
+    "expiry": 1711584000,
+    "scalarRoot": "151425174849000000000",
+    "initAnchor": "1025338668000000000"
+}

package/deployments/1-markets/SILO-CRVUSD-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Silo crvUSD",
+    "SY": "0xE05082B184a34668CD8A904D85FA815802BBb04c",
+    "YT": "0xED97f94dd94255637A054098604E0201C442a3FD",
+    "PT": "0xB87511364014C088e30f872EfC4a00D7efB843AC",
+    "market": "0xC9beCdbC62efb867cB52222b34c187fB170379C6",
+    "expiry": 1711584000,
+    "scalarRoot": "50749840533000000000",
+    "initAnchor": "1033799235000000000"
+}