juno-network 0.15.0 → 0.17.0

package/src/codegen/cosmos/orm/v1alpha1/schema.ts

@@ -0,0 +1,348 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/** StorageType */
+export enum StorageType {
+  /**
+   * STORAGE_TYPE_DEFAULT_UNSPECIFIED - STORAGE_TYPE_DEFAULT_UNSPECIFIED indicates the persistent
+   * KV-storage where primary key entries are stored in merkle-tree
+   * backed commitment storage and indexes and seqs are stored in
+   * fast index storage. Note that the Cosmos SDK before store/v2alpha1
+   * does not support this.
+   */
+  STORAGE_TYPE_DEFAULT_UNSPECIFIED = 0,
+  /**
+   * STORAGE_TYPE_MEMORY - STORAGE_TYPE_MEMORY indicates in-memory storage that will be
+   * reloaded every time an app restarts. Tables with this type of storage
+   * will by default be ignored when importing and exporting a module's
+   * state from JSON.
+   */
+  STORAGE_TYPE_MEMORY = 1,
+  /**
+   * STORAGE_TYPE_TRANSIENT - STORAGE_TYPE_TRANSIENT indicates transient storage that is reset
+   * at the end of every block. Tables with this type of storage
+   * will by default be ignored when importing and exporting a module's
+   * state from JSON.
+   */
+  STORAGE_TYPE_TRANSIENT = 2,
+  /**
+   * STORAGE_TYPE_INDEX - STORAGE_TYPE_INDEX indicates persistent storage which is not backed
+   * by a merkle-tree and won't affect the app hash. Note that the Cosmos SDK
+   * before store/v2alpha1 does not support this.
+   */
+  STORAGE_TYPE_INDEX = 3,
+  /**
+   * STORAGE_TYPE_COMMITMENT - STORAGE_TYPE_INDEX indicates persistent storage which is backed by
+   * a merkle-tree. With this type of storage, both primary and index keys
+   * will affect the app hash and this is generally less efficient
+   * than using STORAGE_TYPE_DEFAULT_UNSPECIFIED which separates index
+   * keys into index storage. Note that modules built with the
+   * Cosmos SDK before store/v2alpha1 must specify STORAGE_TYPE_COMMITMENT
+   * instead of STORAGE_TYPE_DEFAULT_UNSPECIFIED or STORAGE_TYPE_INDEX
+   * because this is the only type of persistent storage available.
+   */
+  STORAGE_TYPE_COMMITMENT = 4,
+  UNRECOGNIZED = -1,
+}
+export const StorageTypeSDKType = StorageType;
+export const StorageTypeAmino = StorageType;
+export function storageTypeFromJSON(object: any): StorageType {
+  switch (object) {
+    case 0:
+    case "STORAGE_TYPE_DEFAULT_UNSPECIFIED":
+      return StorageType.STORAGE_TYPE_DEFAULT_UNSPECIFIED;
+    case 1:
+    case "STORAGE_TYPE_MEMORY":
+      return StorageType.STORAGE_TYPE_MEMORY;
+    case 2:
+    case "STORAGE_TYPE_TRANSIENT":
+      return StorageType.STORAGE_TYPE_TRANSIENT;
+    case 3:
+    case "STORAGE_TYPE_INDEX":
+      return StorageType.STORAGE_TYPE_INDEX;
+    case 4:
+    case "STORAGE_TYPE_COMMITMENT":
+      return StorageType.STORAGE_TYPE_COMMITMENT;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return StorageType.UNRECOGNIZED;
+  }
+}
+export function storageTypeToJSON(object: StorageType): string {
+  switch (object) {
+    case StorageType.STORAGE_TYPE_DEFAULT_UNSPECIFIED:
+      return "STORAGE_TYPE_DEFAULT_UNSPECIFIED";
+    case StorageType.STORAGE_TYPE_MEMORY:
+      return "STORAGE_TYPE_MEMORY";
+    case StorageType.STORAGE_TYPE_TRANSIENT:
+      return "STORAGE_TYPE_TRANSIENT";
+    case StorageType.STORAGE_TYPE_INDEX:
+      return "STORAGE_TYPE_INDEX";
+    case StorageType.STORAGE_TYPE_COMMITMENT:
+      return "STORAGE_TYPE_COMMITMENT";
+    case StorageType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+export interface ModuleSchemaDescriptor {
+  schemaFile: ModuleSchemaDescriptor_FileEntry[];
+  /**
+   * prefix is an optional prefix that precedes all keys in this module's
+   * store.
+   */
+  prefix: Uint8Array;
+}
+export interface ModuleSchemaDescriptorProtoMsg {
+  typeUrl: "/cosmos.orm.v1alpha1.ModuleSchemaDescriptor";
+  value: Uint8Array;
+}
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+export interface ModuleSchemaDescriptorAmino {
+  schema_file?: ModuleSchemaDescriptor_FileEntryAmino[];
+  /**
+   * prefix is an optional prefix that precedes all keys in this module's
+   * store.
+   */
+  prefix?: string;
+}
+export interface ModuleSchemaDescriptorAminoMsg {
+  type: "cosmos-sdk/ModuleSchemaDescriptor";
+  value: ModuleSchemaDescriptorAmino;
+}
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+export interface ModuleSchemaDescriptorSDKType {
+  schema_file: ModuleSchemaDescriptor_FileEntrySDKType[];
+  prefix: Uint8Array;
+}
+/** FileEntry describes an ORM file used in a module. */
+export interface ModuleSchemaDescriptor_FileEntry {
+  /**
+   * id is a prefix that will be varint encoded and prepended to all the
+   * table keys specified in the file's tables.
+   */
+  id: number;
+  /**
+   * proto_file_name is the name of a file .proto in that contains
+   * table definitions. The .proto file must be in a package that the
+   * module has referenced using cosmos.app.v1.ModuleDescriptor.use_package.
+   */
+  protoFileName: string;
+  /**
+   * storage_type optionally indicates the type of storage this file's
+   * tables should used. If it is left unspecified, the default KV-storage
+   * of the app will be used.
+   */
+  storageType: StorageType;
+}
+export interface ModuleSchemaDescriptor_FileEntryProtoMsg {
+  typeUrl: "/cosmos.orm.v1alpha1.FileEntry";
+  value: Uint8Array;
+}
+/** FileEntry describes an ORM file used in a module. */
+export interface ModuleSchemaDescriptor_FileEntryAmino {
+  /**
+   * id is a prefix that will be varint encoded and prepended to all the
+   * table keys specified in the file's tables.
+   */
+  id?: number;
+  /**
+   * proto_file_name is the name of a file .proto in that contains
+   * table definitions. The .proto file must be in a package that the
+   * module has referenced using cosmos.app.v1.ModuleDescriptor.use_package.
+   */
+  proto_file_name?: string;
+  /**
+   * storage_type optionally indicates the type of storage this file's
+   * tables should used. If it is left unspecified, the default KV-storage
+   * of the app will be used.
+   */
+  storage_type?: StorageType;
+}
+export interface ModuleSchemaDescriptor_FileEntryAminoMsg {
+  type: "cosmos-sdk/FileEntry";
+  value: ModuleSchemaDescriptor_FileEntryAmino;
+}
+/** FileEntry describes an ORM file used in a module. */
+export interface ModuleSchemaDescriptor_FileEntrySDKType {
+  id: number;
+  proto_file_name: string;
+  storage_type: StorageType;
+}
+function createBaseModuleSchemaDescriptor(): ModuleSchemaDescriptor {
+  return {
+    schemaFile: [],
+    prefix: new Uint8Array()
+  };
+}
+export const ModuleSchemaDescriptor = {
+  typeUrl: "/cosmos.orm.v1alpha1.ModuleSchemaDescriptor",
+  encode(message: ModuleSchemaDescriptor, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.schemaFile) {
+      ModuleSchemaDescriptor_FileEntry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.prefix.length !== 0) {
+      writer.uint32(18).bytes(message.prefix);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ModuleSchemaDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleSchemaDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.schemaFile.push(ModuleSchemaDescriptor_FileEntry.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.prefix = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ModuleSchemaDescriptor>): ModuleSchemaDescriptor {
+    const message = createBaseModuleSchemaDescriptor();
+    message.schemaFile = object.schemaFile?.map(e => ModuleSchemaDescriptor_FileEntry.fromPartial(e)) || [];
+    message.prefix = object.prefix ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: ModuleSchemaDescriptorAmino): ModuleSchemaDescriptor {
+    const message = createBaseModuleSchemaDescriptor();
+    message.schemaFile = object.schema_file?.map(e => ModuleSchemaDescriptor_FileEntry.fromAmino(e)) || [];
+    if (object.prefix !== undefined && object.prefix !== null) {
+      message.prefix = bytesFromBase64(object.prefix);
+    }
+    return message;
+  },
+  toAmino(message: ModuleSchemaDescriptor): ModuleSchemaDescriptorAmino {
+    const obj: any = {};
+    if (message.schemaFile) {
+      obj.schema_file = message.schemaFile.map(e => e ? ModuleSchemaDescriptor_FileEntry.toAmino(e) : undefined);
+    } else {
+      obj.schema_file = [];
+    }
+    obj.prefix = message.prefix ? base64FromBytes(message.prefix) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ModuleSchemaDescriptorAminoMsg): ModuleSchemaDescriptor {
+    return ModuleSchemaDescriptor.fromAmino(object.value);
+  },
+  toAminoMsg(message: ModuleSchemaDescriptor): ModuleSchemaDescriptorAminoMsg {
+    return {
+      type: "cosmos-sdk/ModuleSchemaDescriptor",
+      value: ModuleSchemaDescriptor.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleSchemaDescriptorProtoMsg): ModuleSchemaDescriptor {
+    return ModuleSchemaDescriptor.decode(message.value);
+  },
+  toProto(message: ModuleSchemaDescriptor): Uint8Array {
+    return ModuleSchemaDescriptor.encode(message).finish();
+  },
+  toProtoMsg(message: ModuleSchemaDescriptor): ModuleSchemaDescriptorProtoMsg {
+    return {
+      typeUrl: "/cosmos.orm.v1alpha1.ModuleSchemaDescriptor",
+      value: ModuleSchemaDescriptor.encode(message).finish()
+    };
+  }
+};
+function createBaseModuleSchemaDescriptor_FileEntry(): ModuleSchemaDescriptor_FileEntry {
+  return {
+    id: 0,
+    protoFileName: "",
+    storageType: 0
+  };
+}
+export const ModuleSchemaDescriptor_FileEntry = {
+  typeUrl: "/cosmos.orm.v1alpha1.FileEntry",
+  encode(message: ModuleSchemaDescriptor_FileEntry, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+    if (message.protoFileName !== "") {
+      writer.uint32(18).string(message.protoFileName);
+    }
+    if (message.storageType !== 0) {
+      writer.uint32(24).int32(message.storageType);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ModuleSchemaDescriptor_FileEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+        case 2:
+          message.protoFileName = reader.string();
+          break;
+        case 3:
+          message.storageType = (reader.int32() as any);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ModuleSchemaDescriptor_FileEntry>): ModuleSchemaDescriptor_FileEntry {
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+    message.id = object.id ?? 0;
+    message.protoFileName = object.protoFileName ?? "";
+    message.storageType = object.storageType ?? 0;
+    return message;
+  },
+  fromAmino(object: ModuleSchemaDescriptor_FileEntryAmino): ModuleSchemaDescriptor_FileEntry {
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+    if (object.id !== undefined && object.id !== null) {
+      message.id = object.id;
+    }
+    if (object.proto_file_name !== undefined && object.proto_file_name !== null) {
+      message.protoFileName = object.proto_file_name;
+    }
+    if (object.storage_type !== undefined && object.storage_type !== null) {
+      message.storageType = storageTypeFromJSON(object.storage_type);
+    }
+    return message;
+  },
+  toAmino(message: ModuleSchemaDescriptor_FileEntry): ModuleSchemaDescriptor_FileEntryAmino {
+    const obj: any = {};
+    obj.id = message.id;
+    obj.proto_file_name = message.protoFileName;
+    obj.storage_type = storageTypeToJSON(message.storageType);
+    return obj;
+  },
+  fromAminoMsg(object: ModuleSchemaDescriptor_FileEntryAminoMsg): ModuleSchemaDescriptor_FileEntry {
+    return ModuleSchemaDescriptor_FileEntry.fromAmino(object.value);
+  },
+  toAminoMsg(message: ModuleSchemaDescriptor_FileEntry): ModuleSchemaDescriptor_FileEntryAminoMsg {
+    return {
+      type: "cosmos-sdk/FileEntry",
+      value: ModuleSchemaDescriptor_FileEntry.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleSchemaDescriptor_FileEntryProtoMsg): ModuleSchemaDescriptor_FileEntry {
+    return ModuleSchemaDescriptor_FileEntry.decode(message.value);
+  },
+  toProto(message: ModuleSchemaDescriptor_FileEntry): Uint8Array {
+    return ModuleSchemaDescriptor_FileEntry.encode(message).finish();
+  },
+  toProtoMsg(message: ModuleSchemaDescriptor_FileEntry): ModuleSchemaDescriptor_FileEntryProtoMsg {
+    return {
+      typeUrl: "/cosmos.orm.v1alpha1.FileEntry",
+      value: ModuleSchemaDescriptor_FileEntry.encode(message).finish()
+    };
+  }
+};

package/src/codegen/cosmos/params/v1beta1/params.ts

@@ -0,0 +1,250 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposal {
+  title: string;
+  description: string;
+  changes: ParamChange[];
+}
+export interface ParameterChangeProposalProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal";
+  value: Uint8Array;
+}
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposalAmino {
+  title?: string;
+  description?: string;
+  changes?: ParamChangeAmino[];
+}
+export interface ParameterChangeProposalAminoMsg {
+  type: "cosmos-sdk/ParameterChangeProposal";
+  value: ParameterChangeProposalAmino;
+}
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposalSDKType {
+  title: string;
+  description: string;
+  changes: ParamChangeSDKType[];
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChange {
+  subspace: string;
+  key: string;
+  value: string;
+}
+export interface ParamChangeProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange";
+  value: Uint8Array;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChangeAmino {
+  subspace?: string;
+  key?: string;
+  value?: string;
+}
+export interface ParamChangeAminoMsg {
+  type: "cosmos-sdk/ParamChange";
+  value: ParamChangeAmino;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChangeSDKType {
+  subspace: string;
+  key: string;
+  value: string;
+}
+function createBaseParameterChangeProposal(): ParameterChangeProposal {
+  return {
+    title: "",
+    description: "",
+    changes: []
+  };
+}
+export const ParameterChangeProposal = {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+  encode(message: ParameterChangeProposal, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.title !== "") {
+      writer.uint32(10).string(message.title);
+    }
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+    for (const v of message.changes) {
+      ParamChange.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ParameterChangeProposal {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParameterChangeProposal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.title = reader.string();
+          break;
+        case 2:
+          message.description = reader.string();
+          break;
+        case 3:
+          message.changes.push(ParamChange.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ParameterChangeProposal>): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    message.title = object.title ?? "";
+    message.description = object.description ?? "";
+    message.changes = object.changes?.map(e => ParamChange.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: ParameterChangeProposalAmino): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    if (object.title !== undefined && object.title !== null) {
+      message.title = object.title;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    message.changes = object.changes?.map(e => ParamChange.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: ParameterChangeProposal): ParameterChangeProposalAmino {
+    const obj: any = {};
+    obj.title = message.title;
+    obj.description = message.description;
+    if (message.changes) {
+      obj.changes = message.changes.map(e => e ? ParamChange.toAmino(e) : undefined);
+    } else {
+      obj.changes = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ParameterChangeProposalAminoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParameterChangeProposal): ParameterChangeProposalAminoMsg {
+    return {
+      type: "cosmos-sdk/ParameterChangeProposal",
+      value: ParameterChangeProposal.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParameterChangeProposalProtoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.decode(message.value);
+  },
+  toProto(message: ParameterChangeProposal): Uint8Array {
+    return ParameterChangeProposal.encode(message).finish();
+  },
+  toProtoMsg(message: ParameterChangeProposal): ParameterChangeProposalProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+      value: ParameterChangeProposal.encode(message).finish()
+    };
+  }
+};
+function createBaseParamChange(): ParamChange {
+  return {
+    subspace: "",
+    key: "",
+    value: ""
+  };
+}
+export const ParamChange = {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange",
+  encode(message: ParamChange, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+    if (message.key !== "") {
+      writer.uint32(18).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(26).string(message.value);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ParamChange {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParamChange();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+        case 2:
+          message.key = reader.string();
+          break;
+        case 3:
+          message.value = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ParamChange>): ParamChange {
+    const message = createBaseParamChange();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+  fromAmino(object: ParamChangeAmino): ParamChange {
+    const message = createBaseParamChange();
+    if (object.subspace !== undefined && object.subspace !== null) {
+      message.subspace = object.subspace;
+    }
+    if (object.key !== undefined && object.key !== null) {
+      message.key = object.key;
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = object.value;
+    }
+    return message;
+  },
+  toAmino(message: ParamChange): ParamChangeAmino {
+    const obj: any = {};
+    obj.subspace = message.subspace;
+    obj.key = message.key;
+    obj.value = message.value;
+    return obj;
+  },
+  fromAminoMsg(object: ParamChangeAminoMsg): ParamChange {
+    return ParamChange.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParamChange): ParamChangeAminoMsg {
+    return {
+      type: "cosmos-sdk/ParamChange",
+      value: ParamChange.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamChangeProtoMsg): ParamChange {
+    return ParamChange.decode(message.value);
+  },
+  toProto(message: ParamChange): Uint8Array {
+    return ParamChange.encode(message).finish();
+  },
+  toProtoMsg(message: ParamChange): ParamChangeProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParamChange",
+      value: ParamChange.encode(message).finish()
+    };
+  }
+};

package/src/codegen/cosmos/params/v1beta1/query.lcd.ts

@@ -0,0 +1,34 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QuerySubspacesRequest, QuerySubspacesResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+  /* Params queries a specific parameter of a module, given its subspace and
+   key. */
+  async params(params: QueryParamsRequest): Promise<QueryParamsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.subspace !== "undefined") {
+      options.params.subspace = params.subspace;
+    }
+    if (typeof params?.key !== "undefined") {
+      options.params.key = params.key;
+    }
+    const endpoint = `cosmos/params/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint, options);
+  }
+  /* Subspaces queries for all registered subspaces and all keys for a subspace. */
+  async subspaces(_params: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponseSDKType> {
+    const endpoint = `cosmos/params/v1beta1/subspaces`;
+    return await this.req.get<QuerySubspacesResponseSDKType>(endpoint);
+  }
+}

package/src/codegen/cosmos/params/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,44 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QuerySubspacesRequest, QuerySubspacesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /**
+   * Params queries a specific parameter of a module, given its subspace and
+   * key.
+   */
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Subspaces queries for all registered subspaces and all keys for a subspace. */
+  subspaces(request?: QuerySubspacesRequest): Promise<QuerySubspacesResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  subspaces(request: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponse> {
+    const data = QuerySubspacesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Subspaces", data);
+    return promise.then(data => QuerySubspacesResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    subspaces(request?: QuerySubspacesRequest): Promise<QuerySubspacesResponse> {
+      return queryService.subspaces(request);
+    }
+  };
+};