@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/router/swap-aggregator/OKXScaleHelper.sol

@@ -7,11 +7,6 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract OKXScaleHelper {
     address public immutable _tokenApprove;
-    uint256 internal constant TRIM_FLAG_MASK = 0xffffffffffff0000000000000000000000000000000000000000000000000000;
-    uint256 internal constant TRIM_FLAG = 0x7777777711110000000000000000000000000000000000000000000000000000;
-    uint256 internal constant TRIM_DUAL_FLAG = 0x7777777722220000000000000000000000000000000000000000000000000000;
-    uint256 internal constant TRIM_EXPECT_AMOUNT_OUT_MASK =
-        0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
 
     // @dev `allowUnsupportedChain` is a safe guard to prevent deploying this contract on unsupported chains by mistake
     // @dev Please add new `__getTokenApproveForChain` entry when deploying to a new chain.
@@ -33,7 +28,7 @@ abstract contract OKXScaleHelper {
         if (chainid == 56) {
             return 0x2c34A2Fb1d0b4f55de51E1d0bDEfaDDce6b7cDD6;
         }
-        if (chainid == 42_161) {
+        if (chainid == 42161) {
             return 0x70cBb871E8f30Fc8Ce23609E9E0Ea87B6b222F58;
         }
         if (chainid == 8453 || chainid == 5000) {
@@ -53,22 +48,23 @@ abstract contract OKXScaleHelper {
         return _tokenApprove;
     }
 
-    function _okxScaling(bytes calldata rawCallData, uint256 actualAmount)
-        internal
-        pure
-        returns (bytes memory scaledCallData)
-    {
+    function _okxScaling(
+        bytes calldata rawCallData,
+        uint256 actualAmount
+    ) internal pure returns (bytes memory scaledCallData) {
         bytes4 selector = bytes4(rawCallData[:4]);
         bytes calldata dataToDecode = rawCallData[4:];
-        uint256 rawAmountIn;
+
         if (selector == IOKXDexRouter.uniswapV3SwapTo.selector) {
-            (uint256 receiver, uint256 amount, uint256 minReturn, uint256[] memory pools) =
-                abi.decode(dataToDecode, (uint256, uint256, uint256, uint256[]));
-            rawAmountIn = amount;
+            (uint256 receiver, uint256 amount, uint256 minReturn, uint256[] memory pools) = abi.decode(
+                dataToDecode,
+                (uint256, uint256, uint256, uint256[])
+            );
+
             minReturn = (minReturn * actualAmount) / amount;
             amount = actualAmount;
 
-            scaledCallData = abi.encodeWithSelector(selector, receiver, amount, minReturn, pools);
+            return abi.encodeWithSelector(selector, receiver, amount, minReturn, pools);
         } else if (selector == IOKXDexRouter.smartSwapTo.selector) {
             (
                 uint256 orderId,
@@ -78,41 +74,40 @@ abstract contract OKXScaleHelper {
                 IOKXDexRouter.RouterPath[][] memory batches,
                 IOKXDexRouter.PMMSwapRequest[] memory extraData
             ) = abi.decode(
-                dataToDecode,
-                (
-                    uint256,
-                    address,
-                    IOKXDexRouter.BaseRequest,
-                    uint256[],
-                    IOKXDexRouter.RouterPath[][],
-                    IOKXDexRouter.PMMSwapRequest[]
-                )
-            );
-            rawAmountIn = baseRequest.fromTokenAmount;
+                    dataToDecode,
+                    (
+                        uint256,
+                        address,
+                        IOKXDexRouter.BaseRequest,
+                        uint256[],
+                        IOKXDexRouter.RouterPath[][],
+                        IOKXDexRouter.PMMSwapRequest[]
+                    )
+                );
+
             batchesAmount = _scaleArray(batchesAmount, actualAmount, baseRequest.fromTokenAmount);
             baseRequest.minReturnAmount = (baseRequest.minReturnAmount * actualAmount) / baseRequest.fromTokenAmount;
             baseRequest.fromTokenAmount = actualAmount;
 
-            scaledCallData =
-                abi.encodeWithSelector(selector, orderId, receiver, baseRequest, batchesAmount, batches, extraData);
+            return abi.encodeWithSelector(selector, orderId, receiver, baseRequest, batchesAmount, batches, extraData);
         } else if (selector == IOKXDexRouter.unxswapTo.selector) {
-            (uint256 srcToken, uint256 amount, uint256 minReturn, address receiver, bytes32[] memory pools) =
-                abi.decode(dataToDecode, (uint256, uint256, uint256, address, bytes32[]));
+            (uint256 srcToken, uint256 amount, uint256 minReturn, address receiver, bytes32[] memory pools) = abi
+                .decode(dataToDecode, (uint256, uint256, uint256, address, bytes32[]));
 
             minReturn = (minReturn * actualAmount) / amount;
-            rawAmountIn = amount;
             amount = actualAmount;
 
-            scaledCallData = abi.encodeWithSelector(selector, srcToken, amount, minReturn, receiver, pools);
+            return abi.encodeWithSelector(selector, srcToken, amount, minReturn, receiver, pools);
         } else if (selector == IOKXDexRouter.unxswapByOrderId.selector) {
-            (uint256 srcToken, uint256 amount, uint256 minReturn, bytes32[] memory pools) =
-                abi.decode(dataToDecode, (uint256, uint256, uint256, bytes32[]));
-            rawAmountIn = amount;
+            (uint256 srcToken, uint256 amount, uint256 minReturn, bytes32[] memory pools) = abi.decode(
+                dataToDecode,
+                (uint256, uint256, uint256, bytes32[])
+            );
 
             minReturn = (minReturn * actualAmount) / amount;
             amount = actualAmount;
 
-            scaledCallData = abi.encodeWithSelector(selector, srcToken, amount, minReturn, pools);
+            return abi.encodeWithSelector(selector, srcToken, amount, minReturn, pools);
         } else if (selector == IOKXDexRouter.smartSwapByOrderId.selector) {
             (
                 uint256 orderId,
@@ -121,159 +116,39 @@ abstract contract OKXScaleHelper {
                 IOKXDexRouter.RouterPath[][] memory batches,
                 IOKXDexRouter.PMMSwapRequest[] memory extraData
             ) = abi.decode(
-                dataToDecode,
-                (
-                    uint256,
-                    IOKXDexRouter.BaseRequest,
-                    uint256[],
-                    IOKXDexRouter.RouterPath[][],
-                    IOKXDexRouter.PMMSwapRequest[]
-                )
-            );
-            rawAmountIn = baseRequest.fromTokenAmount;
-            batchesAmount = _scaleArray(batchesAmount, actualAmount, baseRequest.fromTokenAmount);
-            baseRequest.minReturnAmount = (baseRequest.minReturnAmount * actualAmount) / baseRequest.fromTokenAmount;
-            baseRequest.fromTokenAmount = actualAmount;
-
-            scaledCallData = abi.encodeWithSelector(selector, orderId, baseRequest, batchesAmount, batches, extraData);
-        } else if (selector == IOKXDexRouter.dagSwapTo.selector) {
-            (
-                uint256 orderId,
-                address receiver,
-                IOKXDexRouter.BaseRequest memory baseRequest,
-                IOKXDexRouter.RouterPath[] memory paths
-            ) = abi.decode(dataToDecode, (uint256, address, IOKXDexRouter.BaseRequest, IOKXDexRouter.RouterPath[]));
-
-            rawAmountIn = baseRequest.fromTokenAmount;
-            baseRequest.minReturnAmount = (baseRequest.minReturnAmount * actualAmount) / baseRequest.fromTokenAmount;
-            baseRequest.fromTokenAmount = actualAmount;
+                    dataToDecode,
+                    (
+                        uint256,
+                        IOKXDexRouter.BaseRequest,
+                        uint256[],
+                        IOKXDexRouter.RouterPath[][],
+                        IOKXDexRouter.PMMSwapRequest[]
+                    )
+                );
 
-            scaledCallData = abi.encodeWithSelector(selector, orderId, receiver, baseRequest, paths);
-        } else if (selector == IOKXDexRouter.dagSwapByOrderId.selector) {
-            (uint256 orderId, IOKXDexRouter.BaseRequest memory baseRequest, IOKXDexRouter.RouterPath[] memory paths) =
-                abi.decode(dataToDecode, (uint256, IOKXDexRouter.BaseRequest, IOKXDexRouter.RouterPath[]));
-            rawAmountIn = baseRequest.fromTokenAmount;
+            batchesAmount = _scaleArray(batchesAmount, actualAmount, baseRequest.fromTokenAmount);
             baseRequest.minReturnAmount = (baseRequest.minReturnAmount * actualAmount) / baseRequest.fromTokenAmount;
             baseRequest.fromTokenAmount = actualAmount;
 
-            scaledCallData = abi.encodeWithSelector(selector, orderId, baseRequest, paths);
+            return abi.encodeWithSelector(selector, orderId, baseRequest, batchesAmount, batches, extraData);
         } else {
             revert("PendleSwap: OKX selector not supported");
         }
-
-        scaledCallData = _scaleTrimInfo(dataToDecode, scaledCallData, actualAmount, rawAmountIn);
-        return scaledCallData;
     }
 
-    function _scaleArray(uint256[] memory arr, uint256 newAmount, uint256 oldAmount)
-        internal
-        pure
-        returns (uint256[] memory scaledArr)
-    {
+    function _scaleArray(
+        uint256[] memory arr,
+        uint256 newAmount,
+        uint256 oldAmount
+    ) internal pure returns (uint256[] memory scaledArr) {
         scaledArr = new uint256[](arr.length);
         for (uint256 i = 0; i < arr.length; i++) {
             scaledArr[i] = (arr[i] * newAmount) / oldAmount;
         }
     }
-
-    // ┌─────────────┬─────────────┬─────────────────┬─────────────┬─────────────┬─────────────────┐
-    // │ trim_flag   │ padding     │ expect_amount   │ trim_flag   │ trim_rate   │ trim_address    │
-    // │ 6 bytes     │ 6 bytes     │ 20 bytes        │ 6 bytes     │ 6 bytes     │ 20 bytes        │
-    // │0x777777771111│0x000000000000│               │0x777777771111│            │                 │
-    // └─────────────┴─────────────┴─────────────────┴─────────────┴─────────────┴─────────────────┘
-    //   ←────────────── 32 bytes ──────────────→
-    // ←────────────── 32 bytes ──────────────→
-
-    // ┌─────────────┬─────────────┬─────────────────┬─────────────┬─────────────┬─────────────────┬─────────────┬─────────────┬─────────────────┐
-    // │ trim_flag   │ charge_rate │ charge_address  │ trim_flag   │ padding     │ expect_amount   │
-    // trim_flag   │ trim_rate1  │ trim_address1   │
-    // │ 6 bytes     │ 6 bytes     │ 20 bytes        │ 6 bytes     │ 6 bytes     │ 20 bytes        │ 6
-    // bytes     │ 6 bytes     │ 20 bytes        │ │0x777777772222│            │
-    // │0x777777772222│0x000000000000│               │0x77777772222│             │                 │
-    // └─────────────┴─────────────┴─────────────────┴─────────────┴─────────────┴─────────────────┴─────────────┴─────────────┴─────────────────┘
-    // ←────────────── 32 bytes ──────────────→
-    // ←────────────── 32 bytes ──────────────→
-    // ←────────────── 32 bytes ──────────────→
-    function _scaleTrimInfo(
-        bytes calldata dataToDecode,
-        bytes memory scaledCallData,
-        uint256 actualAmountIn,
-        uint256 rawAmountIn
-    ) internal pure returns (bytes memory) {
-        uint256 length = dataToDecode.length;
-        // search trim flag from back to front, get the index
-        uint256 firstFlagIndex = length - 32;
-        while (firstFlagIndex > 0) {
-            if (
-                uint256(bytes32(dataToDecode[firstFlagIndex:firstFlagIndex + 32])) & TRIM_FLAG_MASK == TRIM_FLAG
-                    || uint256(bytes32(dataToDecode[firstFlagIndex:firstFlagIndex + 32])) & TRIM_FLAG_MASK
-                        == TRIM_DUAL_FLAG
-            ) {
-                break;
-            }
-            firstFlagIndex -= 32;
-        }
-        require(
-            firstFlagIndex == 0 || firstFlagIndex > scaledCallData.length + 32,
-            "PendleSwap: OKX calldata length mismatch"
-        );
-        if (firstFlagIndex > scaledCallData.length + 32) {
-            uint256 middleFlagIndex = firstFlagIndex - 32;
-            uint256 data = uint256(bytes32(dataToDecode[middleFlagIndex:middleFlagIndex + 32]));
-            require(
-                data & TRIM_FLAG_MASK == TRIM_FLAG || data & TRIM_FLAG_MASK == TRIM_DUAL_FLAG,
-                "PendleSwap: OKX trim flag not found in expected position"
-            );
-            uint256 expectAmountOut =
-                uint256(bytes32(dataToDecode[middleFlagIndex:middleFlagIndex + 32])) & TRIM_EXPECT_AMOUNT_OUT_MASK;
-
-            uint256 acutalExpectAmountOut = (expectAmountOut * actualAmountIn) / rawAmountIn;
-
-            if (data & TRIM_FLAG_MASK == TRIM_FLAG) {
-                bytes32 middle = bytes32(
-                    abi.encodePacked(bytes6(bytes32(uint256(TRIM_FLAG))), uint48(0), uint160(acutalExpectAmountOut))
-                );
-                bytes32 first = bytes32(dataToDecode[firstFlagIndex:firstFlagIndex + 32]);
-                scaledCallData = abi.encodePacked(scaledCallData, middle, first);
-            } else {
-                bytes32 last = bytes32(dataToDecode[middleFlagIndex - 32:middleFlagIndex]);
-                bytes32 middle = bytes32(
-                    abi.encodePacked(
-                        bytes6(bytes32(uint256(TRIM_DUAL_FLAG))), uint48(0), uint160(acutalExpectAmountOut)
-                    )
-                );
-                bytes32 first = bytes32(dataToDecode[firstFlagIndex:firstFlagIndex + 32]);
-
-                scaledCallData = abi.encodePacked(scaledCallData, last, middle, first);
-            }
-        }
-        return scaledCallData;
-    }
 }
 
 interface IOKXDexRouter {
-    struct CommissionInfo {
-        bool isFromTokenCommission; //0x00
-        bool isToTokenCommission; //0x20
-        uint256 commissionRate; //0x40
-        address refererAddress; //0x60
-        address token; //0x80
-        uint256 commissionRate2; //0xa0
-        address refererAddress2; //0xc0
-        bool isToBCommission; //0xe0
-        uint256 commissionRate3; //0x100
-        address refererAddress3; //0x120
-    }
-
-    struct TrimInfo {
-        bool hasTrim; // 0x00
-        uint256 trimRate; // 0x20
-        address trimAddress; // 0x40
-        uint256 expectAmountOut; // 0x60
-        uint256 chargeRate; // 0x80
-        address chargeAddress; // 0xa0
-    }
-
     struct BaseRequest {
         uint256 fromToken;
         address toToken;
@@ -316,10 +191,12 @@ interface IOKXDexRouter {
     //     address to
     // ) external payable;
 
-    function uniswapV3SwapTo(uint256 receiver, uint256 amount, uint256 minReturn, uint256[] calldata pools)
-        external
-        payable
-        returns (uint256 returnAmount);
+    function uniswapV3SwapTo(
+        uint256 receiver,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns (uint256 returnAmount);
 
     function smartSwapTo(
         uint256 orderId,
@@ -345,10 +222,7 @@ interface IOKXDexRouter {
         uint256 minReturn,
         // solhint-disable-next-line no-unused-vars
         bytes32[] calldata pools
-    )
-        external
-        payable
-        returns (uint256 returnAmount);
+    ) external payable returns (uint256 returnAmount);
 
     function smartSwapByOrderId(
         uint256 orderId,
@@ -357,14 +231,4 @@ interface IOKXDexRouter {
         RouterPath[][] calldata batches,
         PMMSwapRequest[] calldata extraData
     ) external payable returns (uint256 returnAmount);
-
-    function dagSwapTo(uint256 orderId, address receiver, BaseRequest calldata baseRequest, RouterPath[] calldata paths)
-        external
-        payable
-        returns (uint256 returnAmount);
-
-    function dagSwapByOrderId(uint256 orderId, BaseRequest calldata baseRequest, RouterPath[] calldata paths)
-        external
-        payable
-        returns (uint256 returnAmount);
 }

package/contracts/router/swap-aggregator/ParaswapScaleHelper.sol

@@ -36,10 +36,11 @@ interface IAugustusV6 {
         bytes pools;
     }
 
-    function swapExactAmountInOnUniswapV2(UniswapV2Data calldata uniData, uint256 partnerAndFee, bytes calldata permit)
-        external
-        payable
-        returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
+    function swapExactAmountInOnUniswapV2(
+        UniswapV2Data calldata uniData,
+        uint256 partnerAndFee,
+        bytes calldata permit
+    ) external payable returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
 
     // ============ UniswapV3 Swap ============
     struct UniswapV3Data {
@@ -53,10 +54,11 @@ interface IAugustusV6 {
         bytes pools;
     }
 
-    function swapExactAmountInOnUniswapV3(UniswapV3Data calldata uniData, uint256 partnerAndFee, bytes calldata permit)
-        external
-        payable
-        returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
+    function swapExactAmountInOnUniswapV3(
+        UniswapV3Data calldata uniData,
+        uint256 partnerAndFee,
+        bytes calldata permit
+    ) external payable returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
 
     // ============ BalancerV2 Swap ============
     struct BalancerV2Data {
@@ -87,10 +89,11 @@ interface IAugustusV6 {
         address payable beneficiary;
     }
 
-    function swapExactAmountInOnCurveV1(CurveV1Data calldata curveV1Data, uint256 partnerAndFee, bytes calldata permit)
-        external
-        payable
-        returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
+    function swapExactAmountInOnCurveV1(
+        CurveV1Data calldata curveV1Data,
+        uint256 partnerAndFee,
+        bytes calldata permit
+    ) external payable returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
 
     // ============ CurveV2 Swap ============
     struct CurveV2Data {
@@ -107,10 +110,11 @@ interface IAugustusV6 {
         address payable beneficiary;
     }
 
-    function swapExactAmountInOnCurveV2(CurveV2Data calldata curveV2Data, uint256 partnerAndFee, bytes calldata permit)
-        external
-        payable
-        returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
+    function swapExactAmountInOnCurveV2(
+        CurveV2Data calldata curveV2Data,
+        uint256 partnerAndFee,
+        bytes calldata permit
+    ) external payable returns (uint256 receivedAmount, uint256 paraswapShare, uint256 partnerShare);
 
     // ============ MakerPSM Swap ============
     struct MakerPSMData {
@@ -126,17 +130,17 @@ interface IAugustusV6 {
         uint256 beneficiaryDirectionApproveFlag;
     }
 
-    function swapExactAmountInOutOnMakerPSM(MakerPSMData calldata makerPSMData, bytes calldata permit)
-        external
-        returns (uint256 spentAmount, uint256 receivedAmount);
+    function swapExactAmountInOutOnMakerPSM(
+        MakerPSMData calldata makerPSMData,
+        bytes calldata permit
+    ) external returns (uint256 spentAmount, uint256 receivedAmount);
 }
 
 contract ParaswapScaleHelper {
-    function _paraswapScaling(bytes calldata rawCallData, uint256 amountIn)
-        internal
-        pure
-        returns (bytes memory scaledCallData)
-    {
+    function _paraswapScaling(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure returns (bytes memory scaledCallData) {
         bytes4 selector = bytes4(rawCallData[:4]);
         bytes calldata dataToDecode = rawCallData[4:];
 
@@ -159,8 +163,10 @@ contract ParaswapScaleHelper {
         }
         // Handle UniswapV2
         else if (selector == IAugustusV6.swapExactAmountInOnUniswapV2.selector) {
-            (IAugustusV6.UniswapV2Data memory uniData, uint256 partnerAndFee, bytes memory permit) =
-                abi.decode(dataToDecode, (IAugustusV6.UniswapV2Data, uint256, bytes));
+            (IAugustusV6.UniswapV2Data memory uniData, uint256 partnerAndFee, bytes memory permit) = abi.decode(
+                dataToDecode,
+                (IAugustusV6.UniswapV2Data, uint256, bytes)
+            );
 
             // Direct scaling calculation
             uniData.toAmount = (uniData.toAmount * amountIn) / uniData.fromAmount;
@@ -171,8 +177,10 @@ contract ParaswapScaleHelper {
         }
         // Handle UniswapV3
         else if (selector == IAugustusV6.swapExactAmountInOnUniswapV3.selector) {
-            (IAugustusV6.UniswapV3Data memory uniV3Data, uint256 partnerAndFee, bytes memory permit) =
-                abi.decode(dataToDecode, (IAugustusV6.UniswapV3Data, uint256, bytes));
+            (IAugustusV6.UniswapV3Data memory uniV3Data, uint256 partnerAndFee, bytes memory permit) = abi.decode(
+                dataToDecode,
+                (IAugustusV6.UniswapV3Data, uint256, bytes)
+            );
 
             // Direct scaling calculation
             uniV3Data.toAmount = (uniV3Data.toAmount * amountIn) / uniV3Data.fromAmount;
@@ -199,8 +207,10 @@ contract ParaswapScaleHelper {
         }
         // Handle CurveV1
         else if (selector == IAugustusV6.swapExactAmountInOnCurveV1.selector) {
-            (IAugustusV6.CurveV1Data memory curveV1Data, uint256 partnerAndFee, bytes memory permit) =
-                abi.decode(dataToDecode, (IAugustusV6.CurveV1Data, uint256, bytes));
+            (IAugustusV6.CurveV1Data memory curveV1Data, uint256 partnerAndFee, bytes memory permit) = abi.decode(
+                dataToDecode,
+                (IAugustusV6.CurveV1Data, uint256, bytes)
+            );
 
             // Direct scaling calculation
             curveV1Data.toAmount = (curveV1Data.toAmount * amountIn) / curveV1Data.fromAmount;
@@ -211,8 +221,10 @@ contract ParaswapScaleHelper {
         }
         // Handle CurveV2
         else if (selector == IAugustusV6.swapExactAmountInOnCurveV2.selector) {
-            (IAugustusV6.CurveV2Data memory curveV2Data, uint256 partnerAndFee, bytes memory permit) =
-                abi.decode(dataToDecode, (IAugustusV6.CurveV2Data, uint256, bytes));
+            (IAugustusV6.CurveV2Data memory curveV2Data, uint256 partnerAndFee, bytes memory permit) = abi.decode(
+                dataToDecode,
+                (IAugustusV6.CurveV2Data, uint256, bytes)
+            );
 
             // Direct scaling calculation
             curveV2Data.toAmount = (curveV2Data.toAmount * amountIn) / curveV2Data.fromAmount;
@@ -223,8 +235,10 @@ contract ParaswapScaleHelper {
         }
         // Handle MakerPSM
         else if (selector == IAugustusV6.swapExactAmountInOutOnMakerPSM.selector) {
-            (IAugustusV6.MakerPSMData memory makerPSMData, bytes memory permit) =
-                abi.decode(dataToDecode, (IAugustusV6.MakerPSMData, bytes));
+            (IAugustusV6.MakerPSMData memory makerPSMData, bytes memory permit) = abi.decode(
+                dataToDecode,
+                (IAugustusV6.MakerPSMData, bytes)
+            );
 
             // Direct scaling calculation
             makerPSMData.toAmount = (makerPSMData.toAmount * amountIn) / makerPSMData.fromAmount;

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.17;
 
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "./OKXScaleHelper.sol";
 import "./ParaswapScaleHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
@@ -33,11 +33,10 @@ contract PendleSwap is
 
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
         _approveForExtRouter(tokenIn, data);
-        data.extRouter
-            .functionCallWithValue(
-                data.needScale ? _getScaledInputData(data.swapType, data.extCalldata, amountIn) : data.extCalldata,
-                tokenIn == NATIVE ? amountIn : 0
-            );
+        data.extRouter.functionCallWithValue(
+            data.needScale ? _getScaledInputData(data.swapType, data.extCalldata, amountIn) : data.extCalldata,
+            tokenIn == NATIVE ? amountIn : 0
+        );
 
         emit SwapSingle(data.swapType, tokenIn, amountIn);
     }
@@ -58,15 +57,17 @@ contract PendleSwap is
         }
     }
 
-    function _getScaledInputData(SwapType swapType, bytes calldata rawCallData, uint256 amountIn)
-        internal
-        view
-        returns (bytes memory scaledCallData)
-    {
+    function _getScaledInputData(
+        SwapType swapType,
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal view returns (bytes memory scaledCallData) {
         if (swapType == SwapType.KYBERSWAP) {
             bool isSuccess;
-            (isSuccess, scaledCallData) =
-                IKyberScalingHelper(KYBER_SCALING_HELPER).getScaledInputData(rawCallData, amountIn);
+            (isSuccess, scaledCallData) = IKyberScalingHelper(KYBER_SCALING_HELPER).getScaledInputData(
+                rawCallData,
+                amountIn
+            );
 
             require(isSuccess, "PendleSwap: Kyber scaling failed");
         } else if (swapType == SwapType.ODOS) {
@@ -80,11 +81,10 @@ contract PendleSwap is
         }
     }
 
-    function _odosScaling(bytes calldata rawCallData, uint256 amountIn)
-        internal
-        pure
-        returns (bytes memory scaledCallData)
-    {
+    function _odosScaling(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure returns (bytes memory scaledCallData) {
         bytes4 selector = bytes4(rawCallData[:4]);
         bytes calldata dataToDecode = rawCallData[4:];
 
@@ -109,10 +109,10 @@ contract PendleSwap is
 }
 
 interface IKyberScalingHelper {
-    function getScaledInputData(bytes calldata inputData, uint256 newAmount)
-        external
-        view
-        returns (bool isSuccess, bytes memory data);
+    function getScaledInputData(
+        bytes calldata inputData,
+        uint256 newAmount
+    ) external view returns (bool isSuccess, bytes memory data);
 }
 
 interface IOdosRouterV2 {
@@ -126,8 +126,10 @@ interface IOdosRouterV2 {
         address outputReceiver;
     }
 
-    function swap(swapTokenInfo memory tokenInfo, bytes calldata pathDefinition, address executor, uint32 referralCode)
-        external
-        payable
-        returns (uint256 amountOut);
+    function swap(
+        swapTokenInfo memory tokenInfo,
+        bytes calldata pathDefinition,
+        address executor,
+        uint32 referralCode
+    ) external payable returns (uint256 amountOut);
 }

package/deployments/1-core.json

@@ -68,5 +68,6 @@
     "cross-chain": {
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
-    }
+    },
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
 }

package/deployments/1-offchain-helper.json

@@ -7,6 +7,5 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
 }

package/deployments/10-core.json

@@ -64,5 +64,6 @@
     "cross-chain": {
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x45Dd4aEcc425b01bf98C567407aB4a4fF3C7d349"
-    }
+    },
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
 }

package/deployments/10-offchain-helper.json

@@ -6,6 +6,5 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
 }

package/deployments/146-core.json

@@ -55,5 +55,6 @@
     "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
     "cross-chain": {
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
-    }
+    },
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
 }

package/deployments/146-offchain-helper.json

@@ -6,6 +6,5 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x21332dCAe68b603B9170d25D21fda68f18Da91df",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
 }

package/deployments/42161-core.json

@@ -65,5 +65,6 @@
     "cross-chain": {
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x4F215b3F8a6E056Ff293E6818F3f501B5F4787D7"
-    }
+    },
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
 }

package/deployments/42161-offchain-helper.json

@@ -7,6 +7,5 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
 }