@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/subaccounts/streaming.ts

@@ -0,0 +1,266 @@
+import { SubaccountId, SubaccountIdSDKType } from "./subaccount";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/**
+ * StreamSubaccountUpdate provides information on a subaccount update. Used in
+ * the full node GRPC stream.
+ */
+
+export interface StreamSubaccountUpdate {
+  subaccountId?: SubaccountId;
+  /** updated_perpetual_positions will each be for unique perpetuals. */
+
+  updatedPerpetualPositions: SubaccountPerpetualPosition[];
+  /** updated_asset_positions will each be for unique assets. */
+
+  updatedAssetPositions: SubaccountAssetPosition[];
+  /**
+   * Snapshot indicates if the response is from a snapshot of the subaccount.
+   * All updates should be ignored until snapshot is received.
+   * If the snapshot is true, then all previous entries should be
+   * discarded and the subaccount should be resynced.
+   * For a snapshot subaccount update, the `updated_perpetual_positions` and
+   * `updated_asset_positions` fields will contain the full state of the
+   * subaccount.
+   */
+
+  snapshot: boolean;
+}
+/**
+ * StreamSubaccountUpdate provides information on a subaccount update. Used in
+ * the full node GRPC stream.
+ */
+
+export interface StreamSubaccountUpdateSDKType {
+  subaccount_id?: SubaccountIdSDKType;
+  updated_perpetual_positions: SubaccountPerpetualPositionSDKType[];
+  updated_asset_positions: SubaccountAssetPositionSDKType[];
+  snapshot: boolean;
+}
+/**
+ * SubaccountPerpetualPosition provides information on a subaccount's updated
+ * perpetual positions.
+ */
+
+export interface SubaccountPerpetualPosition {
+  /** The `Id` of the `Perpetual`. */
+  perpetualId: number;
+  /** The size of the position in base quantums. Negative means short. */
+
+  quantums: Long;
+}
+/**
+ * SubaccountPerpetualPosition provides information on a subaccount's updated
+ * perpetual positions.
+ */
+
+export interface SubaccountPerpetualPositionSDKType {
+  perpetual_id: number;
+  quantums: Long;
+}
+/**
+ * SubaccountAssetPosition provides information on a subaccount's updated asset
+ * positions.
+ */
+
+export interface SubaccountAssetPosition {
+  /** The `Id` of the `Asset`. */
+  assetId: number;
+  /** The absolute size of the position in base quantums. */
+
+  quantums: Long;
+}
+/**
+ * SubaccountAssetPosition provides information on a subaccount's updated asset
+ * positions.
+ */
+
+export interface SubaccountAssetPositionSDKType {
+  asset_id: number;
+  quantums: Long;
+}
+
+function createBaseStreamSubaccountUpdate(): StreamSubaccountUpdate {
+  return {
+    subaccountId: undefined,
+    updatedPerpetualPositions: [],
+    updatedAssetPositions: [],
+    snapshot: false
+  };
+}
+
+export const StreamSubaccountUpdate = {
+  encode(message: StreamSubaccountUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subaccountId !== undefined) {
+      SubaccountId.encode(message.subaccountId, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.updatedPerpetualPositions) {
+      SubaccountPerpetualPosition.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.updatedAssetPositions) {
+      SubaccountAssetPosition.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.snapshot === true) {
+      writer.uint32(32).bool(message.snapshot);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StreamSubaccountUpdate {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamSubaccountUpdate();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subaccountId = SubaccountId.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.updatedPerpetualPositions.push(SubaccountPerpetualPosition.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.updatedAssetPositions.push(SubaccountAssetPosition.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.snapshot = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StreamSubaccountUpdate>): StreamSubaccountUpdate {
+    const message = createBaseStreamSubaccountUpdate();
+    message.subaccountId = object.subaccountId !== undefined && object.subaccountId !== null ? SubaccountId.fromPartial(object.subaccountId) : undefined;
+    message.updatedPerpetualPositions = object.updatedPerpetualPositions?.map(e => SubaccountPerpetualPosition.fromPartial(e)) || [];
+    message.updatedAssetPositions = object.updatedAssetPositions?.map(e => SubaccountAssetPosition.fromPartial(e)) || [];
+    message.snapshot = object.snapshot ?? false;
+    return message;
+  }
+
+};
+
+function createBaseSubaccountPerpetualPosition(): SubaccountPerpetualPosition {
+  return {
+    perpetualId: 0,
+    quantums: Long.ZERO
+  };
+}
+
+export const SubaccountPerpetualPosition = {
+  encode(message: SubaccountPerpetualPosition, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.perpetualId !== 0) {
+      writer.uint32(8).uint32(message.perpetualId);
+    }
+
+    if (!message.quantums.isZero()) {
+      writer.uint32(16).int64(message.quantums);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountPerpetualPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubaccountPerpetualPosition();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.perpetualId = reader.uint32();
+          break;
+
+        case 2:
+          message.quantums = (reader.int64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SubaccountPerpetualPosition>): SubaccountPerpetualPosition {
+    const message = createBaseSubaccountPerpetualPosition();
+    message.perpetualId = object.perpetualId ?? 0;
+    message.quantums = object.quantums !== undefined && object.quantums !== null ? Long.fromValue(object.quantums) : Long.ZERO;
+    return message;
+  }
+
+};
+
+function createBaseSubaccountAssetPosition(): SubaccountAssetPosition {
+  return {
+    assetId: 0,
+    quantums: Long.UZERO
+  };
+}
+
+export const SubaccountAssetPosition = {
+  encode(message: SubaccountAssetPosition, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.assetId !== 0) {
+      writer.uint32(8).uint32(message.assetId);
+    }
+
+    if (!message.quantums.isZero()) {
+      writer.uint32(16).uint64(message.quantums);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountAssetPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubaccountAssetPosition();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.assetId = reader.uint32();
+          break;
+
+        case 2:
+          message.quantums = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SubaccountAssetPosition>): SubaccountAssetPosition {
+    const message = createBaseSubaccountAssetPosition();
+    message.assetId = object.assetId ?? 0;
+    message.quantums = object.quantums !== undefined && object.quantums !== null ? Long.fromValue(object.quantums) : Long.UZERO;
+    return message;
+  }
+
+};

package/src/codegen/zogux/subaccounts/subaccount.ts

@@ -0,0 +1,190 @@
+import { AssetPosition, AssetPositionSDKType } from "./asset_position";
+import { PerpetualPosition, PerpetualPositionSDKType } from "./perpetual_position";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** SubaccountId defines a unique identifier for a Subaccount. */
+
+export interface SubaccountId {
+  /** The address of the wallet that owns this subaccount. */
+  owner: string;
+  /**
+   * The unique number of this subaccount for the owner.
+   * Currently limited to 128*1000 subaccounts per owner.
+   */
+
+  number: number;
+}
+/** SubaccountId defines a unique identifier for a Subaccount. */
+
+export interface SubaccountIdSDKType {
+  owner: string;
+  number: number;
+}
+/**
+ * Subaccount defines a single sub-account for a given address.
+ * Subaccounts are uniquely indexed by a subaccountNumber/owner pair.
+ */
+
+export interface Subaccount {
+  /** The Id of the Subaccount */
+  id?: SubaccountId;
+  /**
+   * All `AssetPosition`s associated with this subaccount.
+   * Always sorted ascending by `asset_id`.
+   */
+
+  assetPositions: AssetPosition[];
+  /**
+   * All `PerpetualPosition`s associated with this subaccount.
+   * Always sorted ascending by `perpetual_id.
+   */
+
+  perpetualPositions: PerpetualPosition[];
+  /**
+   * Set by the owner. If true, then margin trades can be made in this
+   * subaccount.
+   */
+
+  marginEnabled: boolean;
+}
+/**
+ * Subaccount defines a single sub-account for a given address.
+ * Subaccounts are uniquely indexed by a subaccountNumber/owner pair.
+ */
+
+export interface SubaccountSDKType {
+  id?: SubaccountIdSDKType;
+  asset_positions: AssetPositionSDKType[];
+  perpetual_positions: PerpetualPositionSDKType[];
+  margin_enabled: boolean;
+}
+
+function createBaseSubaccountId(): SubaccountId {
+  return {
+    owner: "",
+    number: 0
+  };
+}
+
+export const SubaccountId = {
+  encode(message: SubaccountId, 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): SubaccountId {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubaccountId();
+
+    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<SubaccountId>): SubaccountId {
+    const message = createBaseSubaccountId();
+    message.owner = object.owner ?? "";
+    message.number = object.number ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseSubaccount(): Subaccount {
+  return {
+    id: undefined,
+    assetPositions: [],
+    perpetualPositions: [],
+    marginEnabled: false
+  };
+}
+
+export const Subaccount = {
+  encode(message: Subaccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      SubaccountId.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.assetPositions) {
+      AssetPosition.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.perpetualPositions) {
+      PerpetualPosition.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.marginEnabled === true) {
+      writer.uint32(32).bool(message.marginEnabled);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Subaccount {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubaccount();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = SubaccountId.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.assetPositions.push(AssetPosition.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.perpetualPositions.push(PerpetualPosition.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.marginEnabled = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Subaccount>): Subaccount {
+    const message = createBaseSubaccount();
+    message.id = object.id !== undefined && object.id !== null ? SubaccountId.fromPartial(object.id) : undefined;
+    message.assetPositions = object.assetPositions?.map(e => AssetPosition.fromPartial(e)) || [];
+    message.perpetualPositions = object.perpetualPositions?.map(e => PerpetualPosition.fromPartial(e)) || [];
+    message.marginEnabled = object.marginEnabled ?? false;
+    return message;
+  }
+
+};

package/src/codegen/zogux/token/genesis.ts

@@ -0,0 +1,73 @@
+import { Params, ParamsSDKType, GenesisDenom, GenesisDenomSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the token module's genesis state. */
+
+export interface GenesisState {
+  /** params defines all the parameters of the module. */
+  params?: Params;
+  /** factory_denoms is a list of all denoms created by the token module. */
+
+  factoryDenoms: GenesisDenom[];
+}
+/** GenesisState defines the token module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: ParamsSDKType;
+  factory_denoms: GenesisDenomSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    factoryDenoms: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.factoryDenoms) {
+      GenesisDenom.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.factoryDenoms.push(GenesisDenom.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.factoryDenoms = object.factoryDenoms?.map(e => GenesisDenom.fromPartial(e)) || [];
+    return message;
+  }
+
+};