ccxt 4.5.18 → 4.5.19

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/clob_pair.d.ts

@@ -0,0 +1,127 @@
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/** Status of the CLOB. */
+export declare enum ClobPair_Status {
+    /** STATUS_UNSPECIFIED - Default value. This value is invalid and unused. */
+    STATUS_UNSPECIFIED = 0,
+    /** STATUS_ACTIVE - STATUS_ACTIVE represents an active clob pair. */
+    STATUS_ACTIVE = 1,
+    /**
+     * STATUS_PAUSED - STATUS_PAUSED behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    STATUS_PAUSED = 2,
+    /**
+     * STATUS_CANCEL_ONLY - STATUS_CANCEL_ONLY behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    STATUS_CANCEL_ONLY = 3,
+    /**
+     * STATUS_POST_ONLY - STATUS_POST_ONLY behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    STATUS_POST_ONLY = 4,
+    /**
+     * STATUS_INITIALIZING - STATUS_INITIALIZING represents a newly-added clob pair.
+     * Clob pairs in this state only accept orders which are
+     * both short-term and post-only.
+     */
+    STATUS_INITIALIZING = 5,
+    /**
+     * STATUS_FINAL_SETTLEMENT - STATUS_FINAL_SETTLEMENT represents a clob pair which is deactivated
+     * and trading has ceased. All open positions will be closed by the
+     * protocol. Open stateful orders will be cancelled. Open short-term
+     * orders will be left to expire.
+     */
+    STATUS_FINAL_SETTLEMENT = 6,
+    UNRECOGNIZED = -1
+}
+export declare const ClobPair_StatusSDKType: typeof ClobPair_Status;
+export declare function clobPair_StatusFromJSON(object: any): ClobPair_Status;
+export declare function clobPair_StatusToJSON(object: ClobPair_Status): string;
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Perpetual product.
+ */
+export interface PerpetualClobMetadata {
+    /** Id of the Perpetual the CLOB allows trading of. */
+    perpetualId: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Perpetual product.
+ */
+export interface PerpetualClobMetadataSDKType {
+    perpetual_id: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Spot product.
+ */
+export interface SpotClobMetadata {
+    /** Id of the base Asset in the trading pair. */
+    baseAssetId: number;
+    /** Id of the quote Asset in the trading pair. */
+    quoteAssetId: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Spot product.
+ */
+export interface SpotClobMetadataSDKType {
+    base_asset_id: number;
+    quote_asset_id: number;
+}
+/**
+ * ClobPair represents a single CLOB pair for a given product
+ * in state.
+ */
+export interface ClobPair {
+    /** ID of the orderbook that stores all resting liquidity for this CLOB. */
+    id: number;
+    perpetualClobMetadata?: PerpetualClobMetadata;
+    spotClobMetadata?: SpotClobMetadata;
+    /** Minimum increment in the size of orders on the CLOB, in base quantums. */
+    stepBaseQuantums: Long;
+    /**
+     * Defines the tick size of the orderbook by defining how many subticks
+     * are in one tick. That is, the subticks of any valid order must be a
+     * multiple of this value. Generally this value should start `>= 100`to
+     * allow room for decreasing it.
+     */
+    subticksPerTick: number;
+    /**
+     * `10^Exponent` gives the number of QuoteQuantums traded per BaseQuantum
+     * per Subtick.
+     */
+    quantumConversionExponent: number;
+    status: ClobPair_Status;
+}
+/**
+ * ClobPair represents a single CLOB pair for a given product
+ * in state.
+ */
+export interface ClobPairSDKType {
+    id: number;
+    perpetual_clob_metadata?: PerpetualClobMetadataSDKType;
+    spot_clob_metadata?: SpotClobMetadataSDKType;
+    step_base_quantums: Long;
+    subticks_per_tick: number;
+    quantum_conversion_exponent: number;
+    status: ClobPair_Status;
+}
+export declare const PerpetualClobMetadata: {
+    encode(message: PerpetualClobMetadata, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualClobMetadata;
+    fromPartial(object: DeepPartial<PerpetualClobMetadata>): PerpetualClobMetadata;
+};
+export declare const SpotClobMetadata: {
+    encode(message: SpotClobMetadata, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SpotClobMetadata;
+    fromPartial(object: DeepPartial<SpotClobMetadata>): SpotClobMetadata;
+};
+export declare const ClobPair: {
+    encode(message: ClobPair, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ClobPair;
+    fromPartial(object: DeepPartial<ClobPair>): ClobPair;
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/clob_pair.js

@@ -0,0 +1,251 @@
+import _m0 from "protobufjs/minimal.js";
+import { Long } from "../../helpers.js";
+/** Status of the CLOB. */
+export var ClobPair_Status;
+(function (ClobPair_Status) {
+    /** STATUS_UNSPECIFIED - Default value. This value is invalid and unused. */
+    ClobPair_Status[ClobPair_Status["STATUS_UNSPECIFIED"] = 0] = "STATUS_UNSPECIFIED";
+    /** STATUS_ACTIVE - STATUS_ACTIVE represents an active clob pair. */
+    ClobPair_Status[ClobPair_Status["STATUS_ACTIVE"] = 1] = "STATUS_ACTIVE";
+    /**
+     * STATUS_PAUSED - STATUS_PAUSED behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    ClobPair_Status[ClobPair_Status["STATUS_PAUSED"] = 2] = "STATUS_PAUSED";
+    /**
+     * STATUS_CANCEL_ONLY - STATUS_CANCEL_ONLY behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    ClobPair_Status[ClobPair_Status["STATUS_CANCEL_ONLY"] = 3] = "STATUS_CANCEL_ONLY";
+    /**
+     * STATUS_POST_ONLY - STATUS_POST_ONLY behavior is unfinalized.
+     * TODO(DEC-600): update this documentation.
+     */
+    ClobPair_Status[ClobPair_Status["STATUS_POST_ONLY"] = 4] = "STATUS_POST_ONLY";
+    /**
+     * STATUS_INITIALIZING - STATUS_INITIALIZING represents a newly-added clob pair.
+     * Clob pairs in this state only accept orders which are
+     * both short-term and post-only.
+     */
+    ClobPair_Status[ClobPair_Status["STATUS_INITIALIZING"] = 5] = "STATUS_INITIALIZING";
+    /**
+     * STATUS_FINAL_SETTLEMENT - STATUS_FINAL_SETTLEMENT represents a clob pair which is deactivated
+     * and trading has ceased. All open positions will be closed by the
+     * protocol. Open stateful orders will be cancelled. Open short-term
+     * orders will be left to expire.
+     */
+    ClobPair_Status[ClobPair_Status["STATUS_FINAL_SETTLEMENT"] = 6] = "STATUS_FINAL_SETTLEMENT";
+    ClobPair_Status[ClobPair_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ClobPair_Status || (ClobPair_Status = {}));
+export const ClobPair_StatusSDKType = ClobPair_Status;
+export function clobPair_StatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STATUS_UNSPECIFIED":
+            return ClobPair_Status.STATUS_UNSPECIFIED;
+        case 1:
+        case "STATUS_ACTIVE":
+            return ClobPair_Status.STATUS_ACTIVE;
+        case 2:
+        case "STATUS_PAUSED":
+            return ClobPair_Status.STATUS_PAUSED;
+        case 3:
+        case "STATUS_CANCEL_ONLY":
+            return ClobPair_Status.STATUS_CANCEL_ONLY;
+        case 4:
+        case "STATUS_POST_ONLY":
+            return ClobPair_Status.STATUS_POST_ONLY;
+        case 5:
+        case "STATUS_INITIALIZING":
+            return ClobPair_Status.STATUS_INITIALIZING;
+        case 6:
+        case "STATUS_FINAL_SETTLEMENT":
+            return ClobPair_Status.STATUS_FINAL_SETTLEMENT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ClobPair_Status.UNRECOGNIZED;
+    }
+}
+export function clobPair_StatusToJSON(object) {
+    switch (object) {
+        case ClobPair_Status.STATUS_UNSPECIFIED:
+            return "STATUS_UNSPECIFIED";
+        case ClobPair_Status.STATUS_ACTIVE:
+            return "STATUS_ACTIVE";
+        case ClobPair_Status.STATUS_PAUSED:
+            return "STATUS_PAUSED";
+        case ClobPair_Status.STATUS_CANCEL_ONLY:
+            return "STATUS_CANCEL_ONLY";
+        case ClobPair_Status.STATUS_POST_ONLY:
+            return "STATUS_POST_ONLY";
+        case ClobPair_Status.STATUS_INITIALIZING:
+            return "STATUS_INITIALIZING";
+        case ClobPair_Status.STATUS_FINAL_SETTLEMENT:
+            return "STATUS_FINAL_SETTLEMENT";
+        case ClobPair_Status.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBasePerpetualClobMetadata() {
+    return {
+        perpetualId: 0
+    };
+}
+export const PerpetualClobMetadata = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.perpetualId !== 0) {
+            writer.uint32(8).uint32(message.perpetualId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePerpetualClobMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.perpetualId = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePerpetualClobMetadata();
+        message.perpetualId = object.perpetualId ?? 0;
+        return message;
+    }
+};
+function createBaseSpotClobMetadata() {
+    return {
+        baseAssetId: 0,
+        quoteAssetId: 0
+    };
+}
+export const SpotClobMetadata = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.baseAssetId !== 0) {
+            writer.uint32(8).uint32(message.baseAssetId);
+        }
+        if (message.quoteAssetId !== 0) {
+            writer.uint32(16).uint32(message.quoteAssetId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSpotClobMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.baseAssetId = reader.uint32();
+                    break;
+                case 2:
+                    message.quoteAssetId = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSpotClobMetadata();
+        message.baseAssetId = object.baseAssetId ?? 0;
+        message.quoteAssetId = object.quoteAssetId ?? 0;
+        return message;
+    }
+};
+function createBaseClobPair() {
+    return {
+        id: 0,
+        perpetualClobMetadata: undefined,
+        spotClobMetadata: undefined,
+        stepBaseQuantums: Long.UZERO,
+        subticksPerTick: 0,
+        quantumConversionExponent: 0,
+        status: 0
+    };
+}
+export const ClobPair = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== 0) {
+            writer.uint32(8).uint32(message.id);
+        }
+        if (message.perpetualClobMetadata !== undefined) {
+            PerpetualClobMetadata.encode(message.perpetualClobMetadata, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.spotClobMetadata !== undefined) {
+            SpotClobMetadata.encode(message.spotClobMetadata, writer.uint32(26).fork()).ldelim();
+        }
+        if (!message.stepBaseQuantums.isZero()) {
+            writer.uint32(32).uint64(message.stepBaseQuantums);
+        }
+        if (message.subticksPerTick !== 0) {
+            writer.uint32(40).uint32(message.subticksPerTick);
+        }
+        if (message.quantumConversionExponent !== 0) {
+            writer.uint32(48).sint32(message.quantumConversionExponent);
+        }
+        if (message.status !== 0) {
+            writer.uint32(56).int32(message.status);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseClobPair();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint32();
+                    break;
+                case 2:
+                    message.perpetualClobMetadata = PerpetualClobMetadata.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.spotClobMetadata = SpotClobMetadata.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.stepBaseQuantums = reader.uint64();
+                    break;
+                case 5:
+                    message.subticksPerTick = reader.uint32();
+                    break;
+                case 6:
+                    message.quantumConversionExponent = reader.sint32();
+                    break;
+                case 7:
+                    message.status = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseClobPair();
+        message.id = object.id ?? 0;
+        message.perpetualClobMetadata = object.perpetualClobMetadata !== undefined && object.perpetualClobMetadata !== null ? PerpetualClobMetadata.fromPartial(object.perpetualClobMetadata) : undefined;
+        message.spotClobMetadata = object.spotClobMetadata !== undefined && object.spotClobMetadata !== null ? SpotClobMetadata.fromPartial(object.spotClobMetadata) : undefined;
+        message.stepBaseQuantums = object.stepBaseQuantums !== undefined && object.stepBaseQuantums !== null ? Long.fromValue(object.stepBaseQuantums) : Long.UZERO;
+        message.subticksPerTick = object.subticksPerTick ?? 0;
+        message.quantumConversionExponent = object.quantumConversionExponent ?? 0;
+        message.status = object.status ?? 0;
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/equity_tier_limit_config.d.ts

@@ -0,0 +1,48 @@
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * Defines the set of equity tiers to limit how many open orders
+ * a subaccount is allowed to have.
+ */
+export interface EquityTierLimitConfiguration {
+    /**
+     * How many short term stateful orders are allowed per equity tier.
+     * Specifying 0 values disables this limit.
+     */
+    shortTermOrderEquityTiers: EquityTierLimit[];
+    /**
+     * How many open stateful orders are allowed per equity tier.
+     * Specifying 0 values disables this limit.
+     */
+    statefulOrderEquityTiers: EquityTierLimit[];
+}
+/**
+ * Defines the set of equity tiers to limit how many open orders
+ * a subaccount is allowed to have.
+ */
+export interface EquityTierLimitConfigurationSDKType {
+    short_term_order_equity_tiers: EquityTierLimitSDKType[];
+    stateful_order_equity_tiers: EquityTierLimitSDKType[];
+}
+/** Defines an equity tier limit. */
+export interface EquityTierLimit {
+    /** The total net collateral in USDC quote quantums of equity required. */
+    usdTncRequired: Uint8Array;
+    /** What the limit is for `usd_tnc_required`. */
+    limit: number;
+}
+/** Defines an equity tier limit. */
+export interface EquityTierLimitSDKType {
+    usd_tnc_required: Uint8Array;
+    limit: number;
+}
+export declare const EquityTierLimitConfiguration: {
+    encode(message: EquityTierLimitConfiguration, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EquityTierLimitConfiguration;
+    fromPartial(object: DeepPartial<EquityTierLimitConfiguration>): EquityTierLimitConfiguration;
+};
+export declare const EquityTierLimit: {
+    encode(message: EquityTierLimit, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EquityTierLimit;
+    fromPartial(object: DeepPartial<EquityTierLimit>): EquityTierLimit;
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/equity_tier_limit_config.js

@@ -0,0 +1,87 @@
+import _m0 from "protobufjs/minimal.js";
+function createBaseEquityTierLimitConfiguration() {
+    return {
+        shortTermOrderEquityTiers: [],
+        statefulOrderEquityTiers: []
+    };
+}
+export const EquityTierLimitConfiguration = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.shortTermOrderEquityTiers) {
+            EquityTierLimit.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.statefulOrderEquityTiers) {
+            EquityTierLimit.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEquityTierLimitConfiguration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.shortTermOrderEquityTiers.push(EquityTierLimit.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.statefulOrderEquityTiers.push(EquityTierLimit.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEquityTierLimitConfiguration();
+        message.shortTermOrderEquityTiers = object.shortTermOrderEquityTiers?.map(e => EquityTierLimit.fromPartial(e)) || [];
+        message.statefulOrderEquityTiers = object.statefulOrderEquityTiers?.map(e => EquityTierLimit.fromPartial(e)) || [];
+        return message;
+    }
+};
+function createBaseEquityTierLimit() {
+    return {
+        usdTncRequired: new Uint8Array(),
+        limit: 0
+    };
+}
+export const EquityTierLimit = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.usdTncRequired.length !== 0) {
+            writer.uint32(10).bytes(message.usdTncRequired);
+        }
+        if (message.limit !== 0) {
+            writer.uint32(16).uint32(message.limit);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEquityTierLimit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.usdTncRequired = reader.bytes();
+                    break;
+                case 2:
+                    message.limit = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEquityTierLimit();
+        message.usdTncRequired = object.usdTncRequired ?? new Uint8Array();
+        message.limit = object.limit ?? 0;
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/finalize_block.d.ts

@@ -0,0 +1,23 @@
+import { ClobPair, ClobPairSDKType } from "./clob_pair.js";
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+export interface ClobStagedFinalizeBlockEvent {
+    /** create_clob_pair indicates a new CLOB pair creation. */
+    createClobPair?: ClobPair;
+}
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+export interface ClobStagedFinalizeBlockEventSDKType {
+    create_clob_pair?: ClobPairSDKType;
+}
+export declare const ClobStagedFinalizeBlockEvent: {
+    encode(message: ClobStagedFinalizeBlockEvent, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ClobStagedFinalizeBlockEvent;
+    fromPartial(object: DeepPartial<ClobStagedFinalizeBlockEvent>): ClobStagedFinalizeBlockEvent;
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/finalize_block.js

@@ -0,0 +1,37 @@
+import { ClobPair } from "./clob_pair.js";
+import _m0 from "protobufjs/minimal.js";
+function createBaseClobStagedFinalizeBlockEvent() {
+    return {
+        createClobPair: undefined
+    };
+}
+export const ClobStagedFinalizeBlockEvent = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.createClobPair !== undefined) {
+            ClobPair.encode(message.createClobPair, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseClobStagedFinalizeBlockEvent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.createClobPair = ClobPair.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseClobStagedFinalizeBlockEvent();
+        message.createClobPair = object.createClobPair !== undefined && object.createClobPair !== null ? ClobPair.fromPartial(object.createClobPair) : undefined;
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/clob/liquidations.d.ts

@@ -0,0 +1,92 @@
+import { SubaccountId, SubaccountIdSDKType } from "../subaccounts/subaccount.js";
+import * as _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * PerpetualLiquidationInfo holds information about a liquidation that occurred
+ * for a position held by a subaccount.
+ * Note this proto is defined to make it easier to hash
+ * the metadata of a liquidation, and is never written to state.
+ */
+export interface PerpetualLiquidationInfo {
+    /**
+     * The id of the subaccount that got liquidated/deleveraged or was deleveraged
+     * onto.
+     */
+    subaccountId?: SubaccountId;
+    /** The id of the perpetual involved. */
+    perpetualId: number;
+}
+/**
+ * PerpetualLiquidationInfo holds information about a liquidation that occurred
+ * for a position held by a subaccount.
+ * Note this proto is defined to make it easier to hash
+ * the metadata of a liquidation, and is never written to state.
+ */
+export interface PerpetualLiquidationInfoSDKType {
+    subaccount_id?: SubaccountIdSDKType;
+    perpetual_id: number;
+}
+/**
+ * SubaccountLiquidationInfo holds liquidation information per-subaccount in the
+ * current block.
+ */
+export interface SubaccountLiquidationInfo {
+    /**
+     * An unsorted list of unique perpetual IDs that the subaccount has previously
+     * liquidated.
+     */
+    perpetualsLiquidated: number[];
+    /**
+     * The notional value (in quote quantums, determined by the oracle price) of
+     * all positions liquidated for this subaccount.
+     */
+    notionalLiquidated: Long;
+    /**
+     * The amount of funds that the insurance fund has lost
+     * covering this subaccount.
+     */
+    quantumsInsuranceLost: Long;
+}
+/**
+ * SubaccountLiquidationInfo holds liquidation information per-subaccount in the
+ * current block.
+ */
+export interface SubaccountLiquidationInfoSDKType {
+    perpetuals_liquidated: number[];
+    notional_liquidated: Long;
+    quantums_insurance_lost: Long;
+}
+/**
+ * SubaccountOpenPositionInfo holds information about open positions for a
+ * perpetual.
+ */
+export interface SubaccountOpenPositionInfo {
+    /** The id of the perpetual. */
+    perpetualId: number;
+    subaccountsWithLongPosition: SubaccountId[];
+    subaccountsWithShortPosition: SubaccountId[];
+}
+/**
+ * SubaccountOpenPositionInfo holds information about open positions for a
+ * perpetual.
+ */
+export interface SubaccountOpenPositionInfoSDKType {
+    perpetual_id: number;
+    subaccounts_with_long_position: SubaccountIdSDKType[];
+    subaccounts_with_short_position: SubaccountIdSDKType[];
+}
+export declare const PerpetualLiquidationInfo: {
+    encode(message: PerpetualLiquidationInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualLiquidationInfo;
+    fromPartial(object: DeepPartial<PerpetualLiquidationInfo>): PerpetualLiquidationInfo;
+};
+export declare const SubaccountLiquidationInfo: {
+    encode(message: SubaccountLiquidationInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountLiquidationInfo;
+    fromPartial(object: DeepPartial<SubaccountLiquidationInfo>): SubaccountLiquidationInfo;
+};
+export declare const SubaccountOpenPositionInfo: {
+    encode(message: SubaccountOpenPositionInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountOpenPositionInfo;
+    fromPartial(object: DeepPartial<SubaccountOpenPositionInfo>): SubaccountOpenPositionInfo;
+};