@pendle/core-v2 0.20.0-testnet → 0.20.2-testnet

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

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./IHashflow.sol";
+
+interface IExecutorHelperEthereum1 {
+    struct UniSwap {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+        uint256 limitReturnAmount;
+        uint32 swapFee;
+        uint32 feePrecision;
+        uint32 tokenWeightInput;
+    }
+
+    struct StableSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint8 tokenIndexFrom;
+        uint8 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        uint256 poolLength;
+        address poolLp;
+        bool isSaddle; // true: saddle, false: stable
+    }
+
+    struct CurveSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        int128 tokenIndexFrom;
+        int128 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        bool usePoolUnderlying;
+        bool useTriCrypto;
+    }
+
+    struct UniSwapV3ProMM {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        uint256 limitReturnAmount;
+        uint160 sqrtPriceLimitX96;
+        bool isUniV3; // true = UniV3, false = ProMM
+    }
+
+    struct BalancerV2 {
+        address vault;
+        bytes32 poolId;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        uint256 limit;
+    }
+
+    struct KyberRFQ {
+        address rfq;
+        bytes order;
+        bytes signature;
+        uint256 amount;
+        address payable target;
+    }
+
+    struct DODO {
+        address recipient;
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint256 amount;
+        uint256 minReceiveQuote;
+        address sellHelper;
+        bool isSellBase;
+        bool isVersion2;
+    }
+
+    struct Synthetix {
+        address synthetixProxy;
+        address tokenIn;
+        address tokenOut;
+        bytes32 sourceCurrencyKey;
+        uint256 sourceAmount;
+        bytes32 destinationCurrencyKey;
+        uint256 minAmount;
+        bool useAtomicExchange;
+    }
+
+    struct PSM {
+        address router;
+        address tokenIn;
+        address tokenOut;
+        uint256 amountIn;
+        address recipient;
+    }
+
+    struct Hashflow {
+        address router;
+        IHashflow.Quote quote;
+    }
+
+    struct WSTETH {
+        address pool;
+        uint256 amount;
+        bool isWrapping;
+    }
+
+    function executeUniSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeStableSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeCurveSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeKyberDMMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeUniV3ProMMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeRfqSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeBalV2Swap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeDODOSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeWrappedstETHSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeSynthetixSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executePSMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeHashflowSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+}

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

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+interface IHashflow {
+    enum RFQType {
+        TAKER,
+        MAKER
+    }
+
+    struct Quote {
+        RFQType rfqType;
+        address pool;
+        address eoa;
+        address trader;
+        address effectiveTrader;
+        address baseToken;
+        address quoteToken;
+        uint256 effectiveBaseTokenAmount;
+        uint256 maxBaseTokenAmount;
+        uint256 maxQuoteTokenAmount;
+        uint256 fees;
+        uint256 quoteExpiry;
+        uint256 nonce;
+        bytes32 txid;
+        bytes signedQuote;
+    }
+
+    function tradeSingleHop(Quote memory quote) external payable;
+}

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

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IAggregationExecutor.sol";
+
+interface IMetaAggregationRouter {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address[] srcReceivers;
+        uint256[] srcAmounts;
+        address dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+        bytes permit;
+    }
+
+    function swap(
+        IAggregationExecutor caller,
+        SwapDescription calldata desc,
+        bytes calldata executorData,
+        bytes calldata clientData
+    ) external payable returns (uint256, uint256);
+
+    function swapSimpleMode(
+        IAggregationExecutor caller,
+        SwapDescription calldata desc,
+        bytes calldata executorData,
+        bytes calldata clientData
+    ) external returns (uint256, uint256);
+}

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

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IAggregationExecutor.sol";
+
+interface IMetaAggregationRouterV2 {
+    struct SwapDescriptionV2 {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address[] srcReceivers; // transfer src token to these addresses, default
+        uint256[] srcAmounts;
+        address[] feeReceivers;
+        uint256[] feeAmounts;
+        address dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+        bytes permit;
+    }
+
+    /// @dev  use for swapGeneric and swap to avoid stack too deep
+    struct SwapExecutionParams {
+        address callTarget; // call this address
+        address approveTarget; // approve this address if _APPROVE_FUND set
+        bytes targetData;
+        SwapDescriptionV2 desc;
+        bytes clientData;
+    }
+
+    function swap(SwapExecutionParams calldata execution)
+        external
+        payable
+        returns (uint256, uint256);
+
+    function swapSimpleMode(
+        IAggregationExecutor caller,
+        SwapDescriptionV2 memory desc,
+        bytes calldata executorData,
+        bytes calldata clientData
+    ) external returns (uint256, uint256);
+}

package/deployments/43113-core.json

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

package/deployments/80001-core.json

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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.20.0-testnet",
+  "version": "0.20.2-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,16 +25,16 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.12.2",
+    "hardhat": "^2.12.5",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-storage-layout-diff": "^0.0.4",
-    "prettier": "^2.7.1",
-    "prettier-plugin-solidity": "^1.0.0-rc.1",
+    "prettier": "^2.8.2",
+    "prettier-plugin-solidity": "^1.1.1",
     "solc": "^0.8.17",
     "solhint": "^3.3.7",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.1",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -42,7 +42,7 @@
     "clean": "yarn hardhat clean",
     "fcompile": "yarn clean && yarn compile"
   },
-  "packageManager": "yarn@3.2.2",
+  "packageManager": "yarn@3.3.1",
   "dependencies": {
     "@openzeppelin/contracts": "4.7.3",
     "@openzeppelin/contracts-upgradeable": "4.7.3"

package/typechain-types/ActionAddRemoveLiq.ts

@@ -23,13 +23,24 @@ import type {
   OnEvent,
 } from "./common";
 
+export type SwapDataStruct = {
+  aggregatorType: BigNumberish;
+  router: string;
+  callData: BytesLike;
+};
+
+export type SwapDataStructOutput = [number, string, string] & {
+  aggregatorType: number;
+  router: string;
+  callData: string;
+};
+
 export type TokenInputStruct = {
   tokenIn: string;
   netTokenIn: BigNumberish;
   tokenMintSy: string;
   bulk: string;
-  kyberRouter: string;
-  kybercall: BytesLike;
+  data: SwapDataStruct;
 };
 
 export type TokenInputStructOutput = [
@@ -37,15 +48,13 @@ export type TokenInputStructOutput = [
   BigNumber,
   string,
   string,
-  string,
-  string
+  SwapDataStructOutput
 ] & {
   tokenIn: string;
   netTokenIn: BigNumber;
   tokenMintSy: string;
   bulk: string;
-  kyberRouter: string;
-  kybercall: string;
+  data: SwapDataStructOutput;
 };
 
 export type ApproxParamsStruct = {
@@ -75,8 +84,7 @@ export type TokenOutputStruct = {
   minTokenOut: BigNumberish;
   tokenRedeemSy: string;
   bulk: string;
-  kyberRouter: string;
-  kybercall: BytesLike;
+  data: SwapDataStruct;
 };
 
 export type TokenOutputStructOutput = [
@@ -84,31 +92,29 @@ export type TokenOutputStructOutput = [
   BigNumber,
   string,
   string,
-  string,
-  string
+  SwapDataStructOutput
 ] & {
   tokenOut: string;
   minTokenOut: BigNumber;
   tokenRedeemSy: string;
   bulk: string;
-  kyberRouter: string;
-  kybercall: string;
+  data: SwapDataStructOutput;
 };
 
 export interface ActionAddRemoveLiqInterface extends utils.Interface {
   contractName: "ActionAddRemoveLiq";
   functions: {
     "addLiquidityDualSyAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
-    "addLiquidityDualTokenAndPt(address,address,(address,uint256,address,address,address,bytes),uint256,uint256)": FunctionFragment;
+    "addLiquidityDualTokenAndPt(address,address,(address,uint256,address,address,(uint8,address,bytes)),uint256,uint256)": FunctionFragment;
     "addLiquiditySinglePt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "addLiquiditySingleSy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "addLiquiditySingleToken(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,address,address,bytes))": FunctionFragment;
-    "kyberScalingLib()": FunctionFragment;
+    "addLiquiditySingleToken(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,address,(uint8,address,bytes)))": FunctionFragment;
     "removeLiquidityDualSyAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
-    "removeLiquidityDualTokenAndPt(address,address,uint256,(address,uint256,address,address,address,bytes),uint256)": FunctionFragment;
+    "removeLiquidityDualTokenAndPt(address,address,uint256,(address,uint256,address,address,(uint8,address,bytes)),uint256)": FunctionFragment;
     "removeLiquiditySinglePt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "removeLiquiditySingleSy(address,address,uint256,uint256)": FunctionFragment;
-    "removeLiquiditySingleToken(address,address,uint256,(address,uint256,address,address,address,bytes))": FunctionFragment;
+    "removeLiquiditySingleToken(address,address,uint256,(address,uint256,address,address,(uint8,address,bytes)))": FunctionFragment;
+    "swapAggregator()": FunctionFragment;
   };
 
   encodeFunctionData(
@@ -131,10 +137,6 @@ export interface ActionAddRemoveLiqInterface extends utils.Interface {
     functionFragment: "addLiquiditySingleToken",
     values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
-  encodeFunctionData(
-    functionFragment: "kyberScalingLib",
-    values?: undefined
-  ): string;
   encodeFunctionData(
     functionFragment: "removeLiquidityDualSyAndPt",
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
@@ -155,6 +157,10 @@ export interface ActionAddRemoveLiqInterface extends utils.Interface {
     functionFragment: "removeLiquiditySingleToken",
     values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
+  encodeFunctionData(
+    functionFragment: "swapAggregator",
+    values?: undefined
+  ): string;
 
   decodeFunctionResult(
     functionFragment: "addLiquidityDualSyAndPt",
@@ -176,10 +182,6 @@ export interface ActionAddRemoveLiqInterface extends utils.Interface {
     functionFragment: "addLiquiditySingleToken",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "kyberScalingLib",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "removeLiquidityDualSyAndPt",
     data: BytesLike
@@ -200,6 +202,10 @@ export interface ActionAddRemoveLiqInterface extends utils.Interface {
     functionFragment: "removeLiquiditySingleToken",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapAggregator",
+    data: BytesLike
+  ): Result;
 
   events: {
     "AddLiquidityDualSyAndPt(address,address,address,uint256,uint256,uint256)": EventFragment;
@@ -449,8 +455,6 @@ export interface ActionAddRemoveLiq extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    kyberScalingLib(overrides?: CallOverrides): Promise<[string]>;
-
     removeLiquidityDualSyAndPt(
       receiver: string,
       market: string,
@@ -493,6 +497,8 @@ export interface ActionAddRemoveLiq extends BaseContract {
       output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
+
+    swapAggregator(overrides?: CallOverrides): Promise<[string]>;
   };
 
   addLiquidityDualSyAndPt(
@@ -540,8 +546,6 @@ export interface ActionAddRemoveLiq extends BaseContract {
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  kyberScalingLib(overrides?: CallOverrides): Promise<string>;
-
   removeLiquidityDualSyAndPt(
     receiver: string,
     market: string,
@@ -585,6 +589,8 @@ export interface ActionAddRemoveLiq extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  swapAggregator(overrides?: CallOverrides): Promise<string>;
+
   callStatic: {
     addLiquidityDualSyAndPt(
       receiver: string,
@@ -649,8 +655,6 @@ export interface ActionAddRemoveLiq extends BaseContract {
       [BigNumber, BigNumber] & { netLpOut: BigNumber; netSyFee: BigNumber }
     >;
 
-    kyberScalingLib(overrides?: CallOverrides): Promise<string>;
-
     removeLiquidityDualSyAndPt(
       receiver: string,
       market: string,
@@ -703,6 +707,8 @@ export interface ActionAddRemoveLiq extends BaseContract {
     ): Promise<
       [BigNumber, BigNumber] & { netTokenOut: BigNumber; netSyFee: BigNumber }
     >;
+
+    swapAggregator(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {
@@ -919,8 +925,6 @@ export interface ActionAddRemoveLiq extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    kyberScalingLib(overrides?: CallOverrides): Promise<BigNumber>;
-
     removeLiquidityDualSyAndPt(
       receiver: string,
       market: string,
@@ -963,6 +967,8 @@ export interface ActionAddRemoveLiq extends BaseContract {
       output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
+
+    swapAggregator(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -1011,8 +1017,6 @@ export interface ActionAddRemoveLiq extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    kyberScalingLib(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     removeLiquidityDualSyAndPt(
       receiver: string,
       market: string,
@@ -1055,5 +1059,7 @@ export interface ActionAddRemoveLiq extends BaseContract {
       output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
+
+    swapAggregator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/ActionBaseMintRedeem.ts

@@ -22,16 +22,16 @@ import type {
 export interface ActionBaseMintRedeemInterface extends utils.Interface {
   contractName: "ActionBaseMintRedeem";
   functions: {
-    "kyberScalingLib()": FunctionFragment;
+    "swapAggregator()": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "kyberScalingLib",
+    functionFragment: "swapAggregator",
     values?: undefined
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "kyberScalingLib",
+    functionFragment: "swapAggregator",
     data: BytesLike
   ): Result;
 
@@ -66,22 +66,22 @@ export interface ActionBaseMintRedeem extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    kyberScalingLib(overrides?: CallOverrides): Promise<[string]>;
+    swapAggregator(overrides?: CallOverrides): Promise<[string]>;
   };
 
-  kyberScalingLib(overrides?: CallOverrides): Promise<string>;
+  swapAggregator(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
-    kyberScalingLib(overrides?: CallOverrides): Promise<string>;
+    swapAggregator(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    kyberScalingLib(overrides?: CallOverrides): Promise<BigNumber>;
+    swapAggregator(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    kyberScalingLib(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    swapAggregator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }