@pendle/core-v2 1.4.0-mainnet → 2.0.1-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/{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,
@@ -280,6 +175,8 @@ contract AggregationRouterHelper is
                 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);

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

@@ -131,4 +131,17 @@ library ScaleDataHelperEthereum1 {
         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/{kyberswap → swap-aggregator/kyberswap}/interfaces/IExecutorHelperEthereum1.sol

@@ -182,4 +182,10 @@ interface IExecutorHelperEthereum1 {
         bytes memory data,
         uint256 previousAmountOut
     ) external payable returns (uint256);
+
+    function executeFraxSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
 }

package/deployments/1-core.json

@@ -20,8 +20,9 @@
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
     "bulkSellerFactory": "0x4B1da107B50529d53e5C906a79eaEcDCbC0E1dE3",
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
-    "router": "0x41FAD93F225b5C1C95f2445A5d7fcB85bA46713f",
+    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0xcF45b92cd0B0859FC42a767fAac2354909f937e9",
+    "pendleSwap": "0x9660AC0cB085F8Fb39a6F383cF2067785364f924",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",

package/deployments/1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json

@@ -6,5 +6,6 @@
     "market": "0xFcbAe4635CA89866F83Add208eCcEec742678746",
     "expiry": 1719446400,
     "scalarRoot": "28880000000000000000",
-    "initAnchor": "1105675000000000000"
+    "initAnchor": "1105675000000000000",
+    "bulkSeller": "0xd044Ee6D5dD9E9e4f6E3e81d1DF3ADB8adabAba0"
 }

package/deployments/42161-core.json

@@ -0,0 +1,26 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 42161,
+        "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
+        "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
+        "pendle": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
+        "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
+        "wrappedNative": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "safeWaitTime": 15000
+    },
+    "baseCodeSplitter": "0x29deaEE5413a07C933C15B37d7deB6Eb744Ba9C8",
+    "PENDLE": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
+    "yieldContractFactory": "0x28dE02Ac3c3F5ef427e55c321F73fDc7F192e8E4",
+    "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
+    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
+    "routerStatic": "0x4106FC9811a792130502Bb3A5b693894cca7bD8e",
+    "pendleSwap": "0x0E669e08bd717d7F9c9DE158636BD8561295fbB5",
+    "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
+    "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
+    "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00"
+}

package/deployments/42161-markets/GLP-28MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY GLP",
+    "SY": "0x2066a650AF4b6895f72E618587Aad5e8120B7790",
+    "YT": "0x56051f8e46b67b4d286454995dbc6f5f3c433e34",
+    "PT": "0x96015d0fb97139567a9ba675951816a0bb719e3c",
+    "market": "0x7D49E5Adc0EAAD9C027857767638613253eF125f",
+    "expiry": 1711584000,
+    "scalarRoot": "10484880000000000000",
+    "initAnchor": "1285295000000000000"
+}

package/deployments/42161-offchain-helper.json

@@ -0,0 +1,4 @@
+{
+    "multicall": "0x05d0Ea1dBFA239f9fBC47E306e850Ce971Fe632d",
+    "implicitSwapfeeContract": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0"
+}

package/package.json

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