@pendle/core-v2 5.4.3 → 5.4.4-beta-okx-1

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

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../core/libraries/TokenHelper.sol";
+import "./IPSwapAggregator.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract OKXScaleHelper {
+    function _okx_getTokenApprove() internal view returns (address) {
+        if (block.chainid == 1) {
+            return 0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f;
+        }
+        if (block.chainid == 10) {
+            return 0x68D6B739D2020067D1e2F713b999dA97E4d54812;
+        }
+        if (block.chainid == 56) {
+            return 0x2c34A2Fb1d0b4f55de51E1d0bDEfaDDce6b7cDD6;
+        }
+        if (block.chainid == 42161) {
+            return 0x70cBb871E8f30Fc8Ce23609E9E0Ea87B6b222F58;
+        }
+        if (block.chainid == 8453) {
+            return 0x57df6092665eb6058DE53939612413ff4B09114E;
+        }
+        if (block.chainid == 5000) {
+            return 0x57df6092665eb6058DE53939612413ff4B09114E;
+        }
+
+        revert("PendleSwap: OKX Chain not supported");
+    }
+
+    function _okxScaling(
+        bytes calldata rawCallData,
+        uint256 actualAmount
+    ) internal pure returns (bytes memory scaledCallData) {
+        bytes4 selector = bytes4(rawCallData[:4]);
+        bytes calldata dataToDecode = rawCallData[4:];
+
+        if (selector == IOKXDexRouter.uniswapV3SwapTo.selector) {
+            (uint256 receiver, uint256 amount, uint256 minReturn, uint256[] memory pools) = abi.decode(
+                dataToDecode,
+                (uint256, uint256, uint256, uint256[])
+            );
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, receiver, amount, minReturn, pools);
+        } else if (selector == IOKXDexRouter.smartSwapTo.selector) {
+            (
+                uint256 orderId,
+                address receiver,
+                IOKXDexRouter.BaseRequest memory baseRequest,
+                uint256[] memory batchesAmount,
+                IOKXDexRouter.RouterPath[][] memory batches,
+                IOKXDexRouter.PMMSwapRequest[] memory extraData
+            ) = abi.decode(
+                    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;
+
+            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[]));
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            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[])
+            );
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, srcToken, amount, minReturn, pools);
+        } else if (selector == IOKXDexRouter.smartSwapByOrderId.selector) {
+            (
+                uint256 orderId,
+                IOKXDexRouter.BaseRequest memory baseRequest,
+                uint256[] memory batchesAmount,
+                IOKXDexRouter.RouterPath[][] memory batches,
+                IOKXDexRouter.PMMSwapRequest[] memory extraData
+            ) = abi.decode(
+                    dataToDecode,
+                    (
+                        uint256,
+                        IOKXDexRouter.BaseRequest,
+                        uint256[],
+                        IOKXDexRouter.RouterPath[][],
+                        IOKXDexRouter.PMMSwapRequest[]
+                    )
+                );
+
+            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);
+        } else {
+            revert("PendleSwap: OKX selector not supported");
+        }
+    }
+
+    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;
+        }
+    }
+}
+
+interface IOKXDexRouter {
+    struct BaseRequest {
+        uint256 fromToken;
+        address toToken;
+        uint256 fromTokenAmount;
+        uint256 minReturnAmount;
+        uint256 deadLine;
+    }
+
+    struct RouterPath {
+        address[] mixAdapters;
+        address[] assetTo;
+        uint256[] rawData;
+        bytes[] extraData;
+        uint256 fromToken;
+    }
+
+    struct PMMSwapRequest {
+        uint256 pathIndex;
+        address payer;
+        address fromToken;
+        address toToken;
+        uint256 fromTokenAmountMax;
+        uint256 toTokenAmountMax;
+        uint256 salt;
+        uint256 deadLine;
+        bool isPushOrder;
+        bytes extension;
+    }
+
+    // // address marketMaker;
+    // // uint256 subIndex;
+    // // bytes signature;
+    // // uint256 source;  1byte type + 1byte bool（reverse） + 0...0 + 20 bytes address
+
+    // function smartSwapByInvest(
+    //     BaseRequest calldata baseRequest,
+    //     uint256[] calldata batchesAmount,
+    //     RouterPath[][] calldata batches,
+    //     PMMSwapRequest[] calldata extraData,
+    //     address to
+    // ) external payable;
+
+    function uniswapV3SwapTo(
+        uint256 receiver,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns (uint256 returnAmount);
+
+    function smartSwapTo(
+        uint256 orderId,
+        address receiver,
+        BaseRequest calldata baseRequest,
+        uint256[] calldata batchesAmount,
+        RouterPath[][] calldata batches,
+        PMMSwapRequest[] calldata extraData
+    ) external payable;
+
+    function unxswapTo(
+        uint256 srcToken,
+        uint256 amount,
+        uint256 minReturn,
+        address receiver,
+        // solhint-disable-next-line no-unused-vars
+        bytes32[] calldata pools
+    ) external payable returns (uint256 returnAmount);
+
+    function unxswapByOrderId(
+        uint256 srcToken,
+        uint256 amount,
+        uint256 minReturn,
+        // solhint-disable-next-line no-unused-vars
+        bytes32[] calldata pools
+    ) external payable returns (uint256 returnAmount);
+
+    function smartSwapByOrderId(
+        uint256 orderId,
+        BaseRequest calldata baseRequest,
+        uint256[] calldata batchesAmount,
+        RouterPath[][] calldata batches,
+        PMMSwapRequest[] calldata extraData
+    ) external payable returns (uint256 returnAmount);
+}

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

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface I1inchCommonType {
+    type Address256 is uint256;
+}
+
+abstract contract OneInchScaleHelper is I1inchCommonType {
+    function _rescaleMinAmount(
+        uint256 minAmount,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (uint256) {
+        return (minAmount * newAmount) / oldAmount;
+    }
+
+    function _oneInchScaling(bytes calldata rawCallData, uint256 actualAmount) internal pure returns (bytes memory) {
+        bytes4 selector = bytes4(rawCallData[:4]);
+        bytes memory args = rawCallData[4:];
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo.selector) {
+            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex) = abi.decode(
+                args,
+                (Address256, Address256, uint256, uint256, Address256)
+            );
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex);
+        }
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo2.selector) {
+            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex, Address256 dex2) = abi
+                .decode(args, (Address256, Address256, uint256, uint256, Address256, Address256));
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2);
+        }
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo3.selector) {
+            (
+                Address256 to,
+                Address256 token,
+                uint256 amount,
+                uint256 minReturn,
+                Address256 dex,
+                Address256 dex2,
+                Address256 dex3
+            ) = abi.decode(args, (Address256, Address256, uint256, uint256, Address256, Address256, Address256));
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2, dex3);
+        }
+
+        if (selector == I1inchAggregationRouterV6.swap.selector) {
+            (address executor, I1inchAggregationRouterV6.SwapDescription memory desc, bytes memory data) = abi.decode(
+                args,
+                (address, I1inchAggregationRouterV6.SwapDescription, bytes)
+            );
+
+            desc.minReturnAmount = (desc.minReturnAmount * actualAmount) / desc.amount;
+            desc.amount = actualAmount;
+            return abi.encodeWithSelector(selector, executor, desc, data);
+        }
+
+        revert("1inch: unsupported selector");
+    }
+}
+
+interface I1inchAggregationRouterV6 is I1inchCommonType {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    // we ignore the non-to version since it's guarantee this contract won't receive tokens
+
+    function unoswapTo(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex
+    ) external returns (uint256 returnAmount);
+
+    function unoswapTo2(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex,
+        Address256 dex2
+    ) external returns (uint256 returnAmount);
+
+    function unoswapTo3(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex,
+        Address256 dex2,
+        Address256 dex3
+    ) external returns (uint256 returnAmount);
+
+    function swap(
+        address executor,
+        SwapDescription calldata desc,
+        bytes calldata data
+    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
+}

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

@@ -3,14 +3,18 @@ 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 "./OneInchScaleHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper {
+contract PendleSwap is IPSwapAggregator, TokenHelper, OKXScaleHelper, OneInchScaleHelper {
     using Address for address;
+    using SafeERC20 for IERC20;
 
-    address public immutable KYBER_SCALING_HELPER = 0x2f577A41BeC1BE1152AeEA12e73b7391d15f655D;
+    address private constant KYBER_SCALING_HELPER = 0x2f577A41BeC1BE1152AeEA12e73b7391d15f655D;
 
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
-        _safeApproveInf(tokenIn, data.extRouter);
+        _approveForExtRouter(tokenIn, data);
         data.extRouter.functionCallWithValue(
             data.needScale ? _getScaledInputData(data.swapType, data.extCalldata, amountIn) : data.extCalldata,
             tokenIn == NATIVE ? amountIn : 0
@@ -19,11 +23,20 @@ contract PendleSwap is IPSwapAggregator, TokenHelper {
         emit SwapSingle(data.swapType, tokenIn, amountIn);
     }
 
-    function swapMultiOdos(address[] calldata tokensIn, SwapData calldata data) external payable {
-        for (uint256 i = 0; i < tokensIn.length; ++i) {
-            _safeApproveInf(tokensIn[i], data.extRouter);
+    function _approveForExtRouter(address token, SwapData calldata data) internal {
+        if (token == NATIVE) return;
+
+        if (data.swapType == SwapType.OKX) {
+            _safeApproveInfV2(IERC20(token), _okx_getTokenApprove());
+        } else {
+            _safeApproveInfV2(IERC20(token), data.extRouter);
+        }
+    }
+
+    function _safeApproveInfV2(IERC20 token, address spender) internal {
+        if (token.allowance(address(this), spender) < type(uint256).max) {
+            token.forceApprove(spender, type(uint256).max);
         }
-        data.extRouter.functionCallWithValue(data.extCalldata, msg.value);
     }
 
     function _getScaledInputData(
@@ -41,6 +54,10 @@ contract PendleSwap is IPSwapAggregator, TokenHelper {
             require(isSuccess, "PendleSwap: Kyber scaling failed");
         } else if (swapType == SwapType.ODOS) {
             scaledCallData = _odosScaling(rawCallData, amountIn);
+        } else if (swapType == SwapType.OKX) {
+            scaledCallData = _okxScaling(rawCallData, amountIn);
+        } else if (swapType == SwapType.ONE_INCH) {
+            scaledCallData = _oneInchScaling(rawCallData, amountIn);
         } else {
             assert(false);
         }

package/deployments/1-core.json

@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",

package/deployments/10-core.json

@@ -30,7 +30,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xfa6B22FC4c3Ad88B68c16b3061a16b1714F6Bd57",
     "marketFactoryV3": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",

package/deployments/42161-core.json

@@ -30,7 +30,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",
     "marketFactoryV3": "0x2FCb47B58350cD377f94d3821e7373Df60bD9Ced",

package/deployments/5000-core.json

@@ -28,7 +28,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x964840644B88C583500F473E4B829Ab629aF96A8",
     "marketFactoryV3": "0xD228EC1f7D4313fe321fab511A872475D07F5bA6",

package/deployments/56-core.json

@@ -30,7 +30,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x40Ae6da2d92aa3DCb7f8d7a7209FD12BDfcb7C85",
     "marketFactoryV3": "0xC40fEbF5A33b8C92B187d9be0fD3fe0ac2E4B07c",

package/deployments/8453-core.json

@@ -30,7 +30,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
-    "pendleSwap": "0x7aE5C4Cf5CddFbda870a80D021997d8A04f4Ff11",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "receiverEndpoint": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",

package/package.json

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