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

package/contracts/router/kyberswap/interfaces/IExecutorHelperEthereum1.sol

@@ -0,0 +1,191 @@
+// 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);
+
+    function executeFraxSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+}

package/contracts/router/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/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/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-helper.json

@@ -1,3 +1,4 @@
 {
-    "implicitSwapfeeContract": "0x14A59F6e482B25BAc872a8788E7AfF3F254604Fa"
+    "implicitSwapfeeContract": "0x14A59F6e482B25BAc872a8788E7AfF3F254604Fa",
+    "multicall": "0x44099Cc077E7e4c619b217474ee459532169C563"
 }

package/deployments/80001-helper.json

@@ -1,3 +1,4 @@
 {
-    "implicitSwapfeeContract": "0xc4F3ee03790C06dE413192eb18795Fd3788e669E"
+    "implicitSwapfeeContract": "0xc4F3ee03790C06dE413192eb18795Fd3788e669E",
+    "multicall": "0xEAdf0eF1373Bde6E3265B266F2a474F9C1f66040"
 }

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

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x2b6891918CE19e854daB4fce31a1246ECef575E6",
+    "YT": "0x38692a41E857Fcc28Cf7e5782F6245Cd54a04C7E",
+    "PT": "0x721036540c0Ca715e546286df70c2Be6196d0561",
+    "market": "0x9D6913b06d7B42d921e812c46A63cFb580F5cCfc",
+    "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.20.1-testnet",
+  "version": "0.21.0-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/GMXPreviewHelper.ts

@@ -0,0 +1,134 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface GMXPreviewHelperInterface extends utils.Interface {
+  contractName: "GMXPreviewHelper";
+  functions: {
+    "BASIS_POINTS_DIVISOR()": FunctionFragment;
+    "PRICE_PRECISION()": FunctionFragment;
+    "usdg()": FunctionFragment;
+    "vault()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "BASIS_POINTS_DIVISOR",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "PRICE_PRECISION",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "usdg", values?: undefined): string;
+  encodeFunctionData(functionFragment: "vault", values?: undefined): string;
+
+  decodeFunctionResult(
+    functionFragment: "BASIS_POINTS_DIVISOR",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "PRICE_PRECISION",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "usdg", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "vault", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface GMXPreviewHelper extends BaseContract {
+  contractName: "GMXPreviewHelper";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: GMXPreviewHelperInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    BASIS_POINTS_DIVISOR(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    PRICE_PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    usdg(overrides?: CallOverrides): Promise<[string]>;
+
+    vault(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  BASIS_POINTS_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+  PRICE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+  usdg(overrides?: CallOverrides): Promise<string>;
+
+  vault(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    BASIS_POINTS_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+    PRICE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+    usdg(overrides?: CallOverrides): Promise<string>;
+
+    vault(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    BASIS_POINTS_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+    PRICE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+    usdg(overrides?: CallOverrides): Promise<BigNumber>;
+
+    vault(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    BASIS_POINTS_DIVISOR(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    PRICE_PRECISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    usdg(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    vault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}