@pendle/core-v2 6.3.0-fee-setter → 6.3.0-sweedtest

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

@@ -7,6 +7,11 @@ 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.
@@ -28,7 +33,7 @@ abstract contract OKXScaleHelper {
         if (chainid == 56) {
             return 0x2c34A2Fb1d0b4f55de51E1d0bDEfaDDce6b7cDD6;
         }
-        if (chainid == 42161) {
+        if (chainid == 42_161) {
             return 0x70cBb871E8f30Fc8Ce23609E9E0Ea87B6b222F58;
         }
         if (chainid == 8453 || chainid == 5000) {
@@ -48,23 +53,22 @@ 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[])
-            );
-
+            (uint256 receiver, uint256 amount, uint256 minReturn, uint256[] memory pools) =
+                abi.decode(dataToDecode, (uint256, uint256, uint256, uint256[]));
+            rawAmountIn = amount;
             minReturn = (minReturn * actualAmount) / amount;
             amount = actualAmount;
 
-            return abi.encodeWithSelector(selector, receiver, amount, minReturn, pools);
+            scaledCallData = abi.encodeWithSelector(selector, receiver, amount, minReturn, pools);
         } else if (selector == IOKXDexRouter.smartSwapTo.selector) {
             (
                 uint256 orderId,
@@ -74,40 +78,41 @@ abstract contract OKXScaleHelper {
                 IOKXDexRouter.RouterPath[][] memory batches,
                 IOKXDexRouter.PMMSwapRequest[] memory extraData
             ) = abi.decode(
-                    dataToDecode,
-                    (
-                        uint256,
-                        address,
-                        IOKXDexRouter.BaseRequest,
-                        uint256[],
-                        IOKXDexRouter.RouterPath[][],
-                        IOKXDexRouter.PMMSwapRequest[]
-                    )
-                );
-
+                dataToDecode,
+                (
+                    uint256,
+                    address,
+                    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;
 
-            return abi.encodeWithSelector(selector, orderId, receiver, baseRequest, batchesAmount, batches, extraData);
+            scaledCallData =
+                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;
 
-            return abi.encodeWithSelector(selector, srcToken, amount, minReturn, receiver, pools);
+            scaledCallData = 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[])
-            );
+            (uint256 srcToken, uint256 amount, uint256 minReturn, bytes32[] memory pools) =
+                abi.decode(dataToDecode, (uint256, uint256, uint256, bytes32[]));
+            rawAmountIn = amount;
 
             minReturn = (minReturn * actualAmount) / amount;
             amount = actualAmount;
 
-            return abi.encodeWithSelector(selector, srcToken, amount, minReturn, pools);
+            scaledCallData = abi.encodeWithSelector(selector, srcToken, amount, minReturn, pools);
         } else if (selector == IOKXDexRouter.smartSwapByOrderId.selector) {
             (
                 uint256 orderId,
@@ -116,39 +121,159 @@ abstract contract OKXScaleHelper {
                 IOKXDexRouter.RouterPath[][] memory batches,
                 IOKXDexRouter.PMMSwapRequest[] memory extraData
             ) = abi.decode(
-                    dataToDecode,
-                    (
-                        uint256,
-                        IOKXDexRouter.BaseRequest,
-                        uint256[],
-                        IOKXDexRouter.RouterPath[][],
-                        IOKXDexRouter.PMMSwapRequest[]
-                    )
-                );
-
+                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;
 
-            return abi.encodeWithSelector(selector, orderId, baseRequest, batchesAmount, batches, extraData);
+            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;
+
+            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;
+            baseRequest.minReturnAmount = (baseRequest.minReturnAmount * actualAmount) / baseRequest.fromTokenAmount;
+            baseRequest.fromTokenAmount = actualAmount;
+
+            scaledCallData = abi.encodeWithSelector(selector, orderId, baseRequest, paths);
         } 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;
@@ -191,12 +316,10 @@ 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,
@@ -222,7 +345,10 @@ 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,
@@ -231,4 +357,14 @@ 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,11 +36,10 @@ 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 {
@@ -54,11 +53,10 @@ 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 {
@@ -89,11 +87,10 @@ 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 {
@@ -110,11 +107,10 @@ 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 {
@@ -130,17 +126,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:];
 
@@ -163,10 +159,8 @@ 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;
@@ -177,10 +171,8 @@ 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;
@@ -207,10 +199,8 @@ 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;
@@ -221,10 +211,8 @@ 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;
@@ -235,10 +223,8 @@ 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,10 +33,11 @@ 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);
     }
@@ -57,17 +58,15 @@ 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) {
@@ -81,10 +80,11 @@ 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,10 +126,8 @@ 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

@@ -33,13 +33,15 @@
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
-    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
+    "pyYtLpOracle": "0x5542be50420E88dd7D5B4a3D488FA6ED82F6DAc2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
     "yieldContractFactoryV4": "0x273b4bFA3Bb30fe8F32c467b5f0046834557F072",
     "marketFactoryV4": "0x3d75Bd20C983edb5fD218A1b7e0024F1056c7A2F",
     "yieldContractFactoryV5": "0x35A338522a435D46f77Be32C70E215B813D0e3aC",
     "marketFactoryV5": "0x6fcf753f2C67b83f7B09746Bbc4FA0047b35D050",
+    "yieldContractFactoryV6": "0x3E6EBa46AbC5ab18ED95F6667d8B2fd4020E4637",
+    "marketFactoryV6": "0x6d247b1c044fA1E22e6B04fA9F71Baf99EB29A9f",
     "poolDeployHelper": "0x4Df98410c95737FD646D2413AC6CAFc1c04834b9",
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
@@ -50,7 +52,8 @@
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
     "experimental": {
         "PendleChainlinkOracleFactory": "0x9E5129dcC15d39625617DcD7F0F44FB0BB957FFd",
-        "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579"
+        "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579",
+        "MarketSweed": "0x606adeDea906017E059283382B3072Dc58131835"
     },
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",

package/deployments/10-core.json

@@ -32,13 +32,15 @@
     },
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
     "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
-    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
+    "pyYtLpOracle": "0x5542be50420E88dd7D5B4a3D488FA6ED82F6DAc2",
     "yieldContractFactoryV3": "0xfa6B22FC4c3Ad88B68c16b3061a16b1714F6Bd57",
     "marketFactoryV3": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",
     "yieldContractFactoryV4": "0xf799E4c029d14f41Dc1918C9A4C67242F565710e",
     "marketFactoryV4": "0x73Be47237F12F36203823BAc9A4d80dC798B7015",
     "yieldContractFactoryV5": "0xCcA0977eA3809C8fB785737Eb9fAcD5B19626e81",
     "marketFactoryV5": "0x02Adf72d5D06a9C92136562Eb237C07696833a84",
+    "marketFactoryV6": "0x95a937f7064C75C6Bc257160088C0a9D58cca333",
+    "yieldContractFactoryV6": "0x2bA5e078b1fF6f1AB02a3B4462F3Be6E950E60e8",
     "poolDeployHelper": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
@@ -50,7 +52,8 @@
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
     "experimental": {
         "PendleChainlinkOracleFactory": "0x2A73e899389cABa2a2f648BaBA35e67f5C00EFee",
-        "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579"
+        "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579",
+        "MarketSweed": "0x606adeDea906017E059283382B3072Dc58131835"
     },
     "receiverEndpoint": "0xED18de5442297a4Ec1ce59C7c7d9427Adc2A012b",
     "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18",