@d8x/perpetuals-sdk 0.7.2 → 0.7.4

package/dist/esm/contracts/zkevmTestnet/IPerpetualManager.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IPerpetualManager.js.map

package/dist/esm/contracts/zkevmTestnet/IPerpetualManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPerpetualManager.js","sourceRoot":"","sources":["../../../../src/contracts/zkevmTestnet/IPerpetualManager.ts"],"names":[],"mappings":""}

package/dist/esm/contracts/zkevmTestnet/LimitOrderBook.d.ts

@@ -0,0 +1,600 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../common";
+export declare namespace IPerpetualOrder {
+    type OrderStruct = {
+        leverageTDR: BigNumberish;
+        brokerFeeTbps: BigNumberish;
+        iPerpetualId: BigNumberish;
+        traderAddr: string;
+        executionTimestamp: BigNumberish;
+        brokerAddr: string;
+        submittedTimestamp: BigNumberish;
+        flags: BigNumberish;
+        iDeadline: BigNumberish;
+        referrerAddr: string;
+        fAmount: BigNumberish;
+        fLimitPrice: BigNumberish;
+        fTriggerPrice: BigNumberish;
+        brokerSignature: BytesLike;
+    };
+    type OrderStructOutput = [
+        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;
+        referrerAddr: string;
+        fAmount: BigNumber;
+        fLimitPrice: BigNumber;
+        fTriggerPrice: BigNumber;
+        brokerSignature: string;
+    };
+}
+export declare namespace IClientOrder {
+    type ClientOrderStruct = {
+        iPerpetualId: BigNumberish;
+        fLimitPrice: BigNumberish;
+        leverageTDR: BigNumberish;
+        executionTimestamp: BigNumberish;
+        flags: BigNumberish;
+        iDeadline: BigNumberish;
+        brokerAddr: string;
+        fTriggerPrice: BigNumberish;
+        fAmount: BigNumberish;
+        parentChildDigest1: BytesLike;
+        traderAddr: string;
+        parentChildDigest2: BytesLike;
+        brokerFeeTbps: BigNumberish;
+        brokerSignature: BytesLike;
+    };
+    type ClientOrderStructOutput = [
+        number,
+        BigNumber,
+        number,
+        number,
+        number,
+        number,
+        string,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        string,
+        number,
+        string
+    ] & {
+        iPerpetualId: number;
+        fLimitPrice: BigNumber;
+        leverageTDR: number;
+        executionTimestamp: number;
+        flags: number;
+        iDeadline: number;
+        brokerAddr: string;
+        fTriggerPrice: BigNumber;
+        fAmount: BigNumber;
+        parentChildDigest1: string;
+        traderAddr: string;
+        parentChildDigest2: string;
+        brokerFeeTbps: number;
+        brokerSignature: string;
+    };
+}
+export interface LimitOrderBookInterface extends utils.Interface {
+    functions: {
+        "addExecutor(address)": FunctionFragment;
+        "allDigests(uint256)": FunctionFragment;
+        "allLimitDigests(uint256,uint256)": FunctionFragment;
+        "approvedExecutor(address)": FunctionFragment;
+        "cancelOrder(bytes32,bytes,bytes[],uint64[])": FunctionFragment;
+        "digestsOfTrader(address,uint256)": FunctionFragment;
+        "executeOrder(bytes32,address,bytes[],uint64[])": FunctionFragment;
+        "executeOrders(bytes32[],address,bytes[],uint64[])": FunctionFragment;
+        "getOrderStatus(bytes32)": FunctionFragment;
+        "getOrders(address,uint256,uint256)": FunctionFragment;
+        "getSignature(bytes32)": FunctionFragment;
+        "getTrader(bytes32)": FunctionFragment;
+        "lastOrderHash()": FunctionFragment;
+        "limitDigestsOfTrader(address,uint256,uint256)": FunctionFragment;
+        "marketCloseSwitchTimestamp()": FunctionFragment;
+        "nextOrderHash(bytes32)": FunctionFragment;
+        "numberOfAllDigests()": FunctionFragment;
+        "numberOfDigestsOfTrader(address)": FunctionFragment;
+        "numberOfOrderBookDigests()": FunctionFragment;
+        "orderCount()": FunctionFragment;
+        "orderDependency(bytes32)": FunctionFragment;
+        "orderOfDigest(bytes32)": FunctionFragment;
+        "orderSignature(bytes32)": FunctionFragment;
+        "perpManager()": FunctionFragment;
+        "perpetualId()": FunctionFragment;
+        "pollLimitOrders(bytes32,uint256)": FunctionFragment;
+        "postOrder((uint24,int128,uint16,uint32,uint32,uint32,address,int128,int128,bytes32,address,bytes32,uint16,bytes),bytes)": FunctionFragment;
+        "postOrders((uint24,int128,uint16,uint32,uint32,uint32,address,int128,int128,bytes32,address,bytes32,uint16,bytes)[],bytes[])": FunctionFragment;
+        "prevOrderHash(bytes32)": FunctionFragment;
+        "removeExecutor(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "addExecutor" | "allDigests" | "allLimitDigests" | "approvedExecutor" | "cancelOrder" | "digestsOfTrader" | "executeOrder" | "executeOrders" | "getOrderStatus" | "getOrders" | "getSignature" | "getTrader" | "lastOrderHash" | "limitDigestsOfTrader" | "marketCloseSwitchTimestamp" | "nextOrderHash" | "numberOfAllDigests" | "numberOfDigestsOfTrader" | "numberOfOrderBookDigests" | "orderCount" | "orderDependency" | "orderOfDigest" | "orderSignature" | "perpManager" | "perpetualId" | "pollLimitOrders" | "postOrder" | "postOrders" | "prevOrderHash" | "removeExecutor"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addExecutor", values: [string]): string;
+    encodeFunctionData(functionFragment: "allDigests", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allLimitDigests", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "approvedExecutor", values: [string]): string;
+    encodeFunctionData(functionFragment: "cancelOrder", values: [BytesLike, BytesLike, BytesLike[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "digestsOfTrader", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "executeOrder", values: [BytesLike, string, BytesLike[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "executeOrders", values: [BytesLike[], string, BytesLike[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "getOrderStatus", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getOrders", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getSignature", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getTrader", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "lastOrderHash", values?: undefined): string;
+    encodeFunctionData(functionFragment: "limitDigestsOfTrader", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "marketCloseSwitchTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nextOrderHash", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "numberOfAllDigests", values?: undefined): string;
+    encodeFunctionData(functionFragment: "numberOfDigestsOfTrader", values: [string]): string;
+    encodeFunctionData(functionFragment: "numberOfOrderBookDigests", values?: undefined): string;
+    encodeFunctionData(functionFragment: "orderCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "orderDependency", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "orderOfDigest", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "orderSignature", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "perpManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "perpetualId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pollLimitOrders", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "postOrder", values: [IClientOrder.ClientOrderStruct, BytesLike]): string;
+    encodeFunctionData(functionFragment: "postOrders", values: [IClientOrder.ClientOrderStruct[], BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "prevOrderHash", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "removeExecutor", values: [string]): string;
+    decodeFunctionResult(functionFragment: "addExecutor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allDigests", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allLimitDigests", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approvedExecutor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "digestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOrderStatus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastOrderHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "limitDigestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "marketCloseSwitchTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nextOrderHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "numberOfAllDigests", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "numberOfDigestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "numberOfOrderBookDigests", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderDependency", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderOfDigest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpetualId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pollLimitOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "postOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "postOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "prevOrderHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeExecutor", data: BytesLike): Result;
+    events: {
+        "ExecutionFailed(uint24,address,bytes32,string)": EventFragment;
+        "PerpetualLimitOrderCreated(uint24,address,address,tuple,bytes32)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ExecutionFailed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PerpetualLimitOrderCreated"): EventFragment;
+}
+export interface ExecutionFailedEventObject {
+    perpetualId: number;
+    trader: string;
+    digest: string;
+    reason: string;
+}
+export type ExecutionFailedEvent = TypedEvent<[
+    number,
+    string,
+    string,
+    string
+], ExecutionFailedEventObject>;
+export type ExecutionFailedEventFilter = TypedEventFilter<ExecutionFailedEvent>;
+export interface PerpetualLimitOrderCreatedEventObject {
+    perpetualId: number;
+    trader: string;
+    brokerAddr: string;
+    order: IPerpetualOrder.OrderStructOutput;
+    digest: string;
+}
+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>;
+    interface: LimitOrderBookInterface;
+    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: {
+        addExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        allDigests(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        allLimitDigests(page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<[string[]]>;
+        approvedExecutor(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
+        cancelOrder(_digest: BytesLike, _signature: BytesLike, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        digestsOfTrader(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        executeOrder(_digest: BytesLike, _referrerAddr: string, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        executeOrders(_digests: BytesLike[], _referrerAddr: 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[]
+        ] & {
+            orders: IClientOrder.ClientOrderStructOutput[];
+        }>;
+        getSignature(digest: BytesLike, overrides?: CallOverrides): Promise<[string] & {
+            signature: string;
+        }>;
+        getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<[string] & {
+            trader: string;
+        }>;
+        lastOrderHash(overrides?: CallOverrides): Promise<[string]>;
+        limitDigestsOfTrader(trader: string, page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<[string[]]>;
+        marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
+        nextOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        numberOfAllDigests(overrides?: CallOverrides): Promise<[BigNumber]>;
+        numberOfDigestsOfTrader(trader: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        numberOfOrderBookDigests(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;
+            referrerAddr: string;
+            fAmount: BigNumber;
+            fLimitPrice: BigNumber;
+            fTriggerPrice: BigNumber;
+            brokerSignature: string;
+        }>;
+        orderSignature(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        perpManager(overrides?: CallOverrides): Promise<[string]>;
+        perpetualId(overrides?: CallOverrides): Promise<[number]>;
+        pollLimitOrders(_startAfter: BytesLike, _numElements: BigNumberish, overrides?: CallOverrides): Promise<[
+            IClientOrder.ClientOrderStructOutput[],
+            string[]
+        ] & {
+            orders: IClientOrder.ClientOrderStructOutput[];
+            orderHashes: string[];
+        }>;
+        postOrder(_order: IClientOrder.ClientOrderStruct, _signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        prevOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        removeExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    addExecutor(_executor: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    allDigests(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    allLimitDigests(page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+    approvedExecutor(arg0: string, overrides?: CallOverrides): Promise<boolean>;
+    cancelOrder(_digest: BytesLike, _signature: BytesLike, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    digestsOfTrader(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    executeOrder(_digest: BytesLike, _referrerAddr: string, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    executeOrders(_digests: BytesLike[], _referrerAddr: 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[]>;
+    getSignature(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
+    getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
+    lastOrderHash(overrides?: CallOverrides): Promise<string>;
+    limitDigestsOfTrader(trader: string, page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+    marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    nextOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    numberOfAllDigests(overrides?: CallOverrides): Promise<BigNumber>;
+    numberOfDigestsOfTrader(trader: string, overrides?: CallOverrides): Promise<BigNumber>;
+    numberOfOrderBookDigests(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;
+        referrerAddr: string;
+        fAmount: BigNumber;
+        fLimitPrice: BigNumber;
+        fTriggerPrice: BigNumber;
+        brokerSignature: string;
+    }>;
+    orderSignature(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    perpManager(overrides?: CallOverrides): Promise<string>;
+    perpetualId(overrides?: CallOverrides): Promise<number>;
+    pollLimitOrders(_startAfter: BytesLike, _numElements: BigNumberish, overrides?: CallOverrides): Promise<[
+        IClientOrder.ClientOrderStructOutput[],
+        string[]
+    ] & {
+        orders: IClientOrder.ClientOrderStructOutput[];
+        orderHashes: string[];
+    }>;
+    postOrder(_order: IClientOrder.ClientOrderStruct, _signature: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    prevOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    removeExecutor(_executor: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        addExecutor(_executor: string, overrides?: CallOverrides): Promise<void>;
+        allDigests(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        allLimitDigests(page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+        approvedExecutor(arg0: string, overrides?: CallOverrides): Promise<boolean>;
+        cancelOrder(_digest: BytesLike, _signature: BytesLike, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: CallOverrides): Promise<void>;
+        digestsOfTrader(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        executeOrder(_digest: BytesLike, _referrerAddr: string, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: CallOverrides): Promise<void>;
+        executeOrders(_digests: BytesLike[], _referrerAddr: string, _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[]>;
+        getSignature(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
+        getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
+        lastOrderHash(overrides?: CallOverrides): Promise<string>;
+        limitDigestsOfTrader(trader: string, page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+        marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        nextOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        numberOfAllDigests(overrides?: CallOverrides): Promise<BigNumber>;
+        numberOfDigestsOfTrader(trader: string, overrides?: CallOverrides): Promise<BigNumber>;
+        numberOfOrderBookDigests(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;
+            referrerAddr: string;
+            fAmount: BigNumber;
+            fLimitPrice: BigNumber;
+            fTriggerPrice: BigNumber;
+            brokerSignature: string;
+        }>;
+        orderSignature(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        perpManager(overrides?: CallOverrides): Promise<string>;
+        perpetualId(overrides?: CallOverrides): Promise<number>;
+        pollLimitOrders(_startAfter: BytesLike, _numElements: BigNumberish, overrides?: CallOverrides): Promise<[
+            IClientOrder.ClientOrderStructOutput[],
+            string[]
+        ] & {
+            orders: IClientOrder.ClientOrderStructOutput[];
+            orderHashes: string[];
+        }>;
+        postOrder(_order: IClientOrder.ClientOrderStruct, _signature: BytesLike, overrides?: CallOverrides): Promise<void>;
+        postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: CallOverrides): Promise<void>;
+        prevOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        removeExecutor(_executor: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "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;
+        "PerpetualLimitOrderCreated(uint24,address,address,tuple,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: {
+        addExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        allDigests(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        allLimitDigests(page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        approvedExecutor(arg0: string, 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>;
+        executeOrder(_digest: BytesLike, _referrerAddr: string, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        executeOrders(_digests: BytesLike[], _referrerAddr: 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>;
+        getSignature(digest: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        lastOrderHash(overrides?: CallOverrides): Promise<BigNumber>;
+        limitDigestsOfTrader(trader: string, page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        nextOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        numberOfAllDigests(overrides?: CallOverrides): Promise<BigNumber>;
+        numberOfDigestsOfTrader(trader: string, overrides?: CallOverrides): Promise<BigNumber>;
+        numberOfOrderBookDigests(overrides?: CallOverrides): Promise<BigNumber>;
+        orderCount(overrides?: CallOverrides): Promise<BigNumber>;
+        orderDependency(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        orderOfDigest(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        orderSignature(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        perpManager(overrides?: CallOverrides): Promise<BigNumber>;
+        perpetualId(overrides?: CallOverrides): Promise<BigNumber>;
+        pollLimitOrders(_startAfter: BytesLike, _numElements: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        postOrder(_order: IClientOrder.ClientOrderStruct, _signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        prevOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        removeExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        addExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        allDigests(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allLimitDigests(page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        approvedExecutor(arg0: string, 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>;
+        executeOrder(_digest: BytesLike, _referrerAddr: string, _updateData: BytesLike[], _publishTimes: BigNumberish[], overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        executeOrders(_digests: BytesLike[], _referrerAddr: 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>;
+        getSignature(digest: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lastOrderHash(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        limitDigestsOfTrader(trader: string, page: BigNumberish, limit: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        marketCloseSwitchTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        nextOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        numberOfAllDigests(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        numberOfDigestsOfTrader(trader: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        numberOfOrderBookDigests(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        orderCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        orderDependency(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        orderOfDigest(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        orderSignature(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        perpManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        perpetualId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pollLimitOrders(_startAfter: BytesLike, _numElements: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        postOrder(_order: IClientOrder.ClientOrderStruct, _signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        prevOrderHash(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeExecutor(_executor: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/contracts/zkevmTestnet/LimitOrderBook.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LimitOrderBook.js.map

package/dist/esm/contracts/zkevmTestnet/LimitOrderBook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LimitOrderBook.js","sourceRoot":"","sources":["../../../../src/contracts/zkevmTestnet/LimitOrderBook.ts"],"names":[],"mappings":""}