@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/indexer/protocol/v1/perpetual.ts

@@ -0,0 +1,52 @@
+/**
+ * Market type of perpetual.
+ * Defined in perpetual.
+ */
+export enum PerpetualMarketType {
+  /** PERPETUAL_MARKET_TYPE_UNSPECIFIED - Unspecified market type. */
+  PERPETUAL_MARKET_TYPE_UNSPECIFIED = 0,
+
+  /** PERPETUAL_MARKET_TYPE_CROSS - Market type for cross margin perpetual markets. */
+  PERPETUAL_MARKET_TYPE_CROSS = 1,
+
+  /** PERPETUAL_MARKET_TYPE_ISOLATED - Market type for isolated margin perpetual markets. */
+  PERPETUAL_MARKET_TYPE_ISOLATED = 2,
+  UNRECOGNIZED = -1,
+}
+export const PerpetualMarketTypeSDKType = PerpetualMarketType;
+export function perpetualMarketTypeFromJSON(object: any): PerpetualMarketType {
+  switch (object) {
+    case 0:
+    case "PERPETUAL_MARKET_TYPE_UNSPECIFIED":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_UNSPECIFIED;
+
+    case 1:
+    case "PERPETUAL_MARKET_TYPE_CROSS":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_CROSS;
+
+    case 2:
+    case "PERPETUAL_MARKET_TYPE_ISOLATED":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_ISOLATED;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return PerpetualMarketType.UNRECOGNIZED;
+  }
+}
+export function perpetualMarketTypeToJSON(object: PerpetualMarketType): string {
+  switch (object) {
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_UNSPECIFIED:
+      return "PERPETUAL_MARKET_TYPE_UNSPECIFIED";
+
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_CROSS:
+      return "PERPETUAL_MARKET_TYPE_CROSS";
+
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_ISOLATED:
+      return "PERPETUAL_MARKET_TYPE_ISOLATED";
+
+    case PerpetualMarketType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}

package/src/codegen/zogux/indexer/protocol/v1/subaccount.ts

@@ -0,0 +1,281 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../../../helpers";
+/** IndexerSubaccountId defines a unique identifier for a Subaccount. */
+
+export interface IndexerSubaccountId {
+  /** The address of the wallet that owns this subaccount. */
+  owner: string;
+  /**
+   * < 128 Since 128 should be enough to start and it fits within
+   * 1 Byte (1 Bit needed to indicate that the first byte is the last).
+   */
+
+  number: number;
+}
+/** IndexerSubaccountId defines a unique identifier for a Subaccount. */
+
+export interface IndexerSubaccountIdSDKType {
+  owner: string;
+  number: number;
+}
+/**
+ * IndexerPerpetualPosition are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+
+export interface IndexerPerpetualPosition {
+  /** The `Id` of the `Perpetual`. */
+  perpetualId: number;
+  /** The size of the position in base quantums. */
+
+  quantums: Uint8Array;
+  /**
+   * The funding_index of the `Perpetual` the last time this position was
+   * settled.
+   */
+
+  fundingIndex: Uint8Array;
+  /**
+   * Amount of funding payment (in quote quantums).
+   * Note: 1. this field is not cumulative.
+   * 2. a positive value means funding payment was paid out and
+   * a negative value means funding payment was received.
+   */
+
+  fundingPayment: Uint8Array;
+}
+/**
+ * IndexerPerpetualPosition are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+
+export interface IndexerPerpetualPositionSDKType {
+  perpetual_id: number;
+  quantums: Uint8Array;
+  funding_index: Uint8Array;
+  funding_payment: Uint8Array;
+}
+/**
+ * IndexerAssetPosition define an account’s positions of an `Asset`.
+ * Therefore they hold any information needed to trade on Spot and Margin.
+ */
+
+export interface IndexerAssetPosition {
+  /** The `Id` of the `Asset`. */
+  assetId: number;
+  /** The absolute size of the position in base quantums. */
+
+  quantums: Uint8Array;
+  /**
+   * The `Index` (either `LongIndex` or `ShortIndex`) of the `Asset` the last
+   * time this position was settled
+   * TODO(DEC-582): pending margin trading being added.
+   */
+
+  index: Long;
+}
+/**
+ * IndexerAssetPosition define an account’s positions of an `Asset`.
+ * Therefore they hold any information needed to trade on Spot and Margin.
+ */
+
+export interface IndexerAssetPositionSDKType {
+  asset_id: number;
+  quantums: Uint8Array;
+  index: Long;
+}
+
+function createBaseIndexerSubaccountId(): IndexerSubaccountId {
+  return {
+    owner: "",
+    number: 0
+  };
+}
+
+export const IndexerSubaccountId = {
+  encode(message: IndexerSubaccountId, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.owner !== "") {
+      writer.uint32(10).string(message.owner);
+    }
+
+    if (message.number !== 0) {
+      writer.uint32(16).uint32(message.number);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerSubaccountId {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerSubaccountId();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.owner = reader.string();
+          break;
+
+        case 2:
+          message.number = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerSubaccountId>): IndexerSubaccountId {
+    const message = createBaseIndexerSubaccountId();
+    message.owner = object.owner ?? "";
+    message.number = object.number ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseIndexerPerpetualPosition(): IndexerPerpetualPosition {
+  return {
+    perpetualId: 0,
+    quantums: new Uint8Array(),
+    fundingIndex: new Uint8Array(),
+    fundingPayment: new Uint8Array()
+  };
+}
+
+export const IndexerPerpetualPosition = {
+  encode(message: IndexerPerpetualPosition, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.perpetualId !== 0) {
+      writer.uint32(8).uint32(message.perpetualId);
+    }
+
+    if (message.quantums.length !== 0) {
+      writer.uint32(18).bytes(message.quantums);
+    }
+
+    if (message.fundingIndex.length !== 0) {
+      writer.uint32(26).bytes(message.fundingIndex);
+    }
+
+    if (message.fundingPayment.length !== 0) {
+      writer.uint32(34).bytes(message.fundingPayment);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerPerpetualPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerPerpetualPosition();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.perpetualId = reader.uint32();
+          break;
+
+        case 2:
+          message.quantums = reader.bytes();
+          break;
+
+        case 3:
+          message.fundingIndex = reader.bytes();
+          break;
+
+        case 4:
+          message.fundingPayment = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerPerpetualPosition>): IndexerPerpetualPosition {
+    const message = createBaseIndexerPerpetualPosition();
+    message.perpetualId = object.perpetualId ?? 0;
+    message.quantums = object.quantums ?? new Uint8Array();
+    message.fundingIndex = object.fundingIndex ?? new Uint8Array();
+    message.fundingPayment = object.fundingPayment ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseIndexerAssetPosition(): IndexerAssetPosition {
+  return {
+    assetId: 0,
+    quantums: new Uint8Array(),
+    index: Long.UZERO
+  };
+}
+
+export const IndexerAssetPosition = {
+  encode(message: IndexerAssetPosition, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.assetId !== 0) {
+      writer.uint32(8).uint32(message.assetId);
+    }
+
+    if (message.quantums.length !== 0) {
+      writer.uint32(18).bytes(message.quantums);
+    }
+
+    if (!message.index.isZero()) {
+      writer.uint32(24).uint64(message.index);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerAssetPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerAssetPosition();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.assetId = reader.uint32();
+          break;
+
+        case 2:
+          message.quantums = reader.bytes();
+          break;
+
+        case 3:
+          message.index = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerAssetPosition>): IndexerAssetPosition {
+    const message = createBaseIndexerAssetPosition();
+    message.assetId = object.assetId ?? 0;
+    message.quantums = object.quantums ?? new Uint8Array();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.UZERO;
+    return message;
+  }
+
+};

package/src/codegen/zogux/indexer/protocol/v1/vault.ts

@@ -0,0 +1,69 @@
+/** VaultStatus represents the status of a vault. */
+export enum VaultStatus {
+  /** VAULT_STATUS_UNSPECIFIED - Default value, invalid and unused. */
+  VAULT_STATUS_UNSPECIFIED = 0,
+
+  /** VAULT_STATUS_DEACTIVATED - Don’t place orders. Does not count toward global vault balances. */
+  VAULT_STATUS_DEACTIVATED = 1,
+
+  /** VAULT_STATUS_STAND_BY - Don’t place orders. Does count towards global vault balances. */
+  VAULT_STATUS_STAND_BY = 2,
+
+  /** VAULT_STATUS_QUOTING - Places orders on both sides of the book. */
+  VAULT_STATUS_QUOTING = 3,
+
+  /** VAULT_STATUS_CLOSE_ONLY - Only place orders that close the position. */
+  VAULT_STATUS_CLOSE_ONLY = 4,
+  UNRECOGNIZED = -1,
+}
+export const VaultStatusSDKType = VaultStatus;
+export function vaultStatusFromJSON(object: any): VaultStatus {
+  switch (object) {
+    case 0:
+    case "VAULT_STATUS_UNSPECIFIED":
+      return VaultStatus.VAULT_STATUS_UNSPECIFIED;
+
+    case 1:
+    case "VAULT_STATUS_DEACTIVATED":
+      return VaultStatus.VAULT_STATUS_DEACTIVATED;
+
+    case 2:
+    case "VAULT_STATUS_STAND_BY":
+      return VaultStatus.VAULT_STATUS_STAND_BY;
+
+    case 3:
+    case "VAULT_STATUS_QUOTING":
+      return VaultStatus.VAULT_STATUS_QUOTING;
+
+    case 4:
+    case "VAULT_STATUS_CLOSE_ONLY":
+      return VaultStatus.VAULT_STATUS_CLOSE_ONLY;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return VaultStatus.UNRECOGNIZED;
+  }
+}
+export function vaultStatusToJSON(object: VaultStatus): string {
+  switch (object) {
+    case VaultStatus.VAULT_STATUS_UNSPECIFIED:
+      return "VAULT_STATUS_UNSPECIFIED";
+
+    case VaultStatus.VAULT_STATUS_DEACTIVATED:
+      return "VAULT_STATUS_DEACTIVATED";
+
+    case VaultStatus.VAULT_STATUS_STAND_BY:
+      return "VAULT_STATUS_STAND_BY";
+
+    case VaultStatus.VAULT_STATUS_QUOTING:
+      return "VAULT_STATUS_QUOTING";
+
+    case VaultStatus.VAULT_STATUS_CLOSE_ONLY:
+      return "VAULT_STATUS_CLOSE_ONLY";
+
+    case VaultStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}

package/src/codegen/zogux/indexer/redis/redis_order.ts

@@ -0,0 +1,190 @@
+import { IndexerOrder, IndexerOrderSDKType } from "../protocol/v1/clob";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** Enum for the ticker type, PERPETUAL or SPOT. */
+
+export enum RedisOrder_TickerType {
+  /**
+   * TICKER_TYPE_UNSPECIFIED - Default value for the enum. Should never be used in an initialized
+   * `RedisOrder`.
+   */
+  TICKER_TYPE_UNSPECIFIED = 0,
+
+  /** TICKER_TYPE_PERPETUAL - Ticker is for a perpetual pair. */
+  TICKER_TYPE_PERPETUAL = 1,
+
+  /** TICKER_TYPE_SPOT - Ticker is for a spot pair. */
+  TICKER_TYPE_SPOT = 2,
+  UNRECOGNIZED = -1,
+}
+export const RedisOrder_TickerTypeSDKType = RedisOrder_TickerType;
+export function redisOrder_TickerTypeFromJSON(object: any): RedisOrder_TickerType {
+  switch (object) {
+    case 0:
+    case "TICKER_TYPE_UNSPECIFIED":
+      return RedisOrder_TickerType.TICKER_TYPE_UNSPECIFIED;
+
+    case 1:
+    case "TICKER_TYPE_PERPETUAL":
+      return RedisOrder_TickerType.TICKER_TYPE_PERPETUAL;
+
+    case 2:
+    case "TICKER_TYPE_SPOT":
+      return RedisOrder_TickerType.TICKER_TYPE_SPOT;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return RedisOrder_TickerType.UNRECOGNIZED;
+  }
+}
+export function redisOrder_TickerTypeToJSON(object: RedisOrder_TickerType): string {
+  switch (object) {
+    case RedisOrder_TickerType.TICKER_TYPE_UNSPECIFIED:
+      return "TICKER_TYPE_UNSPECIFIED";
+
+    case RedisOrder_TickerType.TICKER_TYPE_PERPETUAL:
+      return "TICKER_TYPE_PERPETUAL";
+
+    case RedisOrder_TickerType.TICKER_TYPE_SPOT:
+      return "TICKER_TYPE_SPOT";
+
+    case RedisOrder_TickerType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/**
+ * RedisOrder is a proto for orders stored in Redis. This proto holds some
+ * human-readable values such as price, size and ticker as well as the original
+ * `Order` proto from the Zogux application.
+ */
+
+export interface RedisOrder {
+  /** uuid of the Order generated by the Indexer based on the `OrderId`. */
+  id: string;
+  /** Order proto from the protocol. */
+
+  order?: IndexerOrder;
+  /** Ticker for the exchange pair for the order. */
+
+  ticker: string;
+  /** Type of the ticker, PERPETUAL or SPOT. */
+
+  tickerType: RedisOrder_TickerType;
+  /** Human-readable price of the order. */
+
+  price: string;
+  /** Human-readable size of the order. */
+
+  size: string;
+}
+/**
+ * RedisOrder is a proto for orders stored in Redis. This proto holds some
+ * human-readable values such as price, size and ticker as well as the original
+ * `Order` proto from the Zogux application.
+ */
+
+export interface RedisOrderSDKType {
+  id: string;
+  order?: IndexerOrderSDKType;
+  ticker: string;
+  ticker_type: RedisOrder_TickerType;
+  price: string;
+  size: string;
+}
+
+function createBaseRedisOrder(): RedisOrder {
+  return {
+    id: "",
+    order: undefined,
+    ticker: "",
+    tickerType: 0,
+    price: "",
+    size: ""
+  };
+}
+
+export const RedisOrder = {
+  encode(message: RedisOrder, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+
+    if (message.order !== undefined) {
+      IndexerOrder.encode(message.order, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.ticker !== "") {
+      writer.uint32(26).string(message.ticker);
+    }
+
+    if (message.tickerType !== 0) {
+      writer.uint32(32).int32(message.tickerType);
+    }
+
+    if (message.price !== "") {
+      writer.uint32(42).string(message.price);
+    }
+
+    if (message.size !== "") {
+      writer.uint32(50).string(message.size);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RedisOrder {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRedisOrder();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+
+        case 2:
+          message.order = IndexerOrder.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.ticker = reader.string();
+          break;
+
+        case 4:
+          message.tickerType = (reader.int32() as any);
+          break;
+
+        case 5:
+          message.price = reader.string();
+          break;
+
+        case 6:
+          message.size = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<RedisOrder>): RedisOrder {
+    const message = createBaseRedisOrder();
+    message.id = object.id ?? "";
+    message.order = object.order !== undefined && object.order !== null ? IndexerOrder.fromPartial(object.order) : undefined;
+    message.ticker = object.ticker ?? "";
+    message.tickerType = object.tickerType ?? 0;
+    message.price = object.price ?? "";
+    message.size = object.size ?? "";
+    return message;
+  }
+
+};