@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/clob/liquidations.ts

@@ -0,0 +1,288 @@
+import { SubaccountId, SubaccountIdSDKType } from "../subaccounts/subaccount";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/**
+ * 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;
+  /** The ids of the subaccounts with long positions. */
+
+  subaccountsWithLongPosition: SubaccountId[];
+  /** The ids of the subaccounts with short positions. */
+
+  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[];
+}
+
+function createBasePerpetualLiquidationInfo(): PerpetualLiquidationInfo {
+  return {
+    subaccountId: undefined,
+    perpetualId: 0
+  };
+}
+
+export const PerpetualLiquidationInfo = {
+  encode(message: PerpetualLiquidationInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): PerpetualLiquidationInfo {
+    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: DeepPartial<PerpetualLiquidationInfo>): PerpetualLiquidationInfo {
+    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(): SubaccountLiquidationInfo {
+  return {
+    perpetualsLiquidated: [],
+    notionalLiquidated: Long.UZERO,
+    quantumsInsuranceLost: Long.UZERO
+  };
+}
+
+export const SubaccountLiquidationInfo = {
+  encode(message: SubaccountLiquidationInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): SubaccountLiquidationInfo {
+    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() as Long);
+          break;
+
+        case 3:
+          message.quantumsInsuranceLost = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SubaccountLiquidationInfo>): SubaccountLiquidationInfo {
+    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(): SubaccountOpenPositionInfo {
+  return {
+    perpetualId: 0,
+    subaccountsWithLongPosition: [],
+    subaccountsWithShortPosition: []
+  };
+}
+
+export const SubaccountOpenPositionInfo = {
+  encode(message: SubaccountOpenPositionInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): SubaccountOpenPositionInfo {
+    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: DeepPartial<SubaccountOpenPositionInfo>): SubaccountOpenPositionInfo {
+    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/src/codegen/zogux/clob/liquidations_config.ts

@@ -0,0 +1,358 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/** 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;
+}
+
+function createBaseLiquidationsConfig(): LiquidationsConfig {
+  return {
+    maxLiquidationFeePpm: 0,
+    positionBlockLimits: undefined,
+    subaccountBlockLimits: undefined,
+    fillablePriceConfig: undefined
+  };
+}
+
+export const LiquidationsConfig = {
+  encode(message: LiquidationsConfig, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): LiquidationsConfig {
+    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: DeepPartial<LiquidationsConfig>): LiquidationsConfig {
+    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(): PositionBlockLimits {
+  return {
+    minPositionNotionalLiquidated: Long.UZERO,
+    maxPositionPortionLiquidatedPpm: 0
+  };
+}
+
+export const PositionBlockLimits = {
+  encode(message: PositionBlockLimits, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.minPositionNotionalLiquidated.isZero()) {
+      writer.uint32(8).uint64(message.minPositionNotionalLiquidated);
+    }
+
+    if (message.maxPositionPortionLiquidatedPpm !== 0) {
+      writer.uint32(16).uint32(message.maxPositionPortionLiquidatedPpm);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PositionBlockLimits {
+    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() as Long);
+          break;
+
+        case 2:
+          message.maxPositionPortionLiquidatedPpm = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PositionBlockLimits>): PositionBlockLimits {
+    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(): SubaccountBlockLimits {
+  return {
+    maxNotionalLiquidated: Long.UZERO,
+    maxQuantumsInsuranceLost: Long.UZERO
+  };
+}
+
+export const SubaccountBlockLimits = {
+  encode(message: SubaccountBlockLimits, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.maxNotionalLiquidated.isZero()) {
+      writer.uint32(8).uint64(message.maxNotionalLiquidated);
+    }
+
+    if (!message.maxQuantumsInsuranceLost.isZero()) {
+      writer.uint32(16).uint64(message.maxQuantumsInsuranceLost);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountBlockLimits {
+    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() as Long);
+          break;
+
+        case 2:
+          message.maxQuantumsInsuranceLost = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SubaccountBlockLimits>): SubaccountBlockLimits {
+    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(): FillablePriceConfig {
+  return {
+    bankruptcyAdjustmentPpm: 0,
+    spreadToMaintenanceMarginRatioPpm: 0
+  };
+}
+
+export const FillablePriceConfig = {
+  encode(message: FillablePriceConfig, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.bankruptcyAdjustmentPpm !== 0) {
+      writer.uint32(8).uint32(message.bankruptcyAdjustmentPpm);
+    }
+
+    if (message.spreadToMaintenanceMarginRatioPpm !== 0) {
+      writer.uint32(16).uint32(message.spreadToMaintenanceMarginRatioPpm);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FillablePriceConfig {
+    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: DeepPartial<FillablePriceConfig>): FillablePriceConfig {
+    const message = createBaseFillablePriceConfig();
+    message.bankruptcyAdjustmentPpm = object.bankruptcyAdjustmentPpm ?? 0;
+    message.spreadToMaintenanceMarginRatioPpm = object.spreadToMaintenanceMarginRatioPpm ?? 0;
+    return message;
+  }
+
+};