ccxt 4.5.18 → 4.5.19

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

@@ -0,0 +1,158 @@
+import { SubaccountId } from "../subaccounts/subaccount.js";
+import * as _m0 from "protobufjs/minimal.js";
+import { Long } from "../../helpers.js";
+function createBasePerpetualLiquidationInfo() {
+    return {
+        subaccountId: undefined,
+        perpetualId: 0
+    };
+}
+export const PerpetualLiquidationInfo = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.subaccountId !== undefined) {
+            SubaccountId.encode(message.subaccountId, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.perpetualId !== 0) {
+            writer.uint32(16).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 = createBasePerpetualLiquidationInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.subaccountId = SubaccountId.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.perpetualId = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePerpetualLiquidationInfo();
+        message.subaccountId = object.subaccountId !== undefined && object.subaccountId !== null ? SubaccountId.fromPartial(object.subaccountId) : undefined;
+        message.perpetualId = object.perpetualId ?? 0;
+        return message;
+    }
+};
+function createBaseSubaccountLiquidationInfo() {
+    return {
+        perpetualsLiquidated: [],
+        notionalLiquidated: Long.UZERO,
+        quantumsInsuranceLost: Long.UZERO
+    };
+}
+export const SubaccountLiquidationInfo = {
+    encode(message, writer = _m0.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.perpetualsLiquidated) {
+            writer.uint32(v);
+        }
+        writer.ldelim();
+        if (!message.notionalLiquidated.isZero()) {
+            writer.uint32(16).uint64(message.notionalLiquidated);
+        }
+        if (!message.quantumsInsuranceLost.isZero()) {
+            writer.uint32(24).uint64(message.quantumsInsuranceLost);
+        }
+        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 = createBaseSubaccountLiquidationInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.perpetualsLiquidated.push(reader.uint32());
+                        }
+                    }
+                    else {
+                        message.perpetualsLiquidated.push(reader.uint32());
+                    }
+                    break;
+                case 2:
+                    message.notionalLiquidated = reader.uint64();
+                    break;
+                case 3:
+                    message.quantumsInsuranceLost = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSubaccountLiquidationInfo();
+        message.perpetualsLiquidated = object.perpetualsLiquidated?.map(e => e) || [];
+        message.notionalLiquidated = object.notionalLiquidated !== undefined && object.notionalLiquidated !== null ? Long.fromValue(object.notionalLiquidated) : Long.UZERO;
+        message.quantumsInsuranceLost = object.quantumsInsuranceLost !== undefined && object.quantumsInsuranceLost !== null ? Long.fromValue(object.quantumsInsuranceLost) : Long.UZERO;
+        return message;
+    }
+};
+function createBaseSubaccountOpenPositionInfo() {
+    return {
+        perpetualId: 0,
+        subaccountsWithLongPosition: [],
+        subaccountsWithShortPosition: []
+    };
+}
+export const SubaccountOpenPositionInfo = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.perpetualId !== 0) {
+            writer.uint32(8).uint32(message.perpetualId);
+        }
+        for (const v of message.subaccountsWithLongPosition) {
+            SubaccountId.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.subaccountsWithShortPosition) {
+            SubaccountId.encode(v, writer.uint32(26).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 = createBaseSubaccountOpenPositionInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.perpetualId = reader.uint32();
+                    break;
+                case 2:
+                    message.subaccountsWithLongPosition.push(SubaccountId.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.subaccountsWithShortPosition.push(SubaccountId.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSubaccountOpenPositionInfo();
+        message.perpetualId = object.perpetualId ?? 0;
+        message.subaccountsWithLongPosition = object.subaccountsWithLongPosition?.map(e => SubaccountId.fromPartial(e)) || [];
+        message.subaccountsWithShortPosition = object.subaccountsWithShortPosition?.map(e => SubaccountId.fromPartial(e)) || [];
+        return message;
+    }
+};

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

@@ -0,0 +1,124 @@
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/** LiquidationsConfig stores all configurable fields related to liquidations. */
+export interface LiquidationsConfig {
+    /**
+     * The maximum liquidation fee (in parts-per-million). This fee goes
+     * 100% to the insurance fund.
+     */
+    maxLiquidationFeePpm: number;
+    /**
+     * Limits around how much of a single position can be liquidated
+     * within a single block.
+     */
+    positionBlockLimits?: PositionBlockLimits;
+    /**
+     * Limits around how many quote quantums from a single subaccount can
+     * be liquidated within a single block.
+     */
+    subaccountBlockLimits?: SubaccountBlockLimits;
+    /**
+     * Config about how the fillable-price spread from the oracle price
+     * increases based on the adjusted bankruptcy rating of the subaccount.
+     */
+    fillablePriceConfig?: FillablePriceConfig;
+}
+/** LiquidationsConfig stores all configurable fields related to liquidations. */
+export interface LiquidationsConfigSDKType {
+    max_liquidation_fee_ppm: number;
+    position_block_limits?: PositionBlockLimitsSDKType;
+    subaccount_block_limits?: SubaccountBlockLimitsSDKType;
+    fillable_price_config?: FillablePriceConfigSDKType;
+}
+/**
+ * PositionBlockLimits stores all configurable fields related to limits
+ * around how much of a single position can be liquidated within a single block.
+ */
+export interface PositionBlockLimits {
+    /**
+     * The minimum amount of quantums to liquidate for each message (in
+     * quote quantums).
+     * Overridden by the maximum size of the position.
+     */
+    minPositionNotionalLiquidated: Long;
+    /**
+     * The maximum portion of the position liquidated (in parts-per-
+     * million). Overridden by min_position_notional_liquidated.
+     */
+    maxPositionPortionLiquidatedPpm: number;
+}
+/**
+ * PositionBlockLimits stores all configurable fields related to limits
+ * around how much of a single position can be liquidated within a single block.
+ */
+export interface PositionBlockLimitsSDKType {
+    min_position_notional_liquidated: Long;
+    max_position_portion_liquidated_ppm: number;
+}
+/**
+ * SubaccountBlockLimits stores all configurable fields related to limits
+ * around how many quote quantums from a single subaccount can
+ * be liquidated within a single block.
+ */
+export interface SubaccountBlockLimits {
+    /**
+     * The maximum notional amount that a single subaccount can have
+     * liquidated (in quote quantums) per block.
+     */
+    maxNotionalLiquidated: Long;
+    /**
+     * The maximum insurance-fund payout amount for a given subaccount
+     * per block. I.e. how much it can cover for that subaccount.
+     */
+    maxQuantumsInsuranceLost: Long;
+}
+/**
+ * SubaccountBlockLimits stores all configurable fields related to limits
+ * around how many quote quantums from a single subaccount can
+ * be liquidated within a single block.
+ */
+export interface SubaccountBlockLimitsSDKType {
+    max_notional_liquidated: Long;
+    max_quantums_insurance_lost: Long;
+}
+/**
+ * FillablePriceConfig stores all configurable fields related to calculating
+ * the fillable price for liquidating a position.
+ */
+export interface FillablePriceConfig {
+    /** The rate at which the Adjusted Bankruptcy Rating increases. */
+    bankruptcyAdjustmentPpm: number;
+    /**
+     * The maximum value that the liquidation spread can take, as
+     * a ratio against the position's maintenance margin.
+     */
+    spreadToMaintenanceMarginRatioPpm: number;
+}
+/**
+ * FillablePriceConfig stores all configurable fields related to calculating
+ * the fillable price for liquidating a position.
+ */
+export interface FillablePriceConfigSDKType {
+    bankruptcy_adjustment_ppm: number;
+    spread_to_maintenance_margin_ratio_ppm: number;
+}
+export declare const LiquidationsConfig: {
+    encode(message: LiquidationsConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LiquidationsConfig;
+    fromPartial(object: DeepPartial<LiquidationsConfig>): LiquidationsConfig;
+};
+export declare const PositionBlockLimits: {
+    encode(message: PositionBlockLimits, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PositionBlockLimits;
+    fromPartial(object: DeepPartial<PositionBlockLimits>): PositionBlockLimits;
+};
+export declare const SubaccountBlockLimits: {
+    encode(message: SubaccountBlockLimits, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountBlockLimits;
+    fromPartial(object: DeepPartial<SubaccountBlockLimits>): SubaccountBlockLimits;
+};
+export declare const FillablePriceConfig: {
+    encode(message: FillablePriceConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FillablePriceConfig;
+    fromPartial(object: DeepPartial<FillablePriceConfig>): FillablePriceConfig;
+};

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

@@ -0,0 +1,190 @@
+import _m0 from "protobufjs/minimal.js";
+import { Long } from "../../helpers.js";
+function createBaseLiquidationsConfig() {
+    return {
+        maxLiquidationFeePpm: 0,
+        positionBlockLimits: undefined,
+        subaccountBlockLimits: undefined,
+        fillablePriceConfig: undefined
+    };
+}
+export const LiquidationsConfig = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.maxLiquidationFeePpm !== 0) {
+            writer.uint32(8).uint32(message.maxLiquidationFeePpm);
+        }
+        if (message.positionBlockLimits !== undefined) {
+            PositionBlockLimits.encode(message.positionBlockLimits, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.subaccountBlockLimits !== undefined) {
+            SubaccountBlockLimits.encode(message.subaccountBlockLimits, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.fillablePriceConfig !== undefined) {
+            FillablePriceConfig.encode(message.fillablePriceConfig, writer.uint32(34).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 = createBaseLiquidationsConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.maxLiquidationFeePpm = reader.uint32();
+                    break;
+                case 2:
+                    message.positionBlockLimits = PositionBlockLimits.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.subaccountBlockLimits = SubaccountBlockLimits.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.fillablePriceConfig = FillablePriceConfig.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLiquidationsConfig();
+        message.maxLiquidationFeePpm = object.maxLiquidationFeePpm ?? 0;
+        message.positionBlockLimits = object.positionBlockLimits !== undefined && object.positionBlockLimits !== null ? PositionBlockLimits.fromPartial(object.positionBlockLimits) : undefined;
+        message.subaccountBlockLimits = object.subaccountBlockLimits !== undefined && object.subaccountBlockLimits !== null ? SubaccountBlockLimits.fromPartial(object.subaccountBlockLimits) : undefined;
+        message.fillablePriceConfig = object.fillablePriceConfig !== undefined && object.fillablePriceConfig !== null ? FillablePriceConfig.fromPartial(object.fillablePriceConfig) : undefined;
+        return message;
+    }
+};
+function createBasePositionBlockLimits() {
+    return {
+        minPositionNotionalLiquidated: Long.UZERO,
+        maxPositionPortionLiquidatedPpm: 0
+    };
+}
+export const PositionBlockLimits = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (!message.minPositionNotionalLiquidated.isZero()) {
+            writer.uint32(8).uint64(message.minPositionNotionalLiquidated);
+        }
+        if (message.maxPositionPortionLiquidatedPpm !== 0) {
+            writer.uint32(16).uint32(message.maxPositionPortionLiquidatedPpm);
+        }
+        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 = createBasePositionBlockLimits();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.minPositionNotionalLiquidated = reader.uint64();
+                    break;
+                case 2:
+                    message.maxPositionPortionLiquidatedPpm = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePositionBlockLimits();
+        message.minPositionNotionalLiquidated = object.minPositionNotionalLiquidated !== undefined && object.minPositionNotionalLiquidated !== null ? Long.fromValue(object.minPositionNotionalLiquidated) : Long.UZERO;
+        message.maxPositionPortionLiquidatedPpm = object.maxPositionPortionLiquidatedPpm ?? 0;
+        return message;
+    }
+};
+function createBaseSubaccountBlockLimits() {
+    return {
+        maxNotionalLiquidated: Long.UZERO,
+        maxQuantumsInsuranceLost: Long.UZERO
+    };
+}
+export const SubaccountBlockLimits = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (!message.maxNotionalLiquidated.isZero()) {
+            writer.uint32(8).uint64(message.maxNotionalLiquidated);
+        }
+        if (!message.maxQuantumsInsuranceLost.isZero()) {
+            writer.uint32(16).uint64(message.maxQuantumsInsuranceLost);
+        }
+        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 = createBaseSubaccountBlockLimits();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.maxNotionalLiquidated = reader.uint64();
+                    break;
+                case 2:
+                    message.maxQuantumsInsuranceLost = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSubaccountBlockLimits();
+        message.maxNotionalLiquidated = object.maxNotionalLiquidated !== undefined && object.maxNotionalLiquidated !== null ? Long.fromValue(object.maxNotionalLiquidated) : Long.UZERO;
+        message.maxQuantumsInsuranceLost = object.maxQuantumsInsuranceLost !== undefined && object.maxQuantumsInsuranceLost !== null ? Long.fromValue(object.maxQuantumsInsuranceLost) : Long.UZERO;
+        return message;
+    }
+};
+function createBaseFillablePriceConfig() {
+    return {
+        bankruptcyAdjustmentPpm: 0,
+        spreadToMaintenanceMarginRatioPpm: 0
+    };
+}
+export const FillablePriceConfig = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.bankruptcyAdjustmentPpm !== 0) {
+            writer.uint32(8).uint32(message.bankruptcyAdjustmentPpm);
+        }
+        if (message.spreadToMaintenanceMarginRatioPpm !== 0) {
+            writer.uint32(16).uint32(message.spreadToMaintenanceMarginRatioPpm);
+        }
+        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 = createBaseFillablePriceConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.bankruptcyAdjustmentPpm = reader.uint32();
+                    break;
+                case 2:
+                    message.spreadToMaintenanceMarginRatioPpm = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseFillablePriceConfig();
+        message.bankruptcyAdjustmentPpm = object.bankruptcyAdjustmentPpm ?? 0;
+        message.spreadToMaintenanceMarginRatioPpm = object.spreadToMaintenanceMarginRatioPpm ?? 0;
+        return message;
+    }
+};

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

@@ -0,0 +1,159 @@
+import { OrderId, OrderIdSDKType } from "./order.js";
+import { SubaccountId, SubaccountIdSDKType } from "../subaccounts/subaccount.js";
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * ClobMatch represents an operations queue entry around all different types
+ * of matches, specifically regular matches, liquidation matches, and
+ * deleveraging matches.
+ */
+export interface ClobMatch {
+    matchOrders?: MatchOrders;
+    matchPerpetualLiquidation?: MatchPerpetualLiquidation;
+    matchPerpetualDeleveraging?: MatchPerpetualDeleveraging;
+}
+/**
+ * ClobMatch represents an operations queue entry around all different types
+ * of matches, specifically regular matches, liquidation matches, and
+ * deleveraging matches.
+ */
+export interface ClobMatchSDKType {
+    match_orders?: MatchOrdersSDKType;
+    match_perpetual_liquidation?: MatchPerpetualLiquidationSDKType;
+    match_perpetual_deleveraging?: MatchPerpetualDeleveragingSDKType;
+}
+/** MakerFill represents the filled amount of a matched maker order. */
+export interface MakerFill {
+    /**
+     * The filled amount of the matched maker order, in base quantums.
+     * TODO(CLOB-571): update to use SerializableInt.
+     */
+    fillAmount: Long;
+    /** The `OrderId` of the matched maker order. */
+    makerOrderId?: OrderId;
+}
+/** MakerFill represents the filled amount of a matched maker order. */
+export interface MakerFillSDKType {
+    fill_amount: Long;
+    maker_order_id?: OrderIdSDKType;
+}
+/** MatchOrders is an injected message used for matching orders. */
+export interface MatchOrders {
+    /** The `OrderId` of the taker order. */
+    takerOrderId?: OrderId;
+    /** An ordered list of fills created by this taker order. */
+    fills: MakerFill[];
+}
+/** MatchOrders is an injected message used for matching orders. */
+export interface MatchOrdersSDKType {
+    taker_order_id?: OrderIdSDKType;
+    fills: MakerFillSDKType[];
+}
+/**
+ * MatchPerpetualLiquidation is an injected message used for liquidating a
+ * subaccount.
+ */
+export interface MatchPerpetualLiquidation {
+    /** ID of the subaccount that was liquidated. */
+    liquidated?: SubaccountId;
+    /** The ID of the clob pair involved in the liquidation. */
+    clobPairId: number;
+    /** The ID of the perpetual involved in the liquidation. */
+    perpetualId: number;
+    /** The total size of the liquidation order including any unfilled size. */
+    totalSize: Long;
+    /** `true` if liquidating a short position, `false` otherwise. */
+    isBuy: boolean;
+    /** An ordered list of fills created by this liquidation. */
+    fills: MakerFill[];
+}
+/**
+ * MatchPerpetualLiquidation is an injected message used for liquidating a
+ * subaccount.
+ */
+export interface MatchPerpetualLiquidationSDKType {
+    liquidated?: SubaccountIdSDKType;
+    clob_pair_id: number;
+    perpetual_id: number;
+    total_size: Long;
+    is_buy: boolean;
+    fills: MakerFillSDKType[];
+}
+/**
+ * MatchPerpetualDeleveraging is an injected message used for deleveraging a
+ * subaccount.
+ */
+export interface MatchPerpetualDeleveraging {
+    /** ID of the subaccount that was liquidated. */
+    liquidated?: SubaccountId;
+    /** The ID of the perpetual that was liquidated. */
+    perpetualId: number;
+    /** An ordered list of fills created by this liquidation. */
+    fills: MatchPerpetualDeleveraging_Fill[];
+    /**
+     * Flag denoting whether the deleveraging operation was for the purpose
+     * of final settlement. Final settlement matches are at the oracle price,
+     * whereas deleveraging happens at the bankruptcy price of the deleveraged
+     * subaccount.
+     */
+    isFinalSettlement: boolean;
+}
+/**
+ * MatchPerpetualDeleveraging is an injected message used for deleveraging a
+ * subaccount.
+ */
+export interface MatchPerpetualDeleveragingSDKType {
+    liquidated?: SubaccountIdSDKType;
+    perpetual_id: number;
+    fills: MatchPerpetualDeleveraging_FillSDKType[];
+    is_final_settlement: boolean;
+}
+/** Fill represents a fill between the liquidated and offsetting subaccount. */
+export interface MatchPerpetualDeleveraging_Fill {
+    /**
+     * ID of the subaccount that was used to offset the liquidated subaccount's
+     * position.
+     */
+    offsettingSubaccountId?: SubaccountId;
+    /**
+     * The amount filled between the liquidated and offsetting position, in
+     * base quantums.
+     * TODO(CLOB-571): update to use SerializableInt.
+     */
+    fillAmount: Long;
+}
+/** Fill represents a fill between the liquidated and offsetting subaccount. */
+export interface MatchPerpetualDeleveraging_FillSDKType {
+    offsetting_subaccount_id?: SubaccountIdSDKType;
+    fill_amount: Long;
+}
+export declare const ClobMatch: {
+    encode(message: ClobMatch, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ClobMatch;
+    fromPartial(object: DeepPartial<ClobMatch>): ClobMatch;
+};
+export declare const MakerFill: {
+    encode(message: MakerFill, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MakerFill;
+    fromPartial(object: DeepPartial<MakerFill>): MakerFill;
+};
+export declare const MatchOrders: {
+    encode(message: MatchOrders, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MatchOrders;
+    fromPartial(object: DeepPartial<MatchOrders>): MatchOrders;
+};
+export declare const MatchPerpetualLiquidation: {
+    encode(message: MatchPerpetualLiquidation, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MatchPerpetualLiquidation;
+    fromPartial(object: DeepPartial<MatchPerpetualLiquidation>): MatchPerpetualLiquidation;
+};
+export declare const MatchPerpetualDeleveraging: {
+    encode(message: MatchPerpetualDeleveraging, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MatchPerpetualDeleveraging;
+    fromPartial(object: DeepPartial<MatchPerpetualDeleveraging>): MatchPerpetualDeleveraging;
+};
+export declare const MatchPerpetualDeleveraging_Fill: {
+    encode(message: MatchPerpetualDeleveraging_Fill, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MatchPerpetualDeleveraging_Fill;
+    fromPartial(object: DeepPartial<MatchPerpetualDeleveraging_Fill>): MatchPerpetualDeleveraging_Fill;
+};