@pendle/core-v2 3.0.0-beta-2 → 3.0.0-beta-4

package/typechain-types/IPLimitRouter.ts

@@ -33,6 +33,7 @@ export type OrderStruct = {
   receiver: string;
   makingAmount: BigNumberish;
   lnImpliedRate: BigNumberish;
+  failSafeRate: BigNumberish;
   permit: BytesLike;
 };
 
@@ -47,6 +48,7 @@ export type OrderStructOutput = [
   string,
   BigNumber,
   BigNumber,
+  BigNumber,
   string
 ] & {
   salt: BigNumber;
@@ -59,6 +61,7 @@ export type OrderStructOutput = [
   receiver: string;
   makingAmount: BigNumber;
   lnImpliedRate: BigNumber;
+  failSafeRate: BigNumber;
   permit: string;
 };
 
@@ -74,62 +77,25 @@ export type FillOrderParamsStructOutput = [
   BigNumber
 ] & { order: OrderStructOutput; signature: string; makingAmount: BigNumber };
 
-export declare namespace IPLimitRouter {
-  export type MultiApprovalStruct = { tokens: string[]; spender: string };
-
-  export type MultiApprovalStructOutput = [string[], string] & {
-    tokens: string[];
-    spender: string;
-  };
-}
-
-export declare namespace IPOrderMixinType {
-  export type OnchainParamsStruct = {
-    timeToExpiry: BigNumberish;
-    pyIndex: BigNumberish;
-    feeRecipient: string;
-    lnFeeRateRoot: BigNumberish;
-  };
-
-  export type OnchainParamsStructOutput = [
-    BigNumber,
-    BigNumber,
-    string,
-    BigNumber
-  ] & {
-    timeToExpiry: BigNumber;
-    pyIndex: BigNumber;
-    feeRecipient: string;
-    lnFeeRateRoot: BigNumber;
-  };
-}
-
 export interface IPLimitRouterInterface extends utils.Interface {
   contractName: "IPLimitRouter";
   functions: {
     "DOMAIN_SEPARATOR()": FunctionFragment;
-    "approveInf((address[],address)[])": FunctionFragment;
-    "cancelBatch((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,bytes)[])": FunctionFragment;
-    "cancelSingle((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,bytes))": FunctionFragment;
+    "cancelBatch((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes)[])": FunctionFragment;
+    "cancelSingle((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes))": FunctionFragment;
     "feeRecipient()": FunctionFragment;
-    "flashFill(((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,bytes),bytes,uint256)[],address,uint256,bytes)": FunctionFragment;
-    "getOnchainParams(address)": FunctionFragment;
-    "hashOrder((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,bytes))": FunctionFragment;
+    "flashFill(((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes),bytes,uint256)[],address,uint256,bytes)": FunctionFragment;
+    "hashOrder((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes))": FunctionFragment;
     "lnFeeRateRoot()": FunctionFragment;
-    "normalFill(((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,bytes),bytes,uint256)[],address,uint256,bytes)": FunctionFragment;
-    "remaining(bytes32)": FunctionFragment;
-    "remainingRaw(bytes32)": FunctionFragment;
-    "remainingsRaw(bytes32[])": FunctionFragment;
+    "normalFill(((uint256,uint256,uint256,uint8,address,address,address,address,uint256,uint256,uint256,bytes),bytes,uint256)[],address,uint256,bytes)": FunctionFragment;
+    "orderStatuses(bytes32[])": FunctionFragment;
+    "orderStatusesRaw(bytes32[])": FunctionFragment;
   };
 
   encodeFunctionData(
     functionFragment: "DOMAIN_SEPARATOR",
     values?: undefined
   ): string;
-  encodeFunctionData(
-    functionFragment: "approveInf",
-    values: [IPLimitRouter.MultiApprovalStruct[]]
-  ): string;
   encodeFunctionData(
     functionFragment: "cancelBatch",
     values: [OrderStruct[]]
@@ -146,10 +112,6 @@ export interface IPLimitRouterInterface extends utils.Interface {
     functionFragment: "flashFill",
     values: [FillOrderParamsStruct[], string, BigNumberish, BytesLike]
   ): string;
-  encodeFunctionData(
-    functionFragment: "getOnchainParams",
-    values: [string]
-  ): string;
   encodeFunctionData(
     functionFragment: "hashOrder",
     values: [OrderStruct]
@@ -163,15 +125,11 @@ export interface IPLimitRouterInterface extends utils.Interface {
     values: [FillOrderParamsStruct[], string, BigNumberish, BytesLike]
   ): string;
   encodeFunctionData(
-    functionFragment: "remaining",
-    values: [BytesLike]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "remainingRaw",
-    values: [BytesLike]
+    functionFragment: "orderStatuses",
+    values: [BytesLike[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "remainingsRaw",
+    functionFragment: "orderStatusesRaw",
     values: [BytesLike[]]
   ): string;
 
@@ -179,7 +137,6 @@ export interface IPLimitRouterInterface extends utils.Interface {
     functionFragment: "DOMAIN_SEPARATOR",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "approveInf", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "cancelBatch",
     data: BytesLike
@@ -193,103 +150,52 @@ export interface IPLimitRouterInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "flashFill", data: BytesLike): Result;
-  decodeFunctionResult(
-    functionFragment: "getOnchainParams",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(functionFragment: "hashOrder", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "lnFeeRateRoot",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "normalFill", data: BytesLike): Result;
-  decodeFunctionResult(functionFragment: "remaining", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "remainingRaw",
+    functionFragment: "orderStatuses",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "remainingsRaw",
+    functionFragment: "orderStatusesRaw",
     data: BytesLike
   ): Result;
 
   events: {
-    "FlashFill(uint8,address,address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
-    "NormalFill(uint8,address,address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
-    "OrderCanceled(address,bytes32,uint256)": EventFragment;
-    "OrderRemainingUpdated(bytes32,uint256)": EventFragment;
+    "OrderCanceled(address,bytes32)": EventFragment;
+    "OrderFilled(bytes32,uint8,address,address,uint256,uint256,uint256,uint256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "FlashFill"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "NormalFill"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OrderCanceled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OrderRemainingUpdated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "OrderFilled"): EventFragment;
 }
 
-export type FlashFillEvent = TypedEvent<
-  [
-    number,
-    string,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
-  {
-    orderType: number;
-    YT: string;
-    taker: string;
-    netOutputToTaker: BigNumber;
-    netInputFromTaker: BigNumber;
-    totalFee: BigNumber;
-    rawTotalMaking: BigNumber;
-    rawTotalTaking: BigNumber;
-  }
+export type OrderCanceledEvent = TypedEvent<
+  [string, string],
+  { maker: string; orderHash: string }
 >;
 
-export type FlashFillEventFilter = TypedEventFilter<FlashFillEvent>;
-
-export type NormalFillEvent = TypedEvent<
-  [
-    number,
-    string,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
+export type OrderCanceledEventFilter = TypedEventFilter<OrderCanceledEvent>;
+
+export type OrderFilledEvent = TypedEvent<
+  [string, number, string, string, BigNumber, BigNumber, BigNumber, BigNumber],
   {
+    orderHash: string;
     orderType: number;
     YT: string;
-    taker: string;
-    actualMaking: BigNumber;
-    actualTaking: BigNumber;
-    totalFee: BigNumber;
-    rawTotalMaking: BigNumber;
-    rawTotalTaking: BigNumber;
+    token: string;
+    netInputFromMaker: BigNumber;
+    netOutputToMaker: BigNumber;
+    feeAmount: BigNumber;
+    notionalVolume: BigNumber;
   }
 >;
 
-export type NormalFillEventFilter = TypedEventFilter<NormalFillEvent>;
-
-export type OrderCanceledEvent = TypedEvent<
-  [string, string, BigNumber],
-  { maker: string; orderHash: string; remaining: BigNumber }
->;
-
-export type OrderCanceledEventFilter = TypedEventFilter<OrderCanceledEvent>;
-
-export type OrderRemainingUpdatedEvent = TypedEvent<
-  [string, BigNumber],
-  { orderHash: string; remaining: BigNumber }
->;
-
-export type OrderRemainingUpdatedEventFilter =
-  TypedEventFilter<OrderRemainingUpdatedEvent>;
+export type OrderFilledEventFilter = TypedEventFilter<OrderFilledEvent>;
 
 export interface IPLimitRouter extends BaseContract {
   contractName: "IPLimitRouter";
@@ -321,11 +227,6 @@ export interface IPLimitRouter extends BaseContract {
   functions: {
     DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;
 
-    approveInf(
-      arr: IPLimitRouter.MultiApprovalStruct[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     cancelBatch(
       orders: OrderStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -346,11 +247,6 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    getOnchainParams(
-      YT: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     hashOrder(order: OrderStruct, overrides?: CallOverrides): Promise<[string]>;
 
     lnFeeRateRoot(overrides?: CallOverrides): Promise<[BigNumber]>;
@@ -363,29 +259,29 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    remaining(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    remainingRaw(
-      orderHash: BytesLike,
+    orderStatuses(
+      orderHashes: BytesLike[],
       overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+    ): Promise<
+      [BigNumber[], BigNumber[]] & {
+        remainings: BigNumber[];
+        filledAmounts: BigNumber[];
+      }
+    >;
 
-    remainingsRaw(
+    orderStatusesRaw(
       orderHashes: BytesLike[],
       overrides?: CallOverrides
-    ): Promise<[BigNumber[]]>;
+    ): Promise<
+      [BigNumber[], BigNumber[]] & {
+        remainingsRaw: BigNumber[];
+        filledAmounts: BigNumber[];
+      }
+    >;
   };
 
   DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
 
-  approveInf(
-    arr: IPLimitRouter.MultiApprovalStruct[],
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   cancelBatch(
     orders: OrderStruct[],
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -406,11 +302,6 @@ export interface IPLimitRouter extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  getOnchainParams(
-    YT: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   hashOrder(order: OrderStruct, overrides?: CallOverrides): Promise<string>;
 
   lnFeeRateRoot(overrides?: CallOverrides): Promise<BigNumber>;
@@ -423,29 +314,29 @@ export interface IPLimitRouter extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  remaining(
-    orderHash: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  remainingRaw(
-    orderHash: BytesLike,
+  orderStatuses(
+    orderHashes: BytesLike[],
     overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  remainingsRaw(
+  ): Promise<
+    [BigNumber[], BigNumber[]] & {
+      remainings: BigNumber[];
+      filledAmounts: BigNumber[];
+    }
+  >;
+
+  orderStatusesRaw(
     orderHashes: BytesLike[],
     overrides?: CallOverrides
-  ): Promise<BigNumber[]>;
+  ): Promise<
+    [BigNumber[], BigNumber[]] & {
+      remainingsRaw: BigNumber[];
+      filledAmounts: BigNumber[];
+    }
+  >;
 
   callStatic: {
     DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
 
-    approveInf(
-      arr: IPLimitRouter.MultiApprovalStruct[],
-      overrides?: CallOverrides
-    ): Promise<void>;
-
     cancelBatch(
       orders: OrderStruct[],
       overrides?: CallOverrides
@@ -469,11 +360,6 @@ export interface IPLimitRouter extends BaseContract {
       }
     >;
 
-    getOnchainParams(
-      YT: string,
-      overrides?: CallOverrides
-    ): Promise<IPOrderMixinType.OnchainParamsStructOutput>;
-
     hashOrder(order: OrderStruct, overrides?: CallOverrides): Promise<string>;
 
     lnFeeRateRoot(overrides?: CallOverrides): Promise<BigNumber>;
@@ -492,94 +378,62 @@ export interface IPLimitRouter extends BaseContract {
       }
     >;
 
-    remaining(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    remainingRaw(
-      orderHash: BytesLike,
+    orderStatuses(
+      orderHashes: BytesLike[],
       overrides?: CallOverrides
-    ): Promise<BigNumber>;
+    ): Promise<
+      [BigNumber[], BigNumber[]] & {
+        remainings: BigNumber[];
+        filledAmounts: BigNumber[];
+      }
+    >;
 
-    remainingsRaw(
+    orderStatusesRaw(
       orderHashes: BytesLike[],
       overrides?: CallOverrides
-    ): Promise<BigNumber[]>;
+    ): Promise<
+      [BigNumber[], BigNumber[]] & {
+        remainingsRaw: BigNumber[];
+        filledAmounts: BigNumber[];
+      }
+    >;
   };
 
   filters: {
-    "FlashFill(uint8,address,address,uint256,uint256,uint256,uint256,uint256)"(
-      orderType?: BigNumberish | null,
-      YT?: string | null,
-      taker?: string | null,
-      netOutputToTaker?: null,
-      netInputFromTaker?: null,
-      totalFee?: null,
-      rawTotalMaking?: null,
-      rawTotalTaking?: null
-    ): FlashFillEventFilter;
-    FlashFill(
-      orderType?: BigNumberish | null,
-      YT?: string | null,
-      taker?: string | null,
-      netOutputToTaker?: null,
-      netInputFromTaker?: null,
-      totalFee?: null,
-      rawTotalMaking?: null,
-      rawTotalTaking?: null
-    ): FlashFillEventFilter;
-
-    "NormalFill(uint8,address,address,uint256,uint256,uint256,uint256,uint256)"(
-      orderType?: BigNumberish | null,
-      YT?: string | null,
-      taker?: string | null,
-      actualMaking?: null,
-      actualTaking?: null,
-      totalFee?: null,
-      rawTotalMaking?: null,
-      rawTotalTaking?: null
-    ): NormalFillEventFilter;
-    NormalFill(
-      orderType?: BigNumberish | null,
-      YT?: string | null,
-      taker?: string | null,
-      actualMaking?: null,
-      actualTaking?: null,
-      totalFee?: null,
-      rawTotalMaking?: null,
-      rawTotalTaking?: null
-    ): NormalFillEventFilter;
-
-    "OrderCanceled(address,bytes32,uint256)"(
+    "OrderCanceled(address,bytes32)"(
       maker?: string | null,
-      orderHash?: BytesLike | null,
-      remaining?: null
+      orderHash?: BytesLike | null
     ): OrderCanceledEventFilter;
     OrderCanceled(
       maker?: string | null,
-      orderHash?: BytesLike | null,
-      remaining?: null
+      orderHash?: BytesLike | null
     ): OrderCanceledEventFilter;
 
-    "OrderRemainingUpdated(bytes32,uint256)"(
+    "OrderFilled(bytes32,uint8,address,address,uint256,uint256,uint256,uint256)"(
       orderHash?: BytesLike | null,
-      remaining?: null
-    ): OrderRemainingUpdatedEventFilter;
-    OrderRemainingUpdated(
+      orderType?: BigNumberish | null,
+      YT?: string | null,
+      token?: null,
+      netInputFromMaker?: null,
+      netOutputToMaker?: null,
+      feeAmount?: null,
+      notionalVolume?: null
+    ): OrderFilledEventFilter;
+    OrderFilled(
       orderHash?: BytesLike | null,
-      remaining?: null
-    ): OrderRemainingUpdatedEventFilter;
+      orderType?: BigNumberish | null,
+      YT?: string | null,
+      token?: null,
+      netInputFromMaker?: null,
+      netOutputToMaker?: null,
+      feeAmount?: null,
+      notionalVolume?: null
+    ): OrderFilledEventFilter;
   };
 
   estimateGas: {
     DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<BigNumber>;
 
-    approveInf(
-      arr: IPLimitRouter.MultiApprovalStruct[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     cancelBatch(
       orders: OrderStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -600,11 +454,6 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getOnchainParams(
-      YT: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     hashOrder(
       order: OrderStruct,
       overrides?: CallOverrides
@@ -620,17 +469,12 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    remaining(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    remainingRaw(
-      orderHash: BytesLike,
+    orderStatuses(
+      orderHashes: BytesLike[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    remainingsRaw(
+    orderStatusesRaw(
       orderHashes: BytesLike[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
@@ -639,11 +483,6 @@ export interface IPLimitRouter extends BaseContract {
   populateTransaction: {
     DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    approveInf(
-      arr: IPLimitRouter.MultiApprovalStruct[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     cancelBatch(
       orders: OrderStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -664,11 +503,6 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getOnchainParams(
-      YT: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     hashOrder(
       order: OrderStruct,
       overrides?: CallOverrides
@@ -684,17 +518,12 @@ export interface IPLimitRouter extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    remaining(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    remainingRaw(
-      orderHash: BytesLike,
+    orderStatuses(
+      orderHashes: BytesLike[],
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    remainingsRaw(
+    orderStatusesRaw(
       orderHashes: BytesLike[],
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;