@pendle/core-v2 1.2.0-mainnet → 1.4.0-mainnet

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

@@ -26,5 +26,5 @@
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
-    "feedistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
+    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
 }

package/deployments/1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rETH-WETH_BalancerLP Aura",
+    "SY": "0xdf7083f2A0F8a191ab5eEAFebE92ED21cD3Dd915",
+    "YT": "0x0F28A763198035825dFAdF3455cB5b8473a7c140",
+    "PT": "0xfbd85BF7A1E1bec0da6D12964B8c05471aE8f048",
+    "market": "0x5546d0f27BEd4075eA03a22c58F7016E24c94EA7",
+    "expiry": 1703721600,
+    "bulkSeller": "0xB2075aeEd11C2D261c3D80c957F495D18cF874ed",
+    "scalarRoot": "27500000000000000000",
+    "initAnchor": "1067325733000000000"
+}

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

@@ -0,0 +1,10 @@
+{
+    "name": "SY wstETH-WETH_BalancerLP Aura",
+    "SY": "0x8267fdabd1b8C8645138f2dE5B0fe24988DC9820",
+    "YT": "0x37fEc7b2f36f3bbAe956262F46ddF21830fa68ef",
+    "PT": "0xf6A865c4B9b087fFDd1e0DF8b5Dbb89Ee3546f49",
+    "market": "0xFcbAe4635CA89866F83Add208eCcEec742678746",
+    "expiry": 1719446400,
+    "scalarRoot": "28880000000000000000",
+    "initAnchor": "1105675000000000000"
+}

package/deployments/1-offchain-helper.json

@@ -0,0 +1,4 @@
+{
+    "multicall": "0x0E7cacc6C2A22Aa2D97a42a8C82edaF9F9eac259",
+    "implicitSwapfeeContract": "0x43D03031FAb845065e9CEfE89Dd122d63F72011F"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "1.2.0-mainnet",
+  "version": "1.4.0-mainnet",
   "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/ComposableStablePreview.ts

@@ -0,0 +1,217 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  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 declare namespace IVault {
+  export type ExitPoolRequestStruct = {
+    assets: string[];
+    minAmountsOut: BigNumberish[];
+    userData: BytesLike;
+    toInternalBalance: boolean;
+  };
+
+  export type ExitPoolRequestStructOutput = [
+    string[],
+    BigNumber[],
+    string,
+    boolean
+  ] & {
+    assets: string[];
+    minAmountsOut: BigNumber[];
+    userData: string;
+    toInternalBalance: boolean;
+  };
+
+  export type JoinPoolRequestStruct = {
+    assets: string[];
+    maxAmountsIn: BigNumberish[];
+    userData: BytesLike;
+    fromInternalBalance: boolean;
+  };
+
+  export type JoinPoolRequestStructOutput = [
+    string[],
+    BigNumber[],
+    string,
+    boolean
+  ] & {
+    assets: string[];
+    maxAmountsIn: BigNumber[];
+    userData: string;
+    fromInternalBalance: boolean;
+  };
+}
+
+export interface ComposableStablePreviewInterface extends utils.Interface {
+  contractName: "ComposableStablePreview";
+  functions: {
+    "exitPoolPreview(bytes32,address,address,(address[],uint256[],bytes,bool),bytes)": FunctionFragment;
+    "joinPoolPreview(bytes32,address,address,(address[],uint256[],bytes,bool),bytes)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "exitPoolPreview",
+    values: [BytesLike, string, string, IVault.ExitPoolRequestStruct, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "joinPoolPreview",
+    values: [BytesLike, string, string, IVault.JoinPoolRequestStruct, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "exitPoolPreview",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "joinPoolPreview",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface ComposableStablePreview extends BaseContract {
+  contractName: "ComposableStablePreview";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ComposableStablePreviewInterface;
+
+  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: {
+    exitPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.ExitPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { amountTokenOut: BigNumber }>;
+
+    joinPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.JoinPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { amountBptOut: BigNumber }>;
+  };
+
+  exitPoolPreview(
+    poolId: BytesLike,
+    sender: string,
+    recipient: string,
+    request: IVault.ExitPoolRequestStruct,
+    data: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  joinPoolPreview(
+    poolId: BytesLike,
+    sender: string,
+    recipient: string,
+    request: IVault.JoinPoolRequestStruct,
+    data: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    exitPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.ExitPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    joinPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.JoinPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    exitPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.ExitPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    joinPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.JoinPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    exitPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.ExitPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    joinPoolPreview(
+      poolId: BytesLike,
+      sender: string,
+      recipient: string,
+      request: IVault.JoinPoolRequestStruct,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/GMXPreviewHelper.ts

@@ -0,0 +1,81 @@
+/* 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: {
+    "vault()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "vault", values?: undefined): string;
+
+  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: {
+    vault(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  vault(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    vault(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    vault(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    vault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}