@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/stats/tx.ts

@@ -0,0 +1,112 @@
+import { Params, ParamsSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+
+export interface MsgUpdateParams {
+  authority: string;
+  /** The parameters to update. Each field must be set. */
+
+  params?: Params;
+}
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+
+export interface MsgUpdateParamsSDKType {
+  authority: string;
+  params?: ParamsSDKType;
+}
+/** MsgUpdateParamsResponse is the Msg/UpdateParams response type. */
+
+export interface MsgUpdateParamsResponse {}
+/** MsgUpdateParamsResponse is the Msg/UpdateParams response type. */
+
+export interface MsgUpdateParamsResponseSDKType {}
+
+function createBaseMsgUpdateParams(): MsgUpdateParams {
+  return {
+    authority: "",
+    params: undefined
+  };
+}
+
+export const MsgUpdateParams = {
+  encode(message: MsgUpdateParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse {
+  return {};
+}
+
+export const MsgUpdateParamsResponse = {
+  encode(_: MsgUpdateParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParamsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  }
+
+};

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

@@ -0,0 +1,96 @@
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * AssetPositions define an account’s positions of an `Asset`.
+ * Therefore they hold any information needed to trade on Spot and Margin.
+ */
+
+export interface AssetPosition {
+  /** 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;
+}
+/**
+ * AssetPositions define an account’s positions of an `Asset`.
+ * Therefore they hold any information needed to trade on Spot and Margin.
+ */
+
+export interface AssetPositionSDKType {
+  asset_id: number;
+  quantums: Uint8Array;
+  index: Long;
+}
+
+function createBaseAssetPosition(): AssetPosition {
+  return {
+    assetId: 0,
+    quantums: new Uint8Array(),
+    index: Long.UZERO
+  };
+}
+
+export const AssetPosition = {
+  encode(message: AssetPosition, 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): AssetPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAssetPosition();
+
+    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<AssetPosition>): AssetPosition {
+    const message = createBaseAssetPosition();
+    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/subaccounts/genesis.ts

@@ -0,0 +1,58 @@
+import { Subaccount, SubaccountSDKType } from "./subaccount";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the subaccounts module's genesis state. */
+
+export interface GenesisState {
+  subaccounts: Subaccount[];
+}
+/** GenesisState defines the subaccounts module's genesis state. */
+
+export interface GenesisStateSDKType {
+  subaccounts: SubaccountSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    subaccounts: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.subaccounts) {
+      Subaccount.encode(v!, writer.uint32(10).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.subaccounts.push(Subaccount.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.subaccounts = object.subaccounts?.map(e => Subaccount.fromPartial(e)) || [];
+    return message;
+  }
+
+};

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

@@ -0,0 +1,134 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * PerpetualLeverageEntry represents a single perpetual leverage setting for
+ * internal storage
+ */
+
+export interface PerpetualLeverageEntry {
+  /** The perpetual ID (internal storage format) */
+  perpetualId: number;
+  /** The user selected IMF in parts per million */
+
+  customImfPpm: number;
+}
+/**
+ * PerpetualLeverageEntry represents a single perpetual leverage setting for
+ * internal storage
+ */
+
+export interface PerpetualLeverageEntrySDKType {
+  perpetual_id: number;
+  custom_imf_ppm: number;
+}
+/** LeverageData represents the leverage settings for a subaccount */
+
+export interface LeverageData {
+  /** List of leverage entries for this subaccount */
+  entries: PerpetualLeverageEntry[];
+}
+/** LeverageData represents the leverage settings for a subaccount */
+
+export interface LeverageDataSDKType {
+  entries: PerpetualLeverageEntrySDKType[];
+}
+
+function createBasePerpetualLeverageEntry(): PerpetualLeverageEntry {
+  return {
+    perpetualId: 0,
+    customImfPpm: 0
+  };
+}
+
+export const PerpetualLeverageEntry = {
+  encode(message: PerpetualLeverageEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.perpetualId !== 0) {
+      writer.uint32(8).uint32(message.perpetualId);
+    }
+
+    if (message.customImfPpm !== 0) {
+      writer.uint32(16).uint32(message.customImfPpm);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualLeverageEntry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerpetualLeverageEntry();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.perpetualId = reader.uint32();
+          break;
+
+        case 2:
+          message.customImfPpm = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PerpetualLeverageEntry>): PerpetualLeverageEntry {
+    const message = createBasePerpetualLeverageEntry();
+    message.perpetualId = object.perpetualId ?? 0;
+    message.customImfPpm = object.customImfPpm ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseLeverageData(): LeverageData {
+  return {
+    entries: []
+  };
+}
+
+export const LeverageData = {
+  encode(message: LeverageData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.entries) {
+      PerpetualLeverageEntry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LeverageData {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLeverageData();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.entries.push(PerpetualLeverageEntry.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LeverageData>): LeverageData {
+    const message = createBaseLeverageData();
+    message.entries = object.entries?.map(e => PerpetualLeverageEntry.fromPartial(e)) || [];
+    return message;
+  }
+
+};

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

@@ -0,0 +1,109 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * PerpetualPositions are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+
+export interface PerpetualPosition {
+  /** 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;
+  /** The quote_balance of the `Perpetual`. */
+
+  quoteBalance: Uint8Array;
+}
+/**
+ * PerpetualPositions are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+
+export interface PerpetualPositionSDKType {
+  perpetual_id: number;
+  quantums: Uint8Array;
+  funding_index: Uint8Array;
+  quote_balance: Uint8Array;
+}
+
+function createBasePerpetualPosition(): PerpetualPosition {
+  return {
+    perpetualId: 0,
+    quantums: new Uint8Array(),
+    fundingIndex: new Uint8Array(),
+    quoteBalance: new Uint8Array()
+  };
+}
+
+export const PerpetualPosition = {
+  encode(message: PerpetualPosition, 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.quoteBalance.length !== 0) {
+      writer.uint32(34).bytes(message.quoteBalance);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualPosition {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerpetualPosition();
+
+    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.quoteBalance = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PerpetualPosition>): PerpetualPosition {
+    const message = createBasePerpetualPosition();
+    message.perpetualId = object.perpetualId ?? 0;
+    message.quantums = object.quantums ?? new Uint8Array();
+    message.fundingIndex = object.fundingIndex ?? new Uint8Array();
+    message.quoteBalance = object.quoteBalance ?? new Uint8Array();
+    return message;
+  }
+
+};

package/src/codegen/zogux/subaccounts/query.lcd.ts

@@ -0,0 +1,58 @@
+import { setPaginationParams } from "../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryGetSubaccountRequest, QuerySubaccountResponseSDKType, QueryAllSubaccountRequest, QuerySubaccountAllResponseSDKType, QueryGetWithdrawalAndTransfersBlockedInfoRequest, QueryGetWithdrawalAndTransfersBlockedInfoResponseSDKType, QueryCollateralPoolAddressRequest, QueryCollateralPoolAddressResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.subaccount = this.subaccount.bind(this);
+    this.subaccountAll = this.subaccountAll.bind(this);
+    this.getWithdrawalAndTransfersBlockedInfo = this.getWithdrawalAndTransfersBlockedInfo.bind(this);
+    this.collateralPoolAddress = this.collateralPoolAddress.bind(this);
+  }
+  /* Queries a Subaccount by id */
+
+
+  async subaccount(params: QueryGetSubaccountRequest): Promise<QuerySubaccountResponseSDKType> {
+    const endpoint = `zogux/subaccounts/subaccount/${params.owner}/${params.number}`;
+    return await this.req.get<QuerySubaccountResponseSDKType>(endpoint);
+  }
+  /* Queries a list of Subaccount items. */
+
+
+  async subaccountAll(params: QueryAllSubaccountRequest = {
+    pagination: undefined
+  }): Promise<QuerySubaccountAllResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `zogux/subaccounts/subaccount`;
+    return await this.req.get<QuerySubaccountAllResponseSDKType>(endpoint, options);
+  }
+  /* Queries information about whether withdrawal and transfers are blocked, and
+   if so which block they are re-enabled on. */
+
+
+  async getWithdrawalAndTransfersBlockedInfo(params: QueryGetWithdrawalAndTransfersBlockedInfoRequest): Promise<QueryGetWithdrawalAndTransfersBlockedInfoResponseSDKType> {
+    const endpoint = `zogux/subaccounts/withdrawals_and_transfers_blocked_info/${params.perpetualId}`;
+    return await this.req.get<QueryGetWithdrawalAndTransfersBlockedInfoResponseSDKType>(endpoint);
+  }
+  /* Queries the collateral pool account address for a perpetual id. */
+
+
+  async collateralPoolAddress(params: QueryCollateralPoolAddressRequest): Promise<QueryCollateralPoolAddressResponseSDKType> {
+    const endpoint = `zogux/subaccounts/collateral_pool_address/${params.perpetualId}`;
+    return await this.req.get<QueryCollateralPoolAddressResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/zogux/subaccounts/query.rpc.Query.ts

@@ -0,0 +1,82 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGetSubaccountRequest, QuerySubaccountResponse, QueryAllSubaccountRequest, QuerySubaccountAllResponse, QueryGetWithdrawalAndTransfersBlockedInfoRequest, QueryGetWithdrawalAndTransfersBlockedInfoResponse, QueryCollateralPoolAddressRequest, QueryCollateralPoolAddressResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Queries a Subaccount by id */
+  subaccount(request: QueryGetSubaccountRequest): Promise<QuerySubaccountResponse>;
+  /** Queries a list of Subaccount items. */
+
+  subaccountAll(request?: QueryAllSubaccountRequest): Promise<QuerySubaccountAllResponse>;
+  /**
+   * Queries information about whether withdrawal and transfers are blocked, and
+   * if so which block they are re-enabled on.
+   */
+
+  getWithdrawalAndTransfersBlockedInfo(request: QueryGetWithdrawalAndTransfersBlockedInfoRequest): Promise<QueryGetWithdrawalAndTransfersBlockedInfoResponse>;
+  /** Queries the collateral pool account address for a perpetual id. */
+
+  collateralPoolAddress(request: QueryCollateralPoolAddressRequest): Promise<QueryCollateralPoolAddressResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.subaccount = this.subaccount.bind(this);
+    this.subaccountAll = this.subaccountAll.bind(this);
+    this.getWithdrawalAndTransfersBlockedInfo = this.getWithdrawalAndTransfersBlockedInfo.bind(this);
+    this.collateralPoolAddress = this.collateralPoolAddress.bind(this);
+  }
+
+  subaccount(request: QueryGetSubaccountRequest): Promise<QuerySubaccountResponse> {
+    const data = QueryGetSubaccountRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.subaccounts.Query", "Subaccount", data);
+    return promise.then(data => QuerySubaccountResponse.decode(new _m0.Reader(data)));
+  }
+
+  subaccountAll(request: QueryAllSubaccountRequest = {
+    pagination: undefined
+  }): Promise<QuerySubaccountAllResponse> {
+    const data = QueryAllSubaccountRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.subaccounts.Query", "SubaccountAll", data);
+    return promise.then(data => QuerySubaccountAllResponse.decode(new _m0.Reader(data)));
+  }
+
+  getWithdrawalAndTransfersBlockedInfo(request: QueryGetWithdrawalAndTransfersBlockedInfoRequest): Promise<QueryGetWithdrawalAndTransfersBlockedInfoResponse> {
+    const data = QueryGetWithdrawalAndTransfersBlockedInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.subaccounts.Query", "GetWithdrawalAndTransfersBlockedInfo", data);
+    return promise.then(data => QueryGetWithdrawalAndTransfersBlockedInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  collateralPoolAddress(request: QueryCollateralPoolAddressRequest): Promise<QueryCollateralPoolAddressResponse> {
+    const data = QueryCollateralPoolAddressRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.subaccounts.Query", "CollateralPoolAddress", data);
+    return promise.then(data => QueryCollateralPoolAddressResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    subaccount(request: QueryGetSubaccountRequest): Promise<QuerySubaccountResponse> {
+      return queryService.subaccount(request);
+    },
+
+    subaccountAll(request?: QueryAllSubaccountRequest): Promise<QuerySubaccountAllResponse> {
+      return queryService.subaccountAll(request);
+    },
+
+    getWithdrawalAndTransfersBlockedInfo(request: QueryGetWithdrawalAndTransfersBlockedInfoRequest): Promise<QueryGetWithdrawalAndTransfersBlockedInfoResponse> {
+      return queryService.getWithdrawalAndTransfersBlockedInfo(request);
+    },
+
+    collateralPoolAddress(request: QueryCollateralPoolAddressRequest): Promise<QueryCollateralPoolAddressResponse> {
+      return queryService.collateralPoolAddress(request);
+    }
+
+  };
+};