@pendle/core-v2 6.0.0 → 6.1.0

package/typechain-types/PendleLimitRouter.ts

@@ -91,6 +91,7 @@ export interface PendleLimitRouterInterface extends utils.Interface {
     "eip712Domain()": FunctionFragment;
     "feeRecipient()": FunctionFragment;
     "fill(((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes),bytes,uint256)[],address,uint256,bytes,bytes)": FunctionFragment;
+    "forceCancel(bytes32[])": FunctionFragment;
     "getLnFeeRateRoot(address)": FunctionFragment;
     "hashOrder((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes))": FunctionFragment;
     "increaseNonce()": FunctionFragment;
@@ -103,7 +104,7 @@ export interface PendleLimitRouterInterface extends utils.Interface {
     "ownerHelper()": FunctionFragment;
     "pendingOwner()": FunctionFragment;
     "setFeeRecipient(address)": FunctionFragment;
-    "setLnFeeRateRoots(address[],uint256[])": FunctionFragment;
+    "setLnFeeRateRoots(address[],uint256[],bool)": FunctionFragment;
     "setOwnerHelper(address)": FunctionFragment;
     "simulate(address,bytes)": FunctionFragment;
     "transferOwnership(address,bool,bool)": FunctionFragment;
@@ -152,6 +153,10 @@ export interface PendleLimitRouterInterface extends utils.Interface {
       BytesLike
     ]
   ): string;
+  encodeFunctionData(
+    functionFragment: "forceCancel",
+    values: [BytesLike[]]
+  ): string;
   encodeFunctionData(
     functionFragment: "getLnFeeRateRoot",
     values: [string]
@@ -196,7 +201,7 @@ export interface PendleLimitRouterInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "setLnFeeRateRoots",
-    values: [string[], BigNumberish[]]
+    values: [string[], BigNumberish[], boolean]
   ): string;
   encodeFunctionData(
     functionFragment: "setOwnerHelper",
@@ -242,6 +247,10 @@ export interface PendleLimitRouterInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "fill", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "forceCancel",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "getLnFeeRateRoot",
     data: BytesLike
@@ -300,6 +309,7 @@ export interface PendleLimitRouterInterface extends utils.Interface {
     "OrderCanceled(address,bytes32)": EventFragment;
     "OrderFilled(bytes32,uint8,address,address,uint256,uint256,uint256,uint256)": EventFragment;
     "OrderFilledV2(bytes32,uint8,address,address,uint256,uint256,uint256,uint256,address,address)": EventFragment;
+    "OrderForceCanceled(bytes32)": EventFragment;
     "OwnershipTransferred(address,address)": EventFragment;
   };
 
@@ -310,6 +320,7 @@ export interface PendleLimitRouterInterface extends utils.Interface {
   getEvent(nameOrSignatureOrTopic: "OrderCanceled"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OrderFilled"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OrderFilledV2"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "OrderForceCanceled"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
 
@@ -389,6 +400,14 @@ export type OrderFilledV2Event = TypedEvent<
 
 export type OrderFilledV2EventFilter = TypedEventFilter<OrderFilledV2Event>;
 
+export type OrderForceCanceledEvent = TypedEvent<
+  [string],
+  { orderHash: string }
+>;
+
+export type OrderForceCanceledEventFilter =
+  TypedEventFilter<OrderForceCanceledEvent>;
+
 export type OwnershipTransferredEvent = TypedEvent<
   [string, string],
   { previousOwner: string; newOwner: string }
@@ -479,6 +498,11 @@ export interface PendleLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    forceCancel(
+      orderHashes: BytesLike[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     getLnFeeRateRoot(
       YT: string,
       overrides?: CallOverrides
@@ -538,6 +562,7 @@ export interface PendleLimitRouter extends BaseContract {
     setLnFeeRateRoots(
       YTs: string[],
       lnFeeRateRoots: BigNumberish[],
+      allowZeroFees: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -614,6 +639,11 @@ export interface PendleLimitRouter extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  forceCancel(
+    orderHashes: BytesLike[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   getLnFeeRateRoot(YT: string, overrides?: CallOverrides): Promise<BigNumber>;
 
   hashOrder(order: OrderStruct, overrides?: CallOverrides): Promise<string>;
@@ -670,6 +700,7 @@ export interface PendleLimitRouter extends BaseContract {
   setLnFeeRateRoots(
     YTs: string[],
     lnFeeRateRoots: BigNumberish[],
+    allowZeroFees: boolean,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -748,6 +779,11 @@ export interface PendleLimitRouter extends BaseContract {
       }
     >;
 
+    forceCancel(
+      orderHashes: BytesLike[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
     getLnFeeRateRoot(YT: string, overrides?: CallOverrides): Promise<BigNumber>;
 
     hashOrder(order: OrderStruct, overrides?: CallOverrides): Promise<string>;
@@ -802,6 +838,7 @@ export interface PendleLimitRouter extends BaseContract {
     setLnFeeRateRoots(
       YTs: string[],
       lnFeeRateRoots: BigNumberish[],
+      allowZeroFees: boolean,
       overrides?: CallOverrides
     ): Promise<void>;
 
@@ -903,6 +940,13 @@ export interface PendleLimitRouter extends BaseContract {
       taker?: null
     ): OrderFilledV2EventFilter;
 
+    "OrderForceCanceled(bytes32)"(
+      orderHash?: BytesLike | null
+    ): OrderForceCanceledEventFilter;
+    OrderForceCanceled(
+      orderHash?: BytesLike | null
+    ): OrderForceCanceledEventFilter;
+
     "OwnershipTransferred(address,address)"(
       previousOwner?: string | null,
       newOwner?: string | null
@@ -956,6 +1000,11 @@ export interface PendleLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    forceCancel(
+      orderHashes: BytesLike[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     getLnFeeRateRoot(YT: string, overrides?: CallOverrides): Promise<BigNumber>;
 
     hashOrder(
@@ -1005,6 +1054,7 @@ export interface PendleLimitRouter extends BaseContract {
     setLnFeeRateRoots(
       YTs: string[],
       lnFeeRateRoots: BigNumberish[],
+      allowZeroFees: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -1070,6 +1120,11 @@ export interface PendleLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    forceCancel(
+      orderHashes: BytesLike[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     getLnFeeRateRoot(
       YT: string,
       overrides?: CallOverrides
@@ -1125,6 +1180,7 @@ export interface PendleLimitRouter extends BaseContract {
     setLnFeeRateRoots(
       YTs: string[],
       lnFeeRateRoots: BigNumberish[],
+      allowZeroFees: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 

package/typechain-types/PendleLpLinearDiscountOracle.ts

@@ -0,0 +1,262 @@
+/* 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 interface PendleLpLinearDiscountOracleInterface extends utils.Interface {
+  contractName: "PendleLpLinearDiscountOracle";
+  functions: {
+    "LP()": FunctionFragment;
+    "baseLpDiscountPerYear()": FunctionFragment;
+    "decimals()": FunctionFragment;
+    "getLpDiscount(uint256)": FunctionFragment;
+    "getLpPrice(uint256)": FunctionFragment;
+    "latestRoundData()": FunctionFragment;
+    "lpMaturedPrice()": FunctionFragment;
+    "maturity()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "LP", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "baseLpDiscountPerYear",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getLpDiscount",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLpPrice",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRoundData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "lpMaturedPrice",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "maturity", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "LP", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "baseLpDiscountPerYear",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getLpDiscount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getLpPrice", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "lpMaturedPrice",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "maturity", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface PendleLpLinearDiscountOracle extends BaseContract {
+  contractName: "PendleLpLinearDiscountOracle";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: PendleLpLinearDiscountOracleInterface;
+
+  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: {
+    LP(overrides?: CallOverrides): Promise<[string]>;
+
+    baseLpDiscountPerYear(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    getLpDiscount(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getLpPrice(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    latestRoundData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    lpMaturedPrice(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    maturity(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  LP(overrides?: CallOverrides): Promise<string>;
+
+  baseLpDiscountPerYear(overrides?: CallOverrides): Promise<BigNumber>;
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  getLpDiscount(
+    timeLeft: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getLpPrice(
+    timeLeft: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  latestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  >;
+
+  lpMaturedPrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+  maturity(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    LP(overrides?: CallOverrides): Promise<string>;
+
+    baseLpDiscountPerYear(overrides?: CallOverrides): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    getLpDiscount(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getLpPrice(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    latestRoundData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+      }
+    >;
+
+    lpMaturedPrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+    maturity(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    LP(overrides?: CallOverrides): Promise<BigNumber>;
+
+    baseLpDiscountPerYear(overrides?: CallOverrides): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getLpDiscount(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getLpPrice(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    latestRoundData(overrides?: CallOverrides): Promise<BigNumber>;
+
+    lpMaturedPrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+    maturity(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    LP(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    baseLpDiscountPerYear(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getLpDiscount(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getLpPrice(
+      timeLeft: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    latestRoundData(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    lpMaturedPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    maturity(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/PendleLpLinearDiscountOracleFactory.ts

@@ -0,0 +1,142 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface PendleLpLinearDiscountOracleFactoryInterface
+  extends utils.Interface {
+  contractName: "PendleLpLinearDiscountOracleFactory";
+  functions: {
+    "create(address,uint256,uint256)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "create",
+    values: [string, BigNumberish, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "create", data: BytesLike): Result;
+
+  events: {
+    "OracleCreated(address,uint256,uint256,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "OracleCreated"): EventFragment;
+}
+
+export type OracleCreatedEvent = TypedEvent<
+  [string, BigNumber, BigNumber, string],
+  {
+    market: string;
+    basePtDiscountPerYear: BigNumber;
+    lpBasePrice: BigNumber;
+    oracle: string;
+  }
+>;
+
+export type OracleCreatedEventFilter = TypedEventFilter<OracleCreatedEvent>;
+
+export interface PendleLpLinearDiscountOracleFactory extends BaseContract {
+  contractName: "PendleLpLinearDiscountOracleFactory";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: PendleLpLinearDiscountOracleFactoryInterface;
+
+  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: {
+    create(
+      market: string,
+      basePtDiscountPerYear: BigNumberish,
+      lpBasePrice: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  create(
+    market: string,
+    basePtDiscountPerYear: BigNumberish,
+    lpBasePrice: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    create(
+      market: string,
+      basePtDiscountPerYear: BigNumberish,
+      lpBasePrice: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<string>;
+  };
+
+  filters: {
+    "OracleCreated(address,uint256,uint256,address)"(
+      market?: string | null,
+      basePtDiscountPerYear?: null,
+      lpBasePrice?: null,
+      oracle?: null
+    ): OracleCreatedEventFilter;
+    OracleCreated(
+      market?: string | null,
+      basePtDiscountPerYear?: null,
+      lpBasePrice?: null,
+      oracle?: null
+    ): OracleCreatedEventFilter;
+  };
+
+  estimateGas: {
+    create(
+      market: string,
+      basePtDiscountPerYear: BigNumberish,
+      lpBasePrice: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    create(
+      market: string,
+      basePtDiscountPerYear: BigNumberish,
+      lpBasePrice: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}