@d8x/perpetuals-sdk 2.6.22 → 2.6.23

package/dist/cjs/contracts/lean0/IPerpetualManager.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IPerpetualManager.js.map

package/dist/cjs/contracts/lean0/IPerpetualManager.js.map

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

package/dist/cjs/contracts/lean0/LimitOrderBook.d.ts

@@ -0,0 +1,533 @@
+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;
+        executorAddr: 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;
+        executorAddr: 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;
+        callbackTarget: string;
+    };
+    type ClientOrderStructOutput = [
+        number,
+        BigNumber,
+        number,
+        number,
+        number,
+        number,
+        string,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        string,
+        number,
+        string,
+        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;
+        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;
+    };
+    getFunction(nameOrSignatureOrTopic: "CALLBACK_GAS_LIMIT" | "actvDigestPos" | "callbackFunctions" | "cancelOrder" | "digestsOfTrader" | "executeOrders" | "getOrderStatus" | "getOrders" | "getTrader" | "initialize" | "lastOrderHash" | "limitDigestsOfTrader" | "marketCloseSwitchTimestamp" | "numberOfDigestsOfTrader" | "orderCount" | "orderDependency" | "orderOfDigest" | "perpManager" | "perpetualId" | "pollRange" | "postOrders"): FunctionFragment;
+    encodeFunctionData(functionFragment: "CALLBACK_GAS_LIMIT", values?: undefined): string;
+    encodeFunctionData(functionFragment: "actvDigestPos", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "callbackFunctions", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "cancelOrder", values: [BytesLike, BytesLike, BytesLike[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "digestsOfTrader", values: [string, 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: "getTrader", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "lastOrderHash", values?: undefined): string;
+    encodeFunctionData(functionFragment: "limitDigestsOfTrader", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "marketCloseSwitchTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "numberOfDigestsOfTrader", values: [string]): string;
+    encodeFunctionData(functionFragment: "orderCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "orderDependency", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "orderOfDigest", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "perpManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "perpetualId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pollRange", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "postOrders", values: [IClientOrder.ClientOrderStruct[], BytesLike[]]): string;
+    decodeFunctionResult(functionFragment: "CALLBACK_GAS_LIMIT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "actvDigestPos", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "callbackFunctions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "digestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOrderStatus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastOrderHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "limitDigestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "marketCloseSwitchTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "numberOfDigestsOfTrader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderDependency", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orderOfDigest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpetualId", data: BytesLike): 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 type CallbackEvent = TypedEvent<[
+    string,
+    boolean,
+    number
+], CallbackEventObject>;
+export type CallbackEventFilter = TypedEventFilter<CallbackEvent>;
+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 InitializedEventObject {
+    version: number;
+}
+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 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: {
+        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[]
+        ] & {
+            orders: 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;
+        }>;
+        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(_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;
+    }>;
+    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(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        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?: CallOverrides): Promise<void>;
+        digestsOfTrader(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        executeOrders(_digests: BytesLike[], _executorAddr: 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[]>;
+        getTrader(digest: BytesLike, overrides?: CallOverrides): Promise<string>;
+        initialize(_perpetualManagerAddr: string, _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<[
+            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;
+        }>;
+        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(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: CallOverrides): Promise<void>;
+    };
+    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>;
+        perpetualId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pollRange(_from: BigNumberish, _numElements: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        postOrders(_orders: IClientOrder.ClientOrderStruct[], _signatures: BytesLike[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/cjs/contracts/lean0/LimitOrderBook.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=LimitOrderBook.js.map

package/dist/cjs/contracts/lean0/LimitOrderBook.js.map

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