@pendle/core-v2 4.2.0 → 4.2.2

package/typechain-types/{ChainlinkRelayerAutomation.ts → IPActionStorageStaticLe1.ts}

@@ -4,6 +4,7 @@
 import {
   BaseContract,
   BigNumber,
+  BigNumberish,
   BytesLike,
   CallOverrides,
   ContractTransaction,
@@ -21,86 +22,105 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface ChainlinkRelayerAutomationInterface extends utils.Interface {
-  contractName: "ChainlinkRelayerAutomation";
+export type ApproxParamsStruct = {
+  guessMin: BigNumberish;
+  guessMax: BigNumberish;
+  guessOffchain: BigNumberish;
+  maxIteration: BigNumberish;
+  eps: BigNumberish;
+};
+
+export type ApproxParamsStructOutput = [
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber
+] & {
+  guessMin: BigNumber;
+  guessMax: BigNumber;
+  guessOffchain: BigNumber;
+  maxIteration: BigNumber;
+  eps: BigNumber;
+};
+
+export interface IPActionStorageStaticLe1Interface extends utils.Interface {
+  contractName: "IPActionStorageStaticLe1";
   functions: {
-    "answerLastSent()": FunctionFragment;
-    "checkUpkeep(bytes)": FunctionFragment;
     "claimOwnership()": FunctionFragment;
-    "owner()": FunctionFragment;
-    "pendingOwner()": FunctionFragment;
-    "performUpkeep(bytes)": FunctionFragment;
+    "getBulkSellerFactory()": FunctionFragment;
+    "getDefaultApproxParams()": FunctionFragment;
+    "getOwnerAndPendingOwner()": FunctionFragment;
+    "setBulkSellerFactory(address)": FunctionFragment;
+    "setDefaultApproxParams((uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "transferOwnership(address,bool,bool)": FunctionFragment;
-    "withdraw()": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "answerLastSent",
+    functionFragment: "claimOwnership",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "checkUpkeep",
-    values: [BytesLike]
+    functionFragment: "getBulkSellerFactory",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "claimOwnership",
+    functionFragment: "getDefaultApproxParams",
     values?: undefined
   ): string;
-  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "pendingOwner",
+    functionFragment: "getOwnerAndPendingOwner",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "performUpkeep",
-    values: [BytesLike]
+    functionFragment: "setBulkSellerFactory",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setDefaultApproxParams",
+    values: [ApproxParamsStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "transferOwnership",
     values: [string, boolean, boolean]
   ): string;
-  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
 
   decodeFunctionResult(
-    functionFragment: "answerLastSent",
+    functionFragment: "claimOwnership",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "checkUpkeep",
+    functionFragment: "getBulkSellerFactory",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "claimOwnership",
+    functionFragment: "getDefaultApproxParams",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getOwnerAndPendingOwner",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "pendingOwner",
+    functionFragment: "setBulkSellerFactory",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "performUpkeep",
+    functionFragment: "setDefaultApproxParams",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "transferOwnership",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
 
   events: {
-    "Initialized(uint8)": EventFragment;
     "OwnershipTransferred(address,address)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
 
-export type InitializedEvent = TypedEvent<[number], { version: number }>;
-
-export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
-
 export type OwnershipTransferredEvent = TypedEvent<
   [string, string],
   { previousOwner: string; newOwner: string }
@@ -109,13 +129,13 @@ export type OwnershipTransferredEvent = TypedEvent<
 export type OwnershipTransferredEventFilter =
   TypedEventFilter<OwnershipTransferredEvent>;
 
-export interface ChainlinkRelayerAutomation extends BaseContract {
-  contractName: "ChainlinkRelayerAutomation";
+export interface IPActionStorageStaticLe1 extends BaseContract {
+  contractName: "IPActionStorageStaticLe1";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: ChainlinkRelayerAutomationInterface;
+  interface: IPActionStorageStaticLe1Interface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -137,23 +157,27 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    answerLastSent(overrides?: CallOverrides): Promise<[BigNumber]>;
-
-    checkUpkeep(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[boolean, string] & { upkeepNeeded: boolean }>;
-
     claimOwnership(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    owner(overrides?: CallOverrides): Promise<[string]>;
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<[string]>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<[ApproxParamsStructOutput]>;
 
-    performUpkeep(
-      arg0: BytesLike,
+    getOwnerAndPendingOwner(
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
+
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -163,29 +187,29 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
       renounce: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
-
-    withdraw(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
   };
 
-  answerLastSent(overrides?: CallOverrides): Promise<BigNumber>;
-
-  checkUpkeep(
-    arg0: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<[boolean, string] & { upkeepNeeded: boolean }>;
-
   claimOwnership(
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  owner(overrides?: CallOverrides): Promise<string>;
+  getBulkSellerFactory(overrides?: CallOverrides): Promise<string>;
 
-  pendingOwner(overrides?: CallOverrides): Promise<string>;
+  getDefaultApproxParams(
+    overrides?: CallOverrides
+  ): Promise<ApproxParamsStructOutput>;
+
+  getOwnerAndPendingOwner(
+    overrides?: CallOverrides
+  ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
+
+  setBulkSellerFactory(
+    _bulkSellerFactory: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
-  performUpkeep(
-    arg0: BytesLike,
+  setDefaultApproxParams(
+    params: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -196,25 +220,28 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  withdraw(
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   callStatic: {
-    answerLastSent(overrides?: CallOverrides): Promise<BigNumber>;
+    claimOwnership(overrides?: CallOverrides): Promise<void>;
 
-    checkUpkeep(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[boolean, string] & { upkeepNeeded: boolean }>;
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<string>;
 
-    claimOwnership(overrides?: CallOverrides): Promise<void>;
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<ApproxParamsStructOutput>;
 
-    owner(overrides?: CallOverrides): Promise<string>;
+    getOwnerAndPendingOwner(
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
 
-    performUpkeep(arg0: BytesLike, overrides?: CallOverrides): Promise<void>;
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
 
     transferOwnership(
       newOwner: string,
@@ -222,14 +249,9 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
       renounce: boolean,
       overrides?: CallOverrides
     ): Promise<void>;
-
-    withdraw(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {
-    "Initialized(uint8)"(version?: null): InitializedEventFilter;
-    Initialized(version?: null): InitializedEventFilter;
-
     "OwnershipTransferred(address,address)"(
       previousOwner?: string | null,
       newOwner?: string | null
@@ -241,20 +263,23 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
   };
 
   estimateGas: {
-    answerLastSent(overrides?: CallOverrides): Promise<BigNumber>;
-
-    checkUpkeep(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
-
     claimOwnership(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    owner(overrides?: CallOverrides): Promise<BigNumber>;
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<BigNumber>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+    getDefaultApproxParams(overrides?: CallOverrides): Promise<BigNumber>;
 
-    performUpkeep(
-      arg0: BytesLike,
+    getOwnerAndPendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -264,30 +289,32 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
       renounce: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
-
-    withdraw(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    answerLastSent(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
-    checkUpkeep(
-      arg0: BytesLike,
+    getBulkSellerFactory(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    claimOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
+    getDefaultApproxParams(
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    getOwnerAndPendingOwner(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
-    performUpkeep(
-      arg0: BytesLike,
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -297,9 +324,5 @@ export interface ChainlinkRelayerAutomation extends BaseContract {
       renounce: boolean,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
-
-    withdraw(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/{IEigenpieStaking.ts → IPActionVePendleStaticLe1.ts}

@@ -7,8 +7,6 @@ import {
   BigNumberish,
   BytesLike,
   CallOverrides,
-  ContractTransaction,
-  Overrides,
   PopulatedTransaction,
   Signer,
   utils,
@@ -22,32 +20,32 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface IEigenpieStakingInterface extends utils.Interface {
-  contractName: "IEigenpieStaking";
+export interface IPActionVePendleStaticLe1Interface extends utils.Interface {
+  contractName: "IPActionVePendleStaticLe1";
   functions: {
-    "depositAsset(address,uint256,uint256,address)": FunctionFragment;
+    "increaseLockPositionStatic(address,uint128,uint128)": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "depositAsset",
-    values: [string, BigNumberish, BigNumberish, string]
+    functionFragment: "increaseLockPositionStatic",
+    values: [string, BigNumberish, BigNumberish]
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "depositAsset",
+    functionFragment: "increaseLockPositionStatic",
     data: BytesLike
   ): Result;
 
   events: {};
 }
 
-export interface IEigenpieStaking extends BaseContract {
-  contractName: "IEigenpieStaking";
+export interface IPActionVePendleStaticLe1 extends BaseContract {
+  contractName: "IPActionVePendleStaticLe1";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: IEigenpieStakingInterface;
+  interface: IPActionVePendleStaticLe1Interface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -69,52 +67,47 @@ export interface IEigenpieStaking extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    depositAsset(
-      asset: string,
-      depositAmount: BigNumberish,
-      minRec: BigNumberish,
-      referral: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { newVeBalance: BigNumber }>;
   };
 
-  depositAsset(
-    asset: string,
-    depositAmount: BigNumberish,
-    minRec: BigNumberish,
-    referral: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  increaseLockPositionStatic(
+    user: string,
+    additionalAmountToLock: BigNumberish,
+    newExpiry: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
   callStatic: {
-    depositAsset(
-      asset: string,
-      depositAmount: BigNumberish,
-      minRec: BigNumberish,
-      referral: string,
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<BigNumber>;
   };
 
   filters: {};
 
   estimateGas: {
-    depositAsset(
-      asset: string,
-      depositAmount: BigNumberish,
-      minRec: BigNumberish,
-      referral: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    depositAsset(
-      asset: string,
-      depositAmount: BigNumberish,
-      minRec: BigNumberish,
-      referral: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/{AutomationCompatible.ts → IPMiniDiamondLe1.ts}

@@ -21,41 +21,53 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface AutomationCompatibleInterface extends utils.Interface {
-  contractName: "AutomationCompatible";
+export declare namespace IPMiniDiamondLe1 {
+  export type SelectorsToFacetStruct = {
+    facet: string;
+    selectors: BytesLike[];
+  };
+
+  export type SelectorsToFacetStructOutput = [string, string[]] & {
+    facet: string;
+    selectors: string[];
+  };
+}
+
+export interface IPMiniDiamondLe1Interface extends utils.Interface {
+  contractName: "IPMiniDiamondLe1";
   functions: {
-    "checkUpkeep(bytes)": FunctionFragment;
-    "performUpkeep(bytes)": FunctionFragment;
+    "facetAddress(bytes4)": FunctionFragment;
+    "setFacetForSelectors((address,bytes4[])[])": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "checkUpkeep",
+    functionFragment: "facetAddress",
     values: [BytesLike]
   ): string;
   encodeFunctionData(
-    functionFragment: "performUpkeep",
-    values: [BytesLike]
+    functionFragment: "setFacetForSelectors",
+    values: [IPMiniDiamondLe1.SelectorsToFacetStruct[]]
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "checkUpkeep",
+    functionFragment: "facetAddress",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "performUpkeep",
+    functionFragment: "setFacetForSelectors",
     data: BytesLike
   ): Result;
 
   events: {};
 }
 
-export interface AutomationCompatible extends BaseContract {
-  contractName: "AutomationCompatible";
+export interface IPMiniDiamondLe1 extends BaseContract {
+  contractName: "IPMiniDiamondLe1";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: AutomationCompatibleInterface;
+  interface: IPMiniDiamondLe1Interface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -77,37 +89,32 @@ export interface AutomationCompatible extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    checkUpkeep(
-      checkData: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
 
-    performUpkeep(
-      performData: BytesLike,
+    setFacetForSelectors(
+      arr: IPMiniDiamondLe1.SelectorsToFacetStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
-  checkUpkeep(
-    checkData: BytesLike,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  facetAddress(selector: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-  performUpkeep(
-    performData: BytesLike,
+  setFacetForSelectors(
+    arr: IPMiniDiamondLe1.SelectorsToFacetStruct[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    checkUpkeep(
-      checkData: BytesLike,
+    facetAddress(
+      selector: BytesLike,
       overrides?: CallOverrides
-    ): Promise<
-      [boolean, string] & { upkeepNeeded: boolean; performData: string }
-    >;
+    ): Promise<string>;
 
-    performUpkeep(
-      performData: BytesLike,
+    setFacetForSelectors(
+      arr: IPMiniDiamondLe1.SelectorsToFacetStruct[],
       overrides?: CallOverrides
     ): Promise<void>;
   };
@@ -115,25 +122,25 @@ export interface AutomationCompatible extends BaseContract {
   filters: {};
 
   estimateGas: {
-    checkUpkeep(
-      checkData: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    performUpkeep(
-      performData: BytesLike,
+    setFacetForSelectors(
+      arr: IPMiniDiamondLe1.SelectorsToFacetStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    checkUpkeep(
-      checkData: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    performUpkeep(
-      performData: BytesLike,
+    setFacetForSelectors(
+      arr: IPMiniDiamondLe1.SelectorsToFacetStruct[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };