@d8x/perpetuals-sdk 1.3.7 → 2.0.0-alpha

package/src/contracts/LimitOrderBook.ts

@@ -3,28 +3,24 @@
 /* eslint-disable */
 import type {
   BaseContract,
-  BigNumber,
   BigNumberish,
   BytesLike,
-  CallOverrides,
-  ContractTransaction,
-  Overrides,
-  PayableOverrides,
-  PopulatedTransaction,
-  Signer,
-  utils,
-} from "ethers";
-import type {
   FunctionFragment,
   Result,
+  Interface,
   EventFragment,
-} from "@ethersproject/abi";
-import type { Listener, Provider } from "@ethersproject/providers";
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
 import type {
-  TypedEventFilter,
-  TypedEvent,
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
   TypedListener,
-  OnEvent,
+  TypedContractMethod,
 } from "./common";
 
 export declare namespace IPerpetualOrder {
@@ -32,13 +28,13 @@ export declare namespace IPerpetualOrder {
     leverageTDR: BigNumberish;
     brokerFeeTbps: BigNumberish;
     iPerpetualId: BigNumberish;
-    traderAddr: string;
+    traderAddr: AddressLike;
     executionTimestamp: BigNumberish;
-    brokerAddr: string;
+    brokerAddr: AddressLike;
     submittedTimestamp: BigNumberish;
     flags: BigNumberish;
     iDeadline: BigNumberish;
-    executorAddr: string;
+    executorAddr: AddressLike;
     fAmount: BigNumberish;
     fLimitPrice: BigNumberish;
     fTriggerPrice: BigNumberish;
@@ -46,34 +42,34 @@ export declare namespace IPerpetualOrder {
   };
 
   export type OrderStructOutput = [
-    number,
-    number,
-    number,
-    string,
-    number,
-    string,
-    number,
-    number,
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    string
+    leverageTDR: bigint,
+    brokerFeeTbps: bigint,
+    iPerpetualId: bigint,
+    traderAddr: string,
+    executionTimestamp: bigint,
+    brokerAddr: string,
+    submittedTimestamp: bigint,
+    flags: bigint,
+    iDeadline: bigint,
+    executorAddr: string,
+    fAmount: bigint,
+    fLimitPrice: bigint,
+    fTriggerPrice: bigint,
+    brokerSignature: string
   ] & {
-    leverageTDR: number;
-    brokerFeeTbps: number;
-    iPerpetualId: number;
+    leverageTDR: bigint;
+    brokerFeeTbps: bigint;
+    iPerpetualId: bigint;
     traderAddr: string;
-    executionTimestamp: number;
+    executionTimestamp: bigint;
     brokerAddr: string;
-    submittedTimestamp: number;
-    flags: number;
-    iDeadline: number;
+    submittedTimestamp: bigint;
+    flags: bigint;
+    iDeadline: bigint;
     executorAddr: string;
-    fAmount: BigNumber;
-    fLimitPrice: BigNumber;
-    fTriggerPrice: BigNumber;
+    fAmount: bigint;
+    fLimitPrice: bigint;
+    fTriggerPrice: bigint;
     brokerSignature: string;
   };
 }
@@ -86,79 +82,55 @@ export declare namespace IClientOrder {
     executionTimestamp: BigNumberish;
     flags: BigNumberish;
     iDeadline: BigNumberish;
-    brokerAddr: string;
+    brokerAddr: AddressLike;
     fTriggerPrice: BigNumberish;
     fAmount: BigNumberish;
     parentChildDigest1: BytesLike;
-    traderAddr: string;
+    traderAddr: AddressLike;
     parentChildDigest2: BytesLike;
     brokerFeeTbps: BigNumberish;
     brokerSignature: BytesLike;
-    callbackTarget: string;
+    callbackTarget: AddressLike;
   };
 
   export type ClientOrderStructOutput = [
-    number,
-    BigNumber,
-    number,
-    number,
-    number,
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    string,
-    string,
-    string,
-    number,
-    string,
-    string
+    iPerpetualId: bigint,
+    fLimitPrice: bigint,
+    leverageTDR: bigint,
+    executionTimestamp: bigint,
+    flags: bigint,
+    iDeadline: bigint,
+    brokerAddr: string,
+    fTriggerPrice: bigint,
+    fAmount: bigint,
+    parentChildDigest1: string,
+    traderAddr: string,
+    parentChildDigest2: string,
+    brokerFeeTbps: bigint,
+    brokerSignature: string,
+    callbackTarget: string
   ] & {
-    iPerpetualId: number;
-    fLimitPrice: BigNumber;
-    leverageTDR: number;
-    executionTimestamp: number;
-    flags: number;
-    iDeadline: number;
+    iPerpetualId: bigint;
+    fLimitPrice: bigint;
+    leverageTDR: bigint;
+    executionTimestamp: bigint;
+    flags: bigint;
+    iDeadline: bigint;
     brokerAddr: string;
-    fTriggerPrice: BigNumber;
-    fAmount: BigNumber;
+    fTriggerPrice: bigint;
+    fAmount: bigint;
     parentChildDigest1: string;
     traderAddr: string;
     parentChildDigest2: string;
-    brokerFeeTbps: number;
+    brokerFeeTbps: bigint;
     brokerSignature: string;
     callbackTarget: string;
   };
 }
 
-export interface LimitOrderBookInterface extends utils.Interface {
-  functions: {
-    "CALLBACK_GAS_LIMIT()": FunctionFragment;
-    "actvDigestPos(bytes32)": FunctionFragment;
-    "callbackFunctions(bytes32)": FunctionFragment;
-    "cancelOrder(bytes32,bytes,bytes[],uint64[])": FunctionFragment;
-    "digestsOfTrader(address,uint256)": FunctionFragment;
-    "executeOrders(bytes32[],address,bytes[],uint64[])": FunctionFragment;
-    "getOrderStatus(bytes32)": FunctionFragment;
-    "getOrders(address,uint256,uint256)": FunctionFragment;
-    "getTrader(bytes32)": FunctionFragment;
-    "initialize(address,uint24,uint8)": FunctionFragment;
-    "lastOrderHash()": FunctionFragment;
-    "limitDigestsOfTrader(address,uint256,uint256)": FunctionFragment;
-    "marketCloseSwitchTimestamp()": FunctionFragment;
-    "numberOfDigestsOfTrader(address)": FunctionFragment;
-    "orderCount()": FunctionFragment;
-    "orderDependency(bytes32)": FunctionFragment;
-    "orderOfDigest(bytes32)": FunctionFragment;
-    "perpManager()": FunctionFragment;
-    "perpetualId()": FunctionFragment;
-    "pollRange(uint256,uint256)": FunctionFragment;
-    "postOrders((uint24,int128,uint16,uint32,uint32,uint32,address,int128,int128,bytes32,address,bytes32,uint16,bytes,address)[],bytes[])": FunctionFragment;
-  };
-
+export interface LimitOrderBookInterface extends Interface {
   getFunction(
-    nameOrSignatureOrTopic:
+    nameOrSignature:
       | "CALLBACK_GAS_LIMIT"
       | "actvDigestPos"
       | "callbackFunctions"
@@ -182,6 +154,14 @@ export interface LimitOrderBookInterface extends utils.Interface {
       | "postOrders"
   ): FunctionFragment;
 
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Callback"
+      | "ExecutionFailed"
+      | "Initialized"
+      | "PerpetualLimitOrderCreated"
+  ): EventFragment;
+
   encodeFunctionData(
     functionFragment: "CALLBACK_GAS_LIMIT",
     values?: undefined
@@ -200,11 +180,11 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "digestsOfTrader",
-    values: [string, BigNumberish]
+    values: [AddressLike, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "executeOrders",
-    values: [BytesLike[], string, BytesLike[], BigNumberish[]]
+    values: [BytesLike[], AddressLike, BytesLike[], BigNumberish[]]
   ): string;
   encodeFunctionData(
     functionFragment: "getOrderStatus",
@@ -212,7 +192,7 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "getOrders",
-    values: [string, BigNumberish, BigNumberish]
+    values: [AddressLike, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "getTrader",
@@ -220,7 +200,7 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "initialize",
-    values: [string, BigNumberish, BigNumberish]
+    values: [AddressLike, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "lastOrderHash",
@@ -228,7 +208,7 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "limitDigestsOfTrader",
-    values: [string, BigNumberish, BigNumberish]
+    values: [AddressLike, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "marketCloseSwitchTimestamp",
@@ -236,7 +216,7 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "numberOfDigestsOfTrader",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(
     functionFragment: "orderCount",
@@ -333,774 +313,518 @@ export interface LimitOrderBookInterface extends utils.Interface {
   ): Result;
   decodeFunctionResult(functionFragment: "pollRange", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "postOrders", data: BytesLike): Result;
-
-  events: {
-    "Callback(address,bool,uint32)": EventFragment;
-    "ExecutionFailed(uint24,address,bytes32,string)": EventFragment;
-    "Initialized(uint8)": EventFragment;
-    "PerpetualLimitOrderCreated(uint24,address,address,(uint16,uint16,uint24,address,uint32,address,uint32,uint32,uint32,address,int128,int128,int128,bytes),bytes32)": EventFragment;
-  };
-
-  getEvent(nameOrSignatureOrTopic: "Callback"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ExecutionFailed"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "PerpetualLimitOrderCreated"): EventFragment;
 }
 
-export interface CallbackEventObject {
-  callbackTarget: string;
-  success: boolean;
-  gasLimit: number;
+export namespace CallbackEvent {
+  export type InputTuple = [
+    callbackTarget: AddressLike,
+    success: boolean,
+    gasLimit: BigNumberish
+  ];
+  export type OutputTuple = [
+    callbackTarget: string,
+    success: boolean,
+    gasLimit: bigint
+  ];
+  export interface OutputObject {
+    callbackTarget: string;
+    success: boolean;
+    gasLimit: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type CallbackEvent = TypedEvent<
-  [string, boolean, number],
-  CallbackEventObject
->;
 
-export type CallbackEventFilter = TypedEventFilter<CallbackEvent>;
-
-export interface ExecutionFailedEventObject {
-  perpetualId: number;
-  trader: string;
-  digest: string;
-  reason: string;
+export namespace ExecutionFailedEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    digest: BytesLike,
+    reason: string
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    digest: string,
+    reason: string
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    digest: string;
+    reason: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type ExecutionFailedEvent = TypedEvent<
-  [number, string, string, string],
-  ExecutionFailedEventObject
->;
-
-export type ExecutionFailedEventFilter = TypedEventFilter<ExecutionFailedEvent>;
 
-export interface InitializedEventObject {
-  version: number;
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
 
-export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
-
-export interface PerpetualLimitOrderCreatedEventObject {
-  perpetualId: number;
-  trader: string;
-  brokerAddr: string;
-  order: IPerpetualOrder.OrderStructOutput;
-  digest: string;
+export namespace PerpetualLimitOrderCreatedEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    brokerAddr: AddressLike,
+    order: IPerpetualOrder.OrderStruct,
+    digest: BytesLike
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    brokerAddr: string,
+    order: IPerpetualOrder.OrderStructOutput,
+    digest: string
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    brokerAddr: string;
+    order: IPerpetualOrder.OrderStructOutput;
+    digest: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type PerpetualLimitOrderCreatedEvent = TypedEvent<
-  [number, string, string, IPerpetualOrder.OrderStructOutput, string],
-  PerpetualLimitOrderCreatedEventObject
->;
-
-export type PerpetualLimitOrderCreatedEventFilter =
-  TypedEventFilter<PerpetualLimitOrderCreatedEvent>;
 
 export interface LimitOrderBook extends BaseContract {
-  connect(signerOrProvider: Signer | Provider | string): this;
-  attach(addressOrName: string): this;
-  deployed(): Promise<this>;
+  connect(runner?: ContractRunner | null): LimitOrderBook;
+  waitForDeployment(): Promise<this>;
 
   interface: LimitOrderBookInterface;
 
-  queryFilter<TEvent extends TypedEvent>(
-    event: TypedEventFilter<TEvent>,
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
     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: {
-    CALLBACK_GAS_LIMIT(overrides?: CallOverrides): Promise<[number]>;
-
-    actvDigestPos(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    callbackFunctions(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[string]>;
-
-    cancelOrder(
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  CALLBACK_GAS_LIMIT: TypedContractMethod<[], [bigint], "view">;
+
+  actvDigestPos: TypedContractMethod<[arg0: BytesLike], [bigint], "view">;
+
+  callbackFunctions: TypedContractMethod<[arg0: BytesLike], [string], "view">;
+
+  cancelOrder: TypedContractMethod<
+    [
       _digest: BytesLike,
       _signature: BytesLike,
       _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
+      _publishTimes: BigNumberish[]
+    ],
+    [void],
+    "payable"
+  >;
 
-    digestsOfTrader(
-      arg0: string,
-      arg1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[string]>;
+  digestsOfTrader: TypedContractMethod<
+    [arg0: AddressLike, arg1: BigNumberish],
+    [string],
+    "view"
+  >;
 
-    executeOrders(
+  executeOrders: TypedContractMethod<
+    [
       _digests: BytesLike[],
-      _executorAddr: string,
+      _executorAddr: AddressLike,
       _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
+      _publishTimes: BigNumberish[]
+    ],
+    [void],
+    "payable"
+  >;
 
-    getOrderStatus(
-      _digest: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[number]>;
+  getOrderStatus: TypedContractMethod<[_digest: BytesLike], [bigint], "view">;
 
-    getOrders(
-      trader: string,
-      offset: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<
-      [IClientOrder.ClientOrderStructOutput[]] & {
-        orders: IClientOrder.ClientOrderStructOutput[];
-      }
-    >;
+  getOrders: TypedContractMethod<
+    [trader: AddressLike, offset: BigNumberish, limit: BigNumberish],
+    [IClientOrder.ClientOrderStructOutput[]],
+    "view"
+  >;
 
-    getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+  getTrader: TypedContractMethod<[digest: BytesLike], [string], "view">;
 
-    initialize(
-      _perpetualManagerAddr: string,
+  initialize: TypedContractMethod<
+    [
+      _perpetualManagerAddr: AddressLike,
       _perpetualId: BigNumberish,
-      _iCancelDelaySec: BigNumberish,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
+      _iCancelDelaySec: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
 
-    lastOrderHash(overrides?: CallOverrides): Promise<[string]>;
+  lastOrderHash: TypedContractMethod<[], [string], "view">;
 
-    limitDigestsOfTrader(
-      trader: string,
-      page: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[string[]]>;
+  limitDigestsOfTrader: TypedContractMethod<
+    [trader: AddressLike, page: BigNumberish, limit: BigNumberish],
+    [string[]],
+    "view"
+  >;
 
-    marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
+  marketCloseSwitchTimestamp: TypedContractMethod<[], [bigint], "view">;
 
-    numberOfDigestsOfTrader(
-      trader: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+  numberOfDigestsOfTrader: TypedContractMethod<
+    [trader: AddressLike],
+    [bigint],
+    "view"
+  >;
 
-    orderCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+  orderCount: TypedContractMethod<[], [bigint], "view">;
 
-    orderDependency(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
+  orderDependency: TypedContractMethod<
+    [arg0: BytesLike],
+    [
       [string, string] & {
         parentChildDigest1: string;
         parentChildDigest2: string;
       }
-    >;
+    ],
+    "view"
+  >;
 
-    orderOfDigest(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
+  orderOfDigest: TypedContractMethod<
+    [arg0: BytesLike],
+    [
       [
-        number,
-        number,
-        number,
+        bigint,
+        bigint,
+        bigint,
         string,
-        number,
+        bigint,
         string,
-        number,
-        number,
-        number,
+        bigint,
+        bigint,
+        bigint,
         string,
-        BigNumber,
-        BigNumber,
-        BigNumber,
+        bigint,
+        bigint,
+        bigint,
         string
       ] & {
-        leverageTDR: number;
-        brokerFeeTbps: number;
-        iPerpetualId: number;
+        leverageTDR: bigint;
+        brokerFeeTbps: bigint;
+        iPerpetualId: bigint;
         traderAddr: string;
-        executionTimestamp: number;
+        executionTimestamp: bigint;
         brokerAddr: string;
-        submittedTimestamp: number;
-        flags: number;
-        iDeadline: number;
+        submittedTimestamp: bigint;
+        flags: bigint;
+        iDeadline: bigint;
         executorAddr: string;
-        fAmount: BigNumber;
-        fLimitPrice: BigNumber;
-        fTriggerPrice: BigNumber;
+        fAmount: bigint;
+        fLimitPrice: bigint;
+        fTriggerPrice: bigint;
         brokerSignature: string;
       }
-    >;
+    ],
+    "view"
+  >;
 
-    perpManager(overrides?: CallOverrides): Promise<[string]>;
+  perpManager: TypedContractMethod<[], [string], "view">;
 
-    perpetualId(overrides?: CallOverrides): Promise<[number]>;
+  perpetualId: TypedContractMethod<[], [bigint], "view">;
 
-    pollRange(
-      _from: BigNumberish,
-      _numElements: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<
-      [IClientOrder.ClientOrderStructOutput[], string[], number[]] & {
+  pollRange: TypedContractMethod<
+    [_from: BigNumberish, _numElements: BigNumberish],
+    [
+      [IClientOrder.ClientOrderStructOutput[], string[], bigint[]] & {
         orders: IClientOrder.ClientOrderStructOutput[];
         orderHashes: string[];
-        submittedTs: number[];
+        submittedTs: bigint[];
       }
-    >;
-
-    postOrders(
-      _orders: IClientOrder.ClientOrderStruct[],
-      _signatures: BytesLike[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-  };
-
-  CALLBACK_GAS_LIMIT(overrides?: CallOverrides): Promise<number>;
-
-  actvDigestPos(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
-
-  callbackFunctions(
-    arg0: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  cancelOrder(
-    _digest: BytesLike,
-    _signature: BytesLike,
-    _updateData: BytesLike[],
-    _publishTimes: BigNumberish[],
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  digestsOfTrader(
-    arg0: string,
-    arg1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  executeOrders(
-    _digests: BytesLike[],
-    _executorAddr: string,
-    _updateData: BytesLike[],
-    _publishTimes: BigNumberish[],
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  getOrderStatus(
-    _digest: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
-  getOrders(
-    trader: string,
-    offset: BigNumberish,
-    limit: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<IClientOrder.ClientOrderStructOutput[]>;
-
-  getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
-
-  initialize(
-    _perpetualManagerAddr: string,
-    _perpetualId: BigNumberish,
-    _iCancelDelaySec: BigNumberish,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  lastOrderHash(overrides?: CallOverrides): Promise<string>;
-
-  limitDigestsOfTrader(
-    trader: string,
-    page: BigNumberish,
-    limit: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<string[]>;
-
-  marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
-
-  numberOfDigestsOfTrader(
-    trader: string,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  orderCount(overrides?: CallOverrides): Promise<BigNumber>;
-
-  orderDependency(
-    arg0: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<
-    [string, string] & {
-      parentChildDigest1: string;
-      parentChildDigest2: string;
-    }
-  >;
-
-  orderOfDigest(
-    arg0: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<
-    [
-      number,
-      number,
-      number,
-      string,
-      number,
-      string,
-      number,
-      number,
-      number,
-      string,
-      BigNumber,
-      BigNumber,
-      BigNumber,
-      string
-    ] & {
-      leverageTDR: number;
-      brokerFeeTbps: number;
-      iPerpetualId: number;
-      traderAddr: string;
-      executionTimestamp: number;
-      brokerAddr: string;
-      submittedTimestamp: number;
-      flags: number;
-      iDeadline: number;
-      executorAddr: string;
-      fAmount: BigNumber;
-      fLimitPrice: BigNumber;
-      fTriggerPrice: BigNumber;
-      brokerSignature: string;
-    }
+    ],
+    "view"
   >;
 
-  perpManager(overrides?: CallOverrides): Promise<string>;
-
-  perpetualId(overrides?: CallOverrides): Promise<number>;
-
-  pollRange(
-    _from: BigNumberish,
-    _numElements: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<
-    [IClientOrder.ClientOrderStructOutput[], string[], number[]] & {
-      orders: IClientOrder.ClientOrderStructOutput[];
-      orderHashes: string[];
-      submittedTs: number[];
-    }
+  postOrders: TypedContractMethod<
+    [_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[]],
+    [void],
+    "nonpayable"
   >;
 
-  postOrders(
-    _orders: IClientOrder.ClientOrderStruct[],
-    _signatures: BytesLike[],
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
 
-  callStatic: {
-    CALLBACK_GAS_LIMIT(overrides?: CallOverrides): Promise<number>;
-
-    actvDigestPos(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    callbackFunctions(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
-    cancelOrder(
+  getFunction(
+    nameOrSignature: "CALLBACK_GAS_LIMIT"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "actvDigestPos"
+  ): TypedContractMethod<[arg0: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "callbackFunctions"
+  ): TypedContractMethod<[arg0: BytesLike], [string], "view">;
+  getFunction(
+    nameOrSignature: "cancelOrder"
+  ): TypedContractMethod<
+    [
       _digest: BytesLike,
       _signature: BytesLike,
       _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    digestsOfTrader(
-      arg0: string,
-      arg1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
-    executeOrders(
+      _publishTimes: BigNumberish[]
+    ],
+    [void],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "digestsOfTrader"
+  ): TypedContractMethod<
+    [arg0: AddressLike, arg1: BigNumberish],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "executeOrders"
+  ): TypedContractMethod<
+    [
       _digests: BytesLike[],
-      _executorAddr: string,
+      _executorAddr: AddressLike,
       _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    getOrderStatus(
-      _digest: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<number>;
-
-    getOrders(
-      trader: string,
-      offset: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<IClientOrder.ClientOrderStructOutput[]>;
-
-    getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
-
-    initialize(
-      _perpetualManagerAddr: string,
+      _publishTimes: BigNumberish[]
+    ],
+    [void],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "getOrderStatus"
+  ): TypedContractMethod<[_digest: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getOrders"
+  ): TypedContractMethod<
+    [trader: AddressLike, offset: BigNumberish, limit: BigNumberish],
+    [IClientOrder.ClientOrderStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getTrader"
+  ): TypedContractMethod<[digest: BytesLike], [string], "view">;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<
+    [
+      _perpetualManagerAddr: AddressLike,
       _perpetualId: BigNumberish,
-      _iCancelDelaySec: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    lastOrderHash(overrides?: CallOverrides): Promise<string>;
-
-    limitDigestsOfTrader(
-      trader: string,
-      page: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<string[]>;
-
-    marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
-
-    numberOfDigestsOfTrader(
-      trader: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    orderCount(overrides?: CallOverrides): Promise<BigNumber>;
-
-    orderDependency(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
+      _iCancelDelaySec: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "lastOrderHash"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "limitDigestsOfTrader"
+  ): TypedContractMethod<
+    [trader: AddressLike, page: BigNumberish, limit: BigNumberish],
+    [string[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "marketCloseSwitchTimestamp"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "numberOfDigestsOfTrader"
+  ): TypedContractMethod<[trader: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "orderCount"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "orderDependency"
+  ): TypedContractMethod<
+    [arg0: BytesLike],
+    [
       [string, string] & {
         parentChildDigest1: string;
         parentChildDigest2: string;
       }
-    >;
-
-    orderOfDigest(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "orderOfDigest"
+  ): TypedContractMethod<
+    [arg0: BytesLike],
+    [
       [
-        number,
-        number,
-        number,
+        bigint,
+        bigint,
+        bigint,
         string,
-        number,
+        bigint,
         string,
-        number,
-        number,
-        number,
+        bigint,
+        bigint,
+        bigint,
         string,
-        BigNumber,
-        BigNumber,
-        BigNumber,
+        bigint,
+        bigint,
+        bigint,
         string
       ] & {
-        leverageTDR: number;
-        brokerFeeTbps: number;
-        iPerpetualId: number;
+        leverageTDR: bigint;
+        brokerFeeTbps: bigint;
+        iPerpetualId: bigint;
         traderAddr: string;
-        executionTimestamp: number;
+        executionTimestamp: bigint;
         brokerAddr: string;
-        submittedTimestamp: number;
-        flags: number;
-        iDeadline: number;
+        submittedTimestamp: bigint;
+        flags: bigint;
+        iDeadline: bigint;
         executorAddr: string;
-        fAmount: BigNumber;
-        fLimitPrice: BigNumber;
-        fTriggerPrice: BigNumber;
+        fAmount: bigint;
+        fLimitPrice: bigint;
+        fTriggerPrice: bigint;
         brokerSignature: string;
       }
-    >;
-
-    perpManager(overrides?: CallOverrides): Promise<string>;
-
-    perpetualId(overrides?: CallOverrides): Promise<number>;
-
-    pollRange(
-      _from: BigNumberish,
-      _numElements: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<
-      [IClientOrder.ClientOrderStructOutput[], string[], number[]] & {
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "perpManager"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "perpetualId"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "pollRange"
+  ): TypedContractMethod<
+    [_from: BigNumberish, _numElements: BigNumberish],
+    [
+      [IClientOrder.ClientOrderStructOutput[], string[], bigint[]] & {
         orders: IClientOrder.ClientOrderStructOutput[];
         orderHashes: string[];
-        submittedTs: number[];
+        submittedTs: bigint[];
       }
-    >;
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "postOrders"
+  ): TypedContractMethod<
+    [_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[]],
+    [void],
+    "nonpayable"
+  >;
 
-    postOrders(
-      _orders: IClientOrder.ClientOrderStruct[],
-      _signatures: BytesLike[],
-      overrides?: CallOverrides
-    ): Promise<void>;
-  };
+  getEvent(
+    key: "Callback"
+  ): TypedContractEvent<
+    CallbackEvent.InputTuple,
+    CallbackEvent.OutputTuple,
+    CallbackEvent.OutputObject
+  >;
+  getEvent(
+    key: "ExecutionFailed"
+  ): TypedContractEvent<
+    ExecutionFailedEvent.InputTuple,
+    ExecutionFailedEvent.OutputTuple,
+    ExecutionFailedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PerpetualLimitOrderCreated"
+  ): TypedContractEvent<
+    PerpetualLimitOrderCreatedEvent.InputTuple,
+    PerpetualLimitOrderCreatedEvent.OutputTuple,
+    PerpetualLimitOrderCreatedEvent.OutputObject
+  >;
 
   filters: {
-    "Callback(address,bool,uint32)"(
-      callbackTarget?: null,
-      success?: null,
-      gasLimit?: null
-    ): CallbackEventFilter;
-    Callback(
-      callbackTarget?: null,
-      success?: null,
-      gasLimit?: null
-    ): CallbackEventFilter;
-
-    "ExecutionFailed(uint24,address,bytes32,string)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      digest?: null,
-      reason?: null
-    ): ExecutionFailedEventFilter;
-    ExecutionFailed(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      digest?: null,
-      reason?: null
-    ): ExecutionFailedEventFilter;
-
-    "Initialized(uint8)"(version?: null): InitializedEventFilter;
-    Initialized(version?: null): InitializedEventFilter;
-
-    "PerpetualLimitOrderCreated(uint24,address,address,(uint16,uint16,uint24,address,uint32,address,uint32,uint32,uint32,address,int128,int128,int128,bytes),bytes32)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      brokerAddr?: null,
-      order?: null,
-      digest?: null
-    ): PerpetualLimitOrderCreatedEventFilter;
-    PerpetualLimitOrderCreated(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      brokerAddr?: null,
-      order?: null,
-      digest?: null
-    ): PerpetualLimitOrderCreatedEventFilter;
-  };
-
-  estimateGas: {
-    CALLBACK_GAS_LIMIT(overrides?: CallOverrides): Promise<BigNumber>;
-
-    actvDigestPos(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    callbackFunctions(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    cancelOrder(
-      _digest: BytesLike,
-      _signature: BytesLike,
-      _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    digestsOfTrader(
-      arg0: string,
-      arg1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    executeOrders(
-      _digests: BytesLike[],
-      _executorAddr: string,
-      _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    getOrderStatus(
-      _digest: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getOrders(
-      trader: string,
-      offset: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
-
-    initialize(
-      _perpetualManagerAddr: string,
-      _perpetualId: BigNumberish,
-      _iCancelDelaySec: BigNumberish,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    lastOrderHash(overrides?: CallOverrides): Promise<BigNumber>;
-
-    limitDigestsOfTrader(
-      trader: string,
-      page: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
-
-    numberOfDigestsOfTrader(
-      trader: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    orderCount(overrides?: CallOverrides): Promise<BigNumber>;
-
-    orderDependency(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    orderOfDigest(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    perpManager(overrides?: CallOverrides): Promise<BigNumber>;
-
-    perpetualId(overrides?: CallOverrides): Promise<BigNumber>;
-
-    pollRange(
-      _from: BigNumberish,
-      _numElements: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    postOrders(
-      _orders: IClientOrder.ClientOrderStruct[],
-      _signatures: BytesLike[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-  };
-
-  populateTransaction: {
-    CALLBACK_GAS_LIMIT(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    actvDigestPos(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    callbackFunctions(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    cancelOrder(
-      _digest: BytesLike,
-      _signature: BytesLike,
-      _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    digestsOfTrader(
-      arg0: string,
-      arg1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    executeOrders(
-      _digests: BytesLike[],
-      _executorAddr: string,
-      _updateData: BytesLike[],
-      _publishTimes: BigNumberish[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    getOrderStatus(
-      _digest: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getOrders(
-      trader: string,
-      offset: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getTrader(
-      digest: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    initialize(
-      _perpetualManagerAddr: string,
-      _perpetualId: BigNumberish,
-      _iCancelDelaySec: BigNumberish,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    lastOrderHash(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    limitDigestsOfTrader(
-      trader: string,
-      page: BigNumberish,
-      limit: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    marketCloseSwitchTimestamp(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    numberOfDigestsOfTrader(
-      trader: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    orderCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    orderDependency(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    orderOfDigest(
-      arg0: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    perpManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    "Callback(address,bool,uint32)": TypedContractEvent<
+      CallbackEvent.InputTuple,
+      CallbackEvent.OutputTuple,
+      CallbackEvent.OutputObject
+    >;
+    Callback: TypedContractEvent<
+      CallbackEvent.InputTuple,
+      CallbackEvent.OutputTuple,
+      CallbackEvent.OutputObject
+    >;
 
-    perpetualId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    "ExecutionFailed(uint24,address,bytes32,string)": TypedContractEvent<
+      ExecutionFailedEvent.InputTuple,
+      ExecutionFailedEvent.OutputTuple,
+      ExecutionFailedEvent.OutputObject
+    >;
+    ExecutionFailed: TypedContractEvent<
+      ExecutionFailedEvent.InputTuple,
+      ExecutionFailedEvent.OutputTuple,
+      ExecutionFailedEvent.OutputObject
+    >;
 
-    pollRange(
-      _from: BigNumberish,
-      _numElements: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
+    "Initialized(uint8)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
 
-    postOrders(
-      _orders: IClientOrder.ClientOrderStruct[],
-      _signatures: BytesLike[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
+    "PerpetualLimitOrderCreated(uint24,address,address,tuple,bytes32)": TypedContractEvent<
+      PerpetualLimitOrderCreatedEvent.InputTuple,
+      PerpetualLimitOrderCreatedEvent.OutputTuple,
+      PerpetualLimitOrderCreatedEvent.OutputObject
+    >;
+    PerpetualLimitOrderCreated: TypedContractEvent<
+      PerpetualLimitOrderCreatedEvent.InputTuple,
+      PerpetualLimitOrderCreatedEvent.OutputTuple,
+      PerpetualLimitOrderCreatedEvent.OutputObject
+    >;
   };
 }