@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/base/node/v1beta1/query.lcd.ts

@@ -0,0 +1,30 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { ConfigRequest, ConfigResponseSDKType, StatusRequest, StatusResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.config = this.config.bind(this);
+    this.status = this.status.bind(this);
+  }
+  /* Config queries for the operator configuration. */
+
+
+  async config(_params: ConfigRequest = {}): Promise<ConfigResponseSDKType> {
+    const endpoint = `cosmos/base/node/v1beta1/config`;
+    return await this.req.get<ConfigResponseSDKType>(endpoint);
+  }
+  /* Status queries for the node status. */
+
+
+  async status(_params: StatusRequest = {}): Promise<StatusResponseSDKType> {
+    const endpoint = `cosmos/base/node/v1beta1/status`;
+    return await this.req.get<StatusResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/cosmos/base/node/v1beta1/query.rpc.Service.ts

@@ -0,0 +1,49 @@
+import { Rpc } from "../../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { ConfigRequest, ConfigResponse, StatusRequest, StatusResponse } from "./query";
+/** Service defines the gRPC querier service for node related queries. */
+
+export interface Service {
+  /** Config queries for the operator configuration. */
+  config(request?: ConfigRequest): Promise<ConfigResponse>;
+  /** Status queries for the node status. */
+
+  status(request?: StatusRequest): Promise<StatusResponse>;
+}
+export class ServiceClientImpl implements Service {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.config = this.config.bind(this);
+    this.status = this.status.bind(this);
+  }
+
+  config(request: ConfigRequest = {}): Promise<ConfigResponse> {
+    const data = ConfigRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.node.v1beta1.Service", "Config", data);
+    return promise.then(data => ConfigResponse.decode(new _m0.Reader(data)));
+  }
+
+  status(request: StatusRequest = {}): Promise<StatusResponse> {
+    const data = StatusRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.node.v1beta1.Service", "Status", data);
+    return promise.then(data => StatusResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new ServiceClientImpl(rpc);
+  return {
+    config(request?: ConfigRequest): Promise<ConfigResponse> {
+      return queryService.config(request);
+    },
+
+    status(request?: StatusRequest): Promise<StatusResponse> {
+      return queryService.status(request);
+    }
+
+  };
+};

package/src/codegen/cosmos/base/node/v1beta1/query.ts

@@ -0,0 +1,276 @@
+import { Timestamp } from "../../../../google/protobuf/timestamp";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long, toTimestamp, fromTimestamp } from "../../../../helpers";
+/** ConfigRequest defines the request structure for the Config gRPC query. */
+
+export interface ConfigRequest {}
+/** ConfigRequest defines the request structure for the Config gRPC query. */
+
+export interface ConfigRequestSDKType {}
+/** ConfigResponse defines the response structure for the Config gRPC query. */
+
+export interface ConfigResponse {
+  minimumGasPrice: string;
+  /** pruning settings */
+
+  pruningKeepRecent: string;
+  pruningInterval: string;
+}
+/** ConfigResponse defines the response structure for the Config gRPC query. */
+
+export interface ConfigResponseSDKType {
+  minimum_gas_price: string;
+  pruning_keep_recent: string;
+  pruning_interval: string;
+}
+/** StateRequest defines the request structure for the status of a node. */
+
+export interface StatusRequest {}
+/** StateRequest defines the request structure for the status of a node. */
+
+export interface StatusRequestSDKType {}
+/** StateResponse defines the response structure for the status of a node. */
+
+export interface StatusResponse {
+  /** earliest block height available in the store */
+  earliestStoreHeight: Long;
+  /** current block height */
+
+  height: Long;
+  /** block height timestamp */
+
+  timestamp?: Date;
+  /** app hash of the current block */
+
+  appHash: Uint8Array;
+  /** validator hash provided by the consensus header */
+
+  validatorHash: Uint8Array;
+}
+/** StateResponse defines the response structure for the status of a node. */
+
+export interface StatusResponseSDKType {
+  earliest_store_height: Long;
+  height: Long;
+  timestamp?: Date;
+  app_hash: Uint8Array;
+  validator_hash: Uint8Array;
+}
+
+function createBaseConfigRequest(): ConfigRequest {
+  return {};
+}
+
+export const ConfigRequest = {
+  encode(_: ConfigRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ConfigRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<ConfigRequest>): ConfigRequest {
+    const message = createBaseConfigRequest();
+    return message;
+  }
+
+};
+
+function createBaseConfigResponse(): ConfigResponse {
+  return {
+    minimumGasPrice: "",
+    pruningKeepRecent: "",
+    pruningInterval: ""
+  };
+}
+
+export const ConfigResponse = {
+  encode(message: ConfigResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.minimumGasPrice !== "") {
+      writer.uint32(10).string(message.minimumGasPrice);
+    }
+
+    if (message.pruningKeepRecent !== "") {
+      writer.uint32(18).string(message.pruningKeepRecent);
+    }
+
+    if (message.pruningInterval !== "") {
+      writer.uint32(26).string(message.pruningInterval);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ConfigResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.minimumGasPrice = reader.string();
+          break;
+
+        case 2:
+          message.pruningKeepRecent = reader.string();
+          break;
+
+        case 3:
+          message.pruningInterval = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ConfigResponse>): ConfigResponse {
+    const message = createBaseConfigResponse();
+    message.minimumGasPrice = object.minimumGasPrice ?? "";
+    message.pruningKeepRecent = object.pruningKeepRecent ?? "";
+    message.pruningInterval = object.pruningInterval ?? "";
+    return message;
+  }
+
+};
+
+function createBaseStatusRequest(): StatusRequest {
+  return {};
+}
+
+export const StatusRequest = {
+  encode(_: StatusRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StatusRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStatusRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<StatusRequest>): StatusRequest {
+    const message = createBaseStatusRequest();
+    return message;
+  }
+
+};
+
+function createBaseStatusResponse(): StatusResponse {
+  return {
+    earliestStoreHeight: Long.UZERO,
+    height: Long.UZERO,
+    timestamp: undefined,
+    appHash: new Uint8Array(),
+    validatorHash: new Uint8Array()
+  };
+}
+
+export const StatusResponse = {
+  encode(message: StatusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.earliestStoreHeight.isZero()) {
+      writer.uint32(8).uint64(message.earliestStoreHeight);
+    }
+
+    if (!message.height.isZero()) {
+      writer.uint32(16).uint64(message.height);
+    }
+
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.appHash.length !== 0) {
+      writer.uint32(34).bytes(message.appHash);
+    }
+
+    if (message.validatorHash.length !== 0) {
+      writer.uint32(42).bytes(message.validatorHash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StatusResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStatusResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.earliestStoreHeight = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.height = (reader.uint64() as Long);
+          break;
+
+        case 3:
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.appHash = reader.bytes();
+          break;
+
+        case 5:
+          message.validatorHash = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StatusResponse>): StatusResponse {
+    const message = createBaseStatusResponse();
+    message.earliestStoreHeight = object.earliestStoreHeight !== undefined && object.earliestStoreHeight !== null ? Long.fromValue(object.earliestStoreHeight) : Long.UZERO;
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.UZERO;
+    message.timestamp = object.timestamp ?? undefined;
+    message.appHash = object.appHash ?? new Uint8Array();
+    message.validatorHash = object.validatorHash ?? new Uint8Array();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/base/query/v1beta1/pagination.ts

@@ -0,0 +1,243 @@
+import { Long, DeepPartial } from "../../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ * 
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+
+export interface PageRequest {
+  /**
+   * key is a value returned in PageResponse.next_key to begin
+   * querying the next page most efficiently. Only one of offset or key
+   * should be set.
+   */
+  key: Uint8Array;
+  /**
+   * offset is a numeric offset that can be used when key is unavailable.
+   * It is less efficient than using key. Only one of offset or key should
+   * be set.
+   */
+
+  offset: Long;
+  /**
+   * limit is the total number of results to be returned in the result page.
+   * If left empty it will default to a value to be set by each app.
+   */
+
+  limit: Long;
+  /**
+   * count_total is set to true  to indicate that the result set should include
+   * a count of the total number of items available for pagination in UIs.
+   * count_total is only respected when offset is used. It is ignored when key
+   * is set.
+   */
+
+  countTotal: boolean;
+  /**
+   * reverse is set to true if results are to be returned in the descending order.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+
+  reverse: boolean;
+}
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ * 
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+
+export interface PageRequestSDKType {
+  key: Uint8Array;
+  offset: Long;
+  limit: Long;
+  count_total: boolean;
+  reverse: boolean;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ * 
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+
+export interface PageResponse {
+  /**
+   * next_key is the key to be passed to PageRequest.key to
+   * query the next page most efficiently. It will be empty if
+   * there are no more results.
+   */
+  nextKey: Uint8Array;
+  /**
+   * total is total number of results available if PageRequest.count_total
+   * was set, its value is undefined otherwise
+   */
+
+  total: Long;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ * 
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+
+export interface PageResponseSDKType {
+  next_key: Uint8Array;
+  total: Long;
+}
+
+function createBasePageRequest(): PageRequest {
+  return {
+    key: new Uint8Array(),
+    offset: Long.UZERO,
+    limit: Long.UZERO,
+    countTotal: false,
+    reverse: false
+  };
+}
+
+export const PageRequest = {
+  encode(message: PageRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (!message.offset.isZero()) {
+      writer.uint32(16).uint64(message.offset);
+    }
+
+    if (!message.limit.isZero()) {
+      writer.uint32(24).uint64(message.limit);
+    }
+
+    if (message.countTotal === true) {
+      writer.uint32(32).bool(message.countTotal);
+    }
+
+    if (message.reverse === true) {
+      writer.uint32(40).bool(message.reverse);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PageRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePageRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.offset = (reader.uint64() as Long);
+          break;
+
+        case 3:
+          message.limit = (reader.uint64() as Long);
+          break;
+
+        case 4:
+          message.countTotal = reader.bool();
+          break;
+
+        case 5:
+          message.reverse = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PageRequest>): PageRequest {
+    const message = createBasePageRequest();
+    message.key = object.key ?? new Uint8Array();
+    message.offset = object.offset !== undefined && object.offset !== null ? Long.fromValue(object.offset) : Long.UZERO;
+    message.limit = object.limit !== undefined && object.limit !== null ? Long.fromValue(object.limit) : Long.UZERO;
+    message.countTotal = object.countTotal ?? false;
+    message.reverse = object.reverse ?? false;
+    return message;
+  }
+
+};
+
+function createBasePageResponse(): PageResponse {
+  return {
+    nextKey: new Uint8Array(),
+    total: Long.UZERO
+  };
+}
+
+export const PageResponse = {
+  encode(message: PageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.nextKey.length !== 0) {
+      writer.uint32(10).bytes(message.nextKey);
+    }
+
+    if (!message.total.isZero()) {
+      writer.uint32(16).uint64(message.total);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PageResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePageResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.nextKey = reader.bytes();
+          break;
+
+        case 2:
+          message.total = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PageResponse>): PageResponse {
+    const message = createBasePageResponse();
+    message.nextKey = object.nextKey ?? new Uint8Array();
+    message.total = object.total !== undefined && object.total !== null ? Long.fromValue(object.total) : Long.UZERO;
+    return message;
+  }
+
+};