@pendle/core-v2 1.3.0-mainnet → 2.0.0-mainnet

package/contracts/router/swap-aggregator/1inch/I1inchAggregationRouterV5.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+interface I1inchAggregationRouterV5 {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    function uniswapV3SwapTo(
+        address payable recipient,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) 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
+        );
+
+    function unoswapTo(
+        address payable recipient,
+        address srcToken,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns(uint256 returnAmount);
+}

package/contracts/router/swap-aggregator/1inch/OneInchAggregationRouterHelper.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "./I1inchAggregationRouterV5.sol";
+import "../../../core/libraries/Errors.sol";
+
+abstract contract OneInchAggregationRouterHelper {
+    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)
+    {
+        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[]));
+
+            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
+        }
+
+        if (selector == I1inchAggregationRouterV5.swap.selector) {
+            (
+                address executor,
+                I1inchAggregationRouterV5.SwapDescription memory desc,
+                bytes memory permit,
+                bytes memory data
+            ) = abi.decode(
+                    args,
+                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
+                );
+
+            desc.minReturnAmount = _rescaleMinAmount(desc.minReturnAmount, desc.amount, newAmount);
+            desc.amount = newAmount;
+            return abi.encodeWithSelector(selector, executor, desc, permit, data);
+        }
+
+        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[]));
+
+            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
+        }
+        revert Errors.UnsupportedSelector(1, selector);
+    }
+}

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

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+struct SwapData {
+    SwapType swapType;
+    address extRouter;
+    bytes extCalldata;
+    bool needScale;
+}
+
+enum SwapType {
+    NONE,
+    KYBERSWAP,
+    ONE_INCH,
+    // ETH_WETH not used in Aggregator
+    ETH_WETH
+}
+
+interface IPSwapAggregator {
+    function swap(
+        address tokenIn,
+        uint256 amountIn,
+        SwapData calldata swapData
+    ) external payable;
+}

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

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import "../../interfaces/IWETH.sol";
+import "../../core/libraries/TokenHelper.sol";
+import "../../core/libraries/Errors.sol";
+import "./IPSwapAggregator.sol";
+import "./1inch/OneInchAggregationRouterHelper.sol";
+import "./kyberswap/KyberAggregationRouterHelper.sol";
+
+contract PendleSwapAggregator is
+    IPSwapAggregator,
+    TokenHelper,
+    KyberAggregationRouterHelper,
+    OneInchAggregationRouterHelper
+{
+    using Address for address;
+
+    function swap(
+        address tokenIn,
+        uint256 amountIn,
+        SwapData calldata data
+    ) external payable {
+        _safeApproveInf(tokenIn, data.extRouter);
+        data.extRouter.functionCallWithValue(
+            data.needScale
+                ? _getScaledInputData(data.swapType, data.extCalldata, amountIn)
+                : data.extCalldata,
+            tokenIn == NATIVE ? amountIn : 0
+        );
+    }
+
+    function _getScaledInputData(
+        SwapType swapType,
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure returns (bytes memory scaledCallData) {
+        if (swapType == SwapType.KYBERSWAP) {
+            scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
+        } else if (swapType == SwapType.ONE_INCH) {
+            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
+        } else {
+            assert(false);
+        }
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/KyberAggregationRouterHelper.sol

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+import "./interfaces/IMetaAggregationRouterV2.sol";
+import "./interfaces/IHashflow.sol";
+import "./interfaces/IExecutorHelperEthereum1.sol";
+import "./ScaleDataHelperEthereum1.sol";
+
+abstract contract KyberAggregationRouterHelper {
+    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 Swap {
+        bytes data;
+        bytes4 selector;
+    }
+
+    struct SimpleSwapData {
+        address[] firstPools;
+        uint256[] firstSwapAmounts;
+        bytes[] swapDatas;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    function _getKyberScaledInputData(bytes calldata kybercall, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        bytes4 selector = bytes4(kybercall[:4]);
+
+        if (selector == IMetaAggregationRouterV2.swap.selector) {
+            IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
+                kybercall[4:],
+                (IMetaAggregationRouterV2.SwapExecutionParams)
+            );
+
+            (params.desc, params.targetData) = _getScaledInputDataV2(
+                params.desc,
+                params.targetData,
+                newAmount,
+                _flagsChecked(params.desc.flags, _SIMPLE_SWAP)
+            );
+            return abi.encodeWithSelector(selector, params);
+        }
+
+        if (selector == IMetaAggregationRouterV2.swapSimpleMode.selector) {
+            (
+                address callTarget,
+                IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+                bytes memory targetData,
+                bytes memory clientData
+            ) = abi.decode(
+                    kybercall[4:],
+                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
+                );
+
+            (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
+            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
+        }
+
+        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)
+        );
+    }
+
+    function _scaledSimpleSwapData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
+        uint256 numberSeq = swapData.firstPools.length;
+        uint256 newTotalSwapAmount;
+        for (uint256 i = 0; i < numberSeq; i++) {
+            if (i == numberSeq - 1) {
+                swapData.firstSwapAmounts[i] = newAmount - newTotalSwapAmount;
+            } else {
+                swapData.firstSwapAmounts[i] =
+                    (swapData.firstSwapAmounts[i] * newAmount) /
+                    oldAmount;
+            }
+            newTotalSwapAmount += swapData.firstSwapAmounts[i];
+        }
+        return abi.encode(swapData);
+    }
+
+    function _scaledExecutorCallBytesData(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
+        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
+        for (uint256 i = 0; i < executorDesc.swapSequences.length; i++) {
+            Swap memory swap = executorDesc.swapSequences[i][0];
+            bytes4 selector = swap.selector;
+
+            if (selector == IExecutorHelperEthereum1.executeUniSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newUniSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeStableSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newStableSwap(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeCurveSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newCurveSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeKyberDMMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newKyberDMM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeUniV3ProMMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newUniV3ProMM(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeRfqSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (selector == IExecutorHelperEthereum1.executeBalV2Swap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newBalancerV2(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeDODOSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newDODO(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeWrappedstETHSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newWrappedstETHSwap(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeSynthetixSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newSynthetix(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executePSMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newPSM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeHashflowSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (selector == IExecutorHelperEthereum1.executeFraxSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newFrax(swap.data, oldAmount, newAmount);
+            } else revert("AggregationExecutor: Dex type not supported");
+        }
+        return abi.encode(executorDesc);
+    }
+
+    function _scaledSwapDescriptionV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory) {
+        uint256 oldMinReturnAmount = desc.minReturnAmount;
+        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
+        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
+        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
+        desc.amount = newAmount;
+        if (desc.srcReceivers.length == 0) {
+            return desc;
+        }
+
+        uint256 newTotal;
+        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
+            if (i == desc.srcReceivers.length - 1) {
+                desc.srcAmounts[i] = newAmount - newTotal;
+            } else {
+                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
+            }
+            newTotal += desc.srcAmounts[i];
+        }
+        return desc;
+    }
+
+    function _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
+        return number & flag != 0;
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/ScaleDataHelperEthereum1.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./interfaces/IExecutorHelperEthereum1.sol";
+
+library ScaleDataHelperEthereum1 {
+    function newUniSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwap memory uniSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwap)
+        );
+        uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
+        return abi.encode(uniSwap);
+    }
+
+    function newStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.StableSwap memory stableSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.StableSwap)
+        );
+        stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
+        return abi.encode(stableSwap);
+    }
+
+    function newCurveSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.CurveSwap memory curveSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.CurveSwap)
+        );
+        curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
+        return abi.encode(curveSwap);
+    }
+
+    function newKyberDMM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwap memory kyberDMMSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwap)
+        );
+        kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
+        return abi.encode(kyberDMMSwap);
+    }
+
+    function newUniV3ProMM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwapV3ProMM)
+        );
+        uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
+
+        return abi.encode(uniSwapV3ProMM);
+    }
+
+    function newBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.BalancerV2 memory balancerV2 = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.BalancerV2)
+        );
+        balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
+        return abi.encode(balancerV2);
+    }
+
+    function newDODO(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.DODO memory dodo = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.DODO)
+        );
+        dodo.amount = (dodo.amount * newAmount) / oldAmount;
+        return abi.encode(dodo);
+    }
+
+    function newSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.Synthetix memory synthetix = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.Synthetix)
+        );
+        synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
+        return abi.encode(synthetix);
+    }
+
+    function newWrappedstETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.WSTETH memory wstEthData = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.WSTETH)
+        );
+        wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
+        return abi.encode(wstEthData);
+    }
+
+    function newPSM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.PSM memory psm = abi.decode(data, (IExecutorHelperEthereum1.PSM));
+        psm.amountIn = (psm.amountIn * newAmount) / oldAmount;
+        return abi.encode(psm);
+    }
+
+    function newFrax(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwap memory frax = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwap)
+        );
+        frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
+        return abi.encode(frax);
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/interfaces/IAggregationExecutor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutor {
+  function callBytes(bytes calldata data) external payable; // 0xd9c45357
+
+  // callbytes per swap sequence
+  function swapSingleSequence(bytes calldata data) external;
+
+  function finalTransactionProcessing(
+    address tokenIn,
+    address tokenOut,
+    address to,
+    bytes calldata destTokenFeeData
+  ) external;
+}