@pendle/core-v2 0.21.0-testnet → 1.0.0-testnet

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,30 @@
+// 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 {
+    struct MultiApproval {
+        address[] tokens;
+        address spender;
+    }
+
+    function swap(
+        address tokenIn,
+        uint256 amountIn,
+        SwapData calldata swapData
+    ) external payable;
+}

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

@@ -0,0 +1,63 @@
+// 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);
+        }
+    }
+
+    /// @notice For the Aggregator to work with a token / aggregator, it must be approved first
+    function approveInf(MultiApproval[] calldata arr) external {
+        for (uint256 i = 0; i < arr.length; ) {
+            MultiApproval calldata ele = arr[i];
+            for (uint256 j = 0; j < ele.tokens.length; ) {
+                _safeApproveInf(ele.tokens[j], ele.spender);
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+}

package/contracts/router/{kyberswap/AggregationRouterHelper.sol → swap-aggregator/kyberswap/KyberAggregationRouterHelper.sol}

@@ -1,25 +1,12 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
-
-import "../../interfaces/IWETH.sol";
-
-import "./interfaces/IMetaAggregationRouter.sol";
 import "./interfaces/IMetaAggregationRouterV2.sol";
 import "./interfaces/IHashflow.sol";
 import "./interfaces/IExecutorHelperEthereum1.sol";
-
-import "./IAggregatorRouterHelper.sol";
 import "./ScaleDataHelperEthereum1.sol";
 
-contract AggregationRouterHelper is
-    IAggregationRouterHelper,
-    Initializable,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable
-{
+abstract contract KyberAggregationRouterHelper {
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
     uint256 private constant _SHOULD_CLAIM = 0x04;
@@ -27,14 +14,6 @@ contract AggregationRouterHelper is
     uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
     uint256 private constant _SIMPLE_SWAP = 0x20;
 
-    constructor() initializer {}
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-
     struct Swap {
         bytes data;
         bytes4 selector;
@@ -58,45 +37,13 @@ contract AggregationRouterHelper is
         bytes destTokenFeeData;
     }
 
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
+    function _getKyberScaledInputData(bytes calldata kybercall, uint256 newAmount)
+        internal
         pure
         returns (bytes memory)
     {
         bytes4 selector = bytes4(kybercall[:4]);
 
-        if (selector == IWETH.deposit.selector) {
-            return kybercall; // no scaling needed
-        }
-
-        if (selector == IWETH.withdraw.selector) {
-            return abi.encodeWithSelector(selector, newAmount);
-        }
-
-        if (
-            selector == IMetaAggregationRouter.swap.selector ||
-            selector == IMetaAggregationRouter.swapSimpleMode.selector
-        ) {
-            (
-                address callTarget,
-                IMetaAggregationRouter.SwapDescription memory desc,
-                bytes memory targetData,
-                bytes memory clientData
-            ) = abi.decode(
-                    kybercall[4:],
-                    (address, IMetaAggregationRouter.SwapDescription, bytes, bytes)
-                );
-
-            (desc, targetData) = _getScaledInputDataV1(
-                desc,
-                targetData,
-                newAmount,
-                selector == IMetaAggregationRouter.swapSimpleMode.selector ||
-                    _flagsChecked(desc.flags, _SIMPLE_SWAP)
-            );
-            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
-        }
-
         if (selector == IMetaAggregationRouterV2.swap.selector) {
             IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
                 kybercall[4:],
@@ -130,32 +77,6 @@ contract AggregationRouterHelper is
         revert("InputScalingHelper: Invalid selector");
     }
 
-    function _getScaledInputDataV1(
-        IMetaAggregationRouter.SwapDescription memory desc,
-        bytes memory executorData,
-        uint256 newAmount,
-        bool isSimpleMode
-    ) internal pure returns (IMetaAggregationRouter.SwapDescription memory, bytes memory) {
-        uint256 oldAmount = desc.amount;
-        if (oldAmount == newAmount) {
-            return (desc, executorData);
-        }
-
-        // simple mode swap
-        if (isSimpleMode) {
-            return (
-                _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
-                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
-            );
-        }
-
-        //normal mode swap
-        return (
-            _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
-            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
-        );
-    }
-
     function _getScaledInputDataV2(
         IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
         bytes memory executorData,
@@ -182,32 +103,6 @@ contract AggregationRouterHelper is
         );
     }
 
-    function _scaledSwapDescriptionV1(
-        IMetaAggregationRouter.SwapDescription memory desc,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (IMetaAggregationRouter.SwapDescription 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 _scaledSimpleSwapData(
         bytes memory data,
         uint256 oldAmount,

package/deployments/43113-core.json

@@ -19,7 +19,8 @@
     "marketFactory": "0x24265d37C87d3ffE64D6B0274c168945d44D1ba2",
     "bulkSellerFactory": "0x137404E334a80fa741AD03d8965ee4b5b8A20259",
     "bulkSellerOffchain": "0x85C369B1aD9A981DCf4Fd8F00F74cB783cacec34",
-    "router": "0x17ae363f142517b593d9A71282BAb8CA6bb4eA51",
+    "router": "0xFC0F1237961A6ecEacAC86aD407e181Ecd5e673C",
+    "pendleSwap": "0xc6404511EF2C4C05A15446aF7D54FB63AFbe4d47",
     "routerStatic": "0xBf98D54D05907f3F576602e8Be7fEaF8891c787F",
     "vePendle": "0xB20E3c268C993BC3c9Bc1C1cc5D7491F2268cD91",
     "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",

package/deployments/80001-core.json

@@ -20,7 +20,8 @@
     "marketFactory": "0xeB2AEd0aE414c76e4f9D4d43cD01064Fec010dfB",
     "bulkSellerFactory": "0x4707f0CC2Ad4211172EdBAFc453E60DBd1C9D854",
     "bulkSellerOffchain": "0x7Fb3626D95449d69f991a37e304b8C9A0a5D0e0c",
-    "router": "0x5141Ad90AafB0D45e9F19Bd9F861362d56f2CF79",
+    "router": "0x53FE536228e70cfb2e8C6Fa38D344a57be797237",
+    "pendleSwap": "0xFee829Cf47c28b8d81cD9035a05320a51595dB42",
     "routerStatic": "0xc7F8F9F1DdE1104664b6fC8F33E49b169C12F41E",
     "receiverEndpoint": "0x256752c851EDB92c97377C93232A9034c835F376",
     "vePendle": "0xC0BC61112D9fD7bA5809047a86EC245593BA0e1E",

package/deployments/80001-markets/GLP-DEC-8TH.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY GLP",
+    "SY": "0x1A2775c9bEe6e798De971c369849CF9130D3e25a",
+    "YT": "0x77F02e40d08eB6d368401b5EaF5500F992b27cC2",
+    "PT": "0xC4d7D9881c6b4e87E1325F06A56d6abB675998b9",
+    "market": "0xB08e72153925ccEc1B43b0d9BF2E1c57eea5E2AB",
+    "expiry": 1701993600,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.21.0-testnet",
+  "version": "1.0.0-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",