decentralcardgame-cardchain-client-ts 0.0.29 → 0.0.31

package/types/cosmos/base/reflection/v2alpha1/reflection.ts

@@ -0,0 +1,2092 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               unknown
+// source: cosmos/base/reflection/v2alpha1/reflection.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "cosmos.base.reflection.v2alpha1";
+
+/** Since: cosmos-sdk 0.43 */
+
+/** AppDescriptor describes a cosmos-sdk based application */
+export interface AppDescriptor {
+  /**
+   * AuthnDescriptor provides information on how to authenticate transactions on the application
+   * NOTE: experimental and subject to change in future releases.
+   */
+  authn:
+    | AuthnDescriptor
+    | undefined;
+  /** chain provides the chain descriptor */
+  chain:
+    | ChainDescriptor
+    | undefined;
+  /** codec provides metadata information regarding codec related types */
+  codec:
+    | CodecDescriptor
+    | undefined;
+  /** configuration provides metadata information regarding the sdk.Config type */
+  configuration:
+    | ConfigurationDescriptor
+    | undefined;
+  /** query_services provides metadata information regarding the available queriable endpoints */
+  queryServices:
+    | QueryServicesDescriptor
+    | undefined;
+  /** tx provides metadata information regarding how to send transactions to the given application */
+  tx: TxDescriptor | undefined;
+}
+
+/** TxDescriptor describes the accepted transaction type */
+export interface TxDescriptor {
+  /**
+   * fullname is the protobuf fullname of the raw transaction type (for instance the tx.Tx type)
+   * it is not meant to support polymorphism of transaction types, it is supposed to be used by
+   * reflection clients to understand if they can handle a specific transaction type in an application.
+   */
+  fullname: string;
+  /** msgs lists the accepted application messages (sdk.Msg) */
+  msgs: MsgDescriptor[];
+}
+
+/**
+ * AuthnDescriptor provides information on how to sign transactions without relying
+ * on the online RPCs GetTxMetadata and CombineUnsignedTxAndSignatures
+ */
+export interface AuthnDescriptor {
+  /** sign_modes defines the supported signature algorithm */
+  signModes: SigningModeDescriptor[];
+}
+
+/**
+ * SigningModeDescriptor provides information on a signing flow of the application
+ * NOTE(fdymylja): here we could go as far as providing an entire flow on how
+ * to sign a message given a SigningModeDescriptor, but it's better to think about
+ * this another time
+ */
+export interface SigningModeDescriptor {
+  /** name defines the unique name of the signing mode */
+  name: string;
+  /** number is the unique int32 identifier for the sign_mode enum */
+  number: number;
+  /**
+   * authn_info_provider_method_fullname defines the fullname of the method to call to get
+   * the metadata required to authenticate using the provided sign_modes
+   */
+  authnInfoProviderMethodFullname: string;
+}
+
+/** ChainDescriptor describes chain information of the application */
+export interface ChainDescriptor {
+  /** id is the chain id */
+  id: string;
+}
+
+/** CodecDescriptor describes the registered interfaces and provides metadata information on the types */
+export interface CodecDescriptor {
+  /** interfaces is a list of the registerted interfaces descriptors */
+  interfaces: InterfaceDescriptor[];
+}
+
+/** InterfaceDescriptor describes the implementation of an interface */
+export interface InterfaceDescriptor {
+  /** fullname is the name of the interface */
+  fullname: string;
+  /**
+   * interface_accepting_messages contains information regarding the proto messages which contain the interface as
+   * google.protobuf.Any field
+   */
+  interfaceAcceptingMessages: InterfaceAcceptingMessageDescriptor[];
+  /** interface_implementers is a list of the descriptors of the interface implementers */
+  interfaceImplementers: InterfaceImplementerDescriptor[];
+}
+
+/** InterfaceImplementerDescriptor describes an interface implementer */
+export interface InterfaceImplementerDescriptor {
+  /** fullname is the protobuf queryable name of the interface implementer */
+  fullname: string;
+  /**
+   * type_url defines the type URL used when marshalling the type as any
+   * this is required so we can provide type safe google.protobuf.Any marshalling and
+   * unmarshalling, making sure that we don't accept just 'any' type
+   * in our interface fields
+   */
+  typeUrl: string;
+}
+
+/**
+ * InterfaceAcceptingMessageDescriptor describes a protobuf message which contains
+ * an interface represented as a google.protobuf.Any
+ */
+export interface InterfaceAcceptingMessageDescriptor {
+  /** fullname is the protobuf fullname of the type containing the interface */
+  fullname: string;
+  /**
+   * field_descriptor_names is a list of the protobuf name (not fullname) of the field
+   * which contains the interface as google.protobuf.Any (the interface is the same, but
+   * it can be in multiple fields of the same proto message)
+   */
+  fieldDescriptorNames: string[];
+}
+
+/** ConfigurationDescriptor contains metadata information on the sdk.Config */
+export interface ConfigurationDescriptor {
+  /** bech32_account_address_prefix is the account address prefix */
+  bech32AccountAddressPrefix: string;
+}
+
+/** MsgDescriptor describes a cosmos-sdk message that can be delivered with a transaction */
+export interface MsgDescriptor {
+  /** msg_type_url contains the TypeURL of a sdk.Msg. */
+  msgTypeUrl: string;
+}
+
+/** GetAuthnDescriptorRequest is the request used for the GetAuthnDescriptor RPC */
+export interface GetAuthnDescriptorRequest {
+}
+
+/** GetAuthnDescriptorResponse is the response returned by the GetAuthnDescriptor RPC */
+export interface GetAuthnDescriptorResponse {
+  /** authn describes how to authenticate to the application when sending transactions */
+  authn: AuthnDescriptor | undefined;
+}
+
+/** GetChainDescriptorRequest is the request used for the GetChainDescriptor RPC */
+export interface GetChainDescriptorRequest {
+}
+
+/** GetChainDescriptorResponse is the response returned by the GetChainDescriptor RPC */
+export interface GetChainDescriptorResponse {
+  /** chain describes application chain information */
+  chain: ChainDescriptor | undefined;
+}
+
+/** GetCodecDescriptorRequest is the request used for the GetCodecDescriptor RPC */
+export interface GetCodecDescriptorRequest {
+}
+
+/** GetCodecDescriptorResponse is the response returned by the GetCodecDescriptor RPC */
+export interface GetCodecDescriptorResponse {
+  /** codec describes the application codec such as registered interfaces and implementations */
+  codec: CodecDescriptor | undefined;
+}
+
+/** GetConfigurationDescriptorRequest is the request used for the GetConfigurationDescriptor RPC */
+export interface GetConfigurationDescriptorRequest {
+}
+
+/** GetConfigurationDescriptorResponse is the response returned by the GetConfigurationDescriptor RPC */
+export interface GetConfigurationDescriptorResponse {
+  /** config describes the application's sdk.Config */
+  config: ConfigurationDescriptor | undefined;
+}
+
+/** GetQueryServicesDescriptorRequest is the request used for the GetQueryServicesDescriptor RPC */
+export interface GetQueryServicesDescriptorRequest {
+}
+
+/** GetQueryServicesDescriptorResponse is the response returned by the GetQueryServicesDescriptor RPC */
+export interface GetQueryServicesDescriptorResponse {
+  /** queries provides information on the available queryable services */
+  queries: QueryServicesDescriptor | undefined;
+}
+
+/** GetTxDescriptorRequest is the request used for the GetTxDescriptor RPC */
+export interface GetTxDescriptorRequest {
+}
+
+/** GetTxDescriptorResponse is the response returned by the GetTxDescriptor RPC */
+export interface GetTxDescriptorResponse {
+  /**
+   * tx provides information on msgs that can be forwarded to the application
+   * alongside the accepted transaction protobuf type
+   */
+  tx: TxDescriptor | undefined;
+}
+
+/** QueryServicesDescriptor contains the list of cosmos-sdk queriable services */
+export interface QueryServicesDescriptor {
+  /** query_services is a list of cosmos-sdk QueryServiceDescriptor */
+  queryServices: QueryServiceDescriptor[];
+}
+
+/** QueryServiceDescriptor describes a cosmos-sdk queryable service */
+export interface QueryServiceDescriptor {
+  /** fullname is the protobuf fullname of the service descriptor */
+  fullname: string;
+  /** is_module describes if this service is actually exposed by an application's module */
+  isModule: boolean;
+  /** methods provides a list of query service methods */
+  methods: QueryMethodDescriptor[];
+}
+
+/**
+ * QueryMethodDescriptor describes a queryable method of a query service
+ * no other info is provided beside method name and tendermint queryable path
+ * because it would be redundant with the grpc reflection service
+ */
+export interface QueryMethodDescriptor {
+  /** name is the protobuf name (not fullname) of the method */
+  name: string;
+  /**
+   * full_query_path is the path that can be used to query
+   * this method via tendermint abci.Query
+   */
+  fullQueryPath: string;
+}
+
+function createBaseAppDescriptor(): AppDescriptor {
+  return {
+    authn: undefined,
+    chain: undefined,
+    codec: undefined,
+    configuration: undefined,
+    queryServices: undefined,
+    tx: undefined,
+  };
+}
+
+export const AppDescriptor: MessageFns<AppDescriptor> = {
+  encode(message: AppDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.authn !== undefined) {
+      AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).join();
+    }
+    if (message.chain !== undefined) {
+      ChainDescriptor.encode(message.chain, writer.uint32(18).fork()).join();
+    }
+    if (message.codec !== undefined) {
+      CodecDescriptor.encode(message.codec, writer.uint32(26).fork()).join();
+    }
+    if (message.configuration !== undefined) {
+      ConfigurationDescriptor.encode(message.configuration, writer.uint32(34).fork()).join();
+    }
+    if (message.queryServices !== undefined) {
+      QueryServicesDescriptor.encode(message.queryServices, writer.uint32(42).fork()).join();
+    }
+    if (message.tx !== undefined) {
+      TxDescriptor.encode(message.tx, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AppDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.authn = AuthnDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.chain = ChainDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.codec = CodecDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.configuration = ConfigurationDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.queryServices = QueryServicesDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.tx = TxDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AppDescriptor {
+    return {
+      authn: isSet(object.authn) ? AuthnDescriptor.fromJSON(object.authn) : undefined,
+      chain: isSet(object.chain) ? ChainDescriptor.fromJSON(object.chain) : undefined,
+      codec: isSet(object.codec) ? CodecDescriptor.fromJSON(object.codec) : undefined,
+      configuration: isSet(object.configuration) ? ConfigurationDescriptor.fromJSON(object.configuration) : undefined,
+      queryServices: isSet(object.queryServices) ? QueryServicesDescriptor.fromJSON(object.queryServices) : undefined,
+      tx: isSet(object.tx) ? TxDescriptor.fromJSON(object.tx) : undefined,
+    };
+  },
+
+  toJSON(message: AppDescriptor): unknown {
+    const obj: any = {};
+    if (message.authn !== undefined) {
+      obj.authn = AuthnDescriptor.toJSON(message.authn);
+    }
+    if (message.chain !== undefined) {
+      obj.chain = ChainDescriptor.toJSON(message.chain);
+    }
+    if (message.codec !== undefined) {
+      obj.codec = CodecDescriptor.toJSON(message.codec);
+    }
+    if (message.configuration !== undefined) {
+      obj.configuration = ConfigurationDescriptor.toJSON(message.configuration);
+    }
+    if (message.queryServices !== undefined) {
+      obj.queryServices = QueryServicesDescriptor.toJSON(message.queryServices);
+    }
+    if (message.tx !== undefined) {
+      obj.tx = TxDescriptor.toJSON(message.tx);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AppDescriptor>, I>>(base?: I): AppDescriptor {
+    return AppDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<AppDescriptor>, I>>(object: I): AppDescriptor {
+    const message = createBaseAppDescriptor();
+    message.authn = (object.authn !== undefined && object.authn !== null)
+      ? AuthnDescriptor.fromPartial(object.authn)
+      : undefined;
+    message.chain = (object.chain !== undefined && object.chain !== null)
+      ? ChainDescriptor.fromPartial(object.chain)
+      : undefined;
+    message.codec = (object.codec !== undefined && object.codec !== null)
+      ? CodecDescriptor.fromPartial(object.codec)
+      : undefined;
+    message.configuration = (object.configuration !== undefined && object.configuration !== null)
+      ? ConfigurationDescriptor.fromPartial(object.configuration)
+      : undefined;
+    message.queryServices = (object.queryServices !== undefined && object.queryServices !== null)
+      ? QueryServicesDescriptor.fromPartial(object.queryServices)
+      : undefined;
+    message.tx = (object.tx !== undefined && object.tx !== null) ? TxDescriptor.fromPartial(object.tx) : undefined;
+    return message;
+  },
+};
+
+function createBaseTxDescriptor(): TxDescriptor {
+  return { fullname: "", msgs: [] };
+}
+
+export const TxDescriptor: MessageFns<TxDescriptor> = {
+  encode(message: TxDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fullname !== "") {
+      writer.uint32(10).string(message.fullname);
+    }
+    for (const v of message.msgs) {
+      MsgDescriptor.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TxDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTxDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fullname = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.msgs.push(MsgDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TxDescriptor {
+    return {
+      fullname: isSet(object.fullname) ? globalThis.String(object.fullname) : "",
+      msgs: globalThis.Array.isArray(object?.msgs) ? object.msgs.map((e: any) => MsgDescriptor.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TxDescriptor): unknown {
+    const obj: any = {};
+    if (message.fullname !== "") {
+      obj.fullname = message.fullname;
+    }
+    if (message.msgs?.length) {
+      obj.msgs = message.msgs.map((e) => MsgDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TxDescriptor>, I>>(base?: I): TxDescriptor {
+    return TxDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TxDescriptor>, I>>(object: I): TxDescriptor {
+    const message = createBaseTxDescriptor();
+    message.fullname = object.fullname ?? "";
+    message.msgs = object.msgs?.map((e) => MsgDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseAuthnDescriptor(): AuthnDescriptor {
+  return { signModes: [] };
+}
+
+export const AuthnDescriptor: MessageFns<AuthnDescriptor> = {
+  encode(message: AuthnDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.signModes) {
+      SigningModeDescriptor.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AuthnDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAuthnDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.signModes.push(SigningModeDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AuthnDescriptor {
+    return {
+      signModes: globalThis.Array.isArray(object?.signModes)
+        ? object.signModes.map((e: any) => SigningModeDescriptor.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: AuthnDescriptor): unknown {
+    const obj: any = {};
+    if (message.signModes?.length) {
+      obj.signModes = message.signModes.map((e) => SigningModeDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AuthnDescriptor>, I>>(base?: I): AuthnDescriptor {
+    return AuthnDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<AuthnDescriptor>, I>>(object: I): AuthnDescriptor {
+    const message = createBaseAuthnDescriptor();
+    message.signModes = object.signModes?.map((e) => SigningModeDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSigningModeDescriptor(): SigningModeDescriptor {
+  return { name: "", number: 0, authnInfoProviderMethodFullname: "" };
+}
+
+export const SigningModeDescriptor: MessageFns<SigningModeDescriptor> = {
+  encode(message: SigningModeDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.number !== 0) {
+      writer.uint32(16).int32(message.number);
+    }
+    if (message.authnInfoProviderMethodFullname !== "") {
+      writer.uint32(26).string(message.authnInfoProviderMethodFullname);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SigningModeDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSigningModeDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.number = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.authnInfoProviderMethodFullname = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SigningModeDescriptor {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      number: isSet(object.number) ? globalThis.Number(object.number) : 0,
+      authnInfoProviderMethodFullname: isSet(object.authnInfoProviderMethodFullname)
+        ? globalThis.String(object.authnInfoProviderMethodFullname)
+        : "",
+    };
+  },
+
+  toJSON(message: SigningModeDescriptor): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.number !== 0) {
+      obj.number = Math.round(message.number);
+    }
+    if (message.authnInfoProviderMethodFullname !== "") {
+      obj.authnInfoProviderMethodFullname = message.authnInfoProviderMethodFullname;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SigningModeDescriptor>, I>>(base?: I): SigningModeDescriptor {
+    return SigningModeDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SigningModeDescriptor>, I>>(object: I): SigningModeDescriptor {
+    const message = createBaseSigningModeDescriptor();
+    message.name = object.name ?? "";
+    message.number = object.number ?? 0;
+    message.authnInfoProviderMethodFullname = object.authnInfoProviderMethodFullname ?? "";
+    return message;
+  },
+};
+
+function createBaseChainDescriptor(): ChainDescriptor {
+  return { id: "" };
+}
+
+export const ChainDescriptor: MessageFns<ChainDescriptor> = {
+  encode(message: ChainDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ChainDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChainDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ChainDescriptor {
+    return { id: isSet(object.id) ? globalThis.String(object.id) : "" };
+  },
+
+  toJSON(message: ChainDescriptor): unknown {
+    const obj: any = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ChainDescriptor>, I>>(base?: I): ChainDescriptor {
+    return ChainDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ChainDescriptor>, I>>(object: I): ChainDescriptor {
+    const message = createBaseChainDescriptor();
+    message.id = object.id ?? "";
+    return message;
+  },
+};
+
+function createBaseCodecDescriptor(): CodecDescriptor {
+  return { interfaces: [] };
+}
+
+export const CodecDescriptor: MessageFns<CodecDescriptor> = {
+  encode(message: CodecDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.interfaces) {
+      InterfaceDescriptor.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CodecDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCodecDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.interfaces.push(InterfaceDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CodecDescriptor {
+    return {
+      interfaces: globalThis.Array.isArray(object?.interfaces)
+        ? object.interfaces.map((e: any) => InterfaceDescriptor.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: CodecDescriptor): unknown {
+    const obj: any = {};
+    if (message.interfaces?.length) {
+      obj.interfaces = message.interfaces.map((e) => InterfaceDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CodecDescriptor>, I>>(base?: I): CodecDescriptor {
+    return CodecDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CodecDescriptor>, I>>(object: I): CodecDescriptor {
+    const message = createBaseCodecDescriptor();
+    message.interfaces = object.interfaces?.map((e) => InterfaceDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseInterfaceDescriptor(): InterfaceDescriptor {
+  return { fullname: "", interfaceAcceptingMessages: [], interfaceImplementers: [] };
+}
+
+export const InterfaceDescriptor: MessageFns<InterfaceDescriptor> = {
+  encode(message: InterfaceDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fullname !== "") {
+      writer.uint32(10).string(message.fullname);
+    }
+    for (const v of message.interfaceAcceptingMessages) {
+      InterfaceAcceptingMessageDescriptor.encode(v!, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.interfaceImplementers) {
+      InterfaceImplementerDescriptor.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): InterfaceDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInterfaceDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fullname = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.interfaceAcceptingMessages.push(InterfaceAcceptingMessageDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.interfaceImplementers.push(InterfaceImplementerDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): InterfaceDescriptor {
+    return {
+      fullname: isSet(object.fullname) ? globalThis.String(object.fullname) : "",
+      interfaceAcceptingMessages: globalThis.Array.isArray(object?.interfaceAcceptingMessages)
+        ? object.interfaceAcceptingMessages.map((e: any) => InterfaceAcceptingMessageDescriptor.fromJSON(e))
+        : [],
+      interfaceImplementers: globalThis.Array.isArray(object?.interfaceImplementers)
+        ? object.interfaceImplementers.map((e: any) => InterfaceImplementerDescriptor.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: InterfaceDescriptor): unknown {
+    const obj: any = {};
+    if (message.fullname !== "") {
+      obj.fullname = message.fullname;
+    }
+    if (message.interfaceAcceptingMessages?.length) {
+      obj.interfaceAcceptingMessages = message.interfaceAcceptingMessages.map((e) =>
+        InterfaceAcceptingMessageDescriptor.toJSON(e)
+      );
+    }
+    if (message.interfaceImplementers?.length) {
+      obj.interfaceImplementers = message.interfaceImplementers.map((e) => InterfaceImplementerDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<InterfaceDescriptor>, I>>(base?: I): InterfaceDescriptor {
+    return InterfaceDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<InterfaceDescriptor>, I>>(object: I): InterfaceDescriptor {
+    const message = createBaseInterfaceDescriptor();
+    message.fullname = object.fullname ?? "";
+    message.interfaceAcceptingMessages =
+      object.interfaceAcceptingMessages?.map((e) => InterfaceAcceptingMessageDescriptor.fromPartial(e)) || [];
+    message.interfaceImplementers =
+      object.interfaceImplementers?.map((e) => InterfaceImplementerDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseInterfaceImplementerDescriptor(): InterfaceImplementerDescriptor {
+  return { fullname: "", typeUrl: "" };
+}
+
+export const InterfaceImplementerDescriptor: MessageFns<InterfaceImplementerDescriptor> = {
+  encode(message: InterfaceImplementerDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fullname !== "") {
+      writer.uint32(10).string(message.fullname);
+    }
+    if (message.typeUrl !== "") {
+      writer.uint32(18).string(message.typeUrl);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): InterfaceImplementerDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInterfaceImplementerDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fullname = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.typeUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): InterfaceImplementerDescriptor {
+    return {
+      fullname: isSet(object.fullname) ? globalThis.String(object.fullname) : "",
+      typeUrl: isSet(object.typeUrl) ? globalThis.String(object.typeUrl) : "",
+    };
+  },
+
+  toJSON(message: InterfaceImplementerDescriptor): unknown {
+    const obj: any = {};
+    if (message.fullname !== "") {
+      obj.fullname = message.fullname;
+    }
+    if (message.typeUrl !== "") {
+      obj.typeUrl = message.typeUrl;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<InterfaceImplementerDescriptor>, I>>(base?: I): InterfaceImplementerDescriptor {
+    return InterfaceImplementerDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<InterfaceImplementerDescriptor>, I>>(
+    object: I,
+  ): InterfaceImplementerDescriptor {
+    const message = createBaseInterfaceImplementerDescriptor();
+    message.fullname = object.fullname ?? "";
+    message.typeUrl = object.typeUrl ?? "";
+    return message;
+  },
+};
+
+function createBaseInterfaceAcceptingMessageDescriptor(): InterfaceAcceptingMessageDescriptor {
+  return { fullname: "", fieldDescriptorNames: [] };
+}
+
+export const InterfaceAcceptingMessageDescriptor: MessageFns<InterfaceAcceptingMessageDescriptor> = {
+  encode(message: InterfaceAcceptingMessageDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fullname !== "") {
+      writer.uint32(10).string(message.fullname);
+    }
+    for (const v of message.fieldDescriptorNames) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): InterfaceAcceptingMessageDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInterfaceAcceptingMessageDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fullname = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.fieldDescriptorNames.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): InterfaceAcceptingMessageDescriptor {
+    return {
+      fullname: isSet(object.fullname) ? globalThis.String(object.fullname) : "",
+      fieldDescriptorNames: globalThis.Array.isArray(object?.fieldDescriptorNames)
+        ? object.fieldDescriptorNames.map((e: any) => globalThis.String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: InterfaceAcceptingMessageDescriptor): unknown {
+    const obj: any = {};
+    if (message.fullname !== "") {
+      obj.fullname = message.fullname;
+    }
+    if (message.fieldDescriptorNames?.length) {
+      obj.fieldDescriptorNames = message.fieldDescriptorNames;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<InterfaceAcceptingMessageDescriptor>, I>>(
+    base?: I,
+  ): InterfaceAcceptingMessageDescriptor {
+    return InterfaceAcceptingMessageDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<InterfaceAcceptingMessageDescriptor>, I>>(
+    object: I,
+  ): InterfaceAcceptingMessageDescriptor {
+    const message = createBaseInterfaceAcceptingMessageDescriptor();
+    message.fullname = object.fullname ?? "";
+    message.fieldDescriptorNames = object.fieldDescriptorNames?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseConfigurationDescriptor(): ConfigurationDescriptor {
+  return { bech32AccountAddressPrefix: "" };
+}
+
+export const ConfigurationDescriptor: MessageFns<ConfigurationDescriptor> = {
+  encode(message: ConfigurationDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.bech32AccountAddressPrefix !== "") {
+      writer.uint32(10).string(message.bech32AccountAddressPrefix);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfigurationDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigurationDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.bech32AccountAddressPrefix = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConfigurationDescriptor {
+    return {
+      bech32AccountAddressPrefix: isSet(object.bech32AccountAddressPrefix)
+        ? globalThis.String(object.bech32AccountAddressPrefix)
+        : "",
+    };
+  },
+
+  toJSON(message: ConfigurationDescriptor): unknown {
+    const obj: any = {};
+    if (message.bech32AccountAddressPrefix !== "") {
+      obj.bech32AccountAddressPrefix = message.bech32AccountAddressPrefix;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfigurationDescriptor>, I>>(base?: I): ConfigurationDescriptor {
+    return ConfigurationDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfigurationDescriptor>, I>>(object: I): ConfigurationDescriptor {
+    const message = createBaseConfigurationDescriptor();
+    message.bech32AccountAddressPrefix = object.bech32AccountAddressPrefix ?? "";
+    return message;
+  },
+};
+
+function createBaseMsgDescriptor(): MsgDescriptor {
+  return { msgTypeUrl: "" };
+}
+
+export const MsgDescriptor: MessageFns<MsgDescriptor> = {
+  encode(message: MsgDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(10).string(message.msgTypeUrl);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.msgTypeUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDescriptor {
+    return { msgTypeUrl: isSet(object.msgTypeUrl) ? globalThis.String(object.msgTypeUrl) : "" };
+  },
+
+  toJSON(message: MsgDescriptor): unknown {
+    const obj: any = {};
+    if (message.msgTypeUrl !== "") {
+      obj.msgTypeUrl = message.msgTypeUrl;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDescriptor>, I>>(base?: I): MsgDescriptor {
+    return MsgDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDescriptor>, I>>(object: I): MsgDescriptor {
+    const message = createBaseMsgDescriptor();
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    return message;
+  },
+};
+
+function createBaseGetAuthnDescriptorRequest(): GetAuthnDescriptorRequest {
+  return {};
+}
+
+export const GetAuthnDescriptorRequest: MessageFns<GetAuthnDescriptorRequest> = {
+  encode(_: GetAuthnDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAuthnDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetAuthnDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetAuthnDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetAuthnDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetAuthnDescriptorRequest>, I>>(base?: I): GetAuthnDescriptorRequest {
+    return GetAuthnDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetAuthnDescriptorRequest>, I>>(_: I): GetAuthnDescriptorRequest {
+    const message = createBaseGetAuthnDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetAuthnDescriptorResponse(): GetAuthnDescriptorResponse {
+  return { authn: undefined };
+}
+
+export const GetAuthnDescriptorResponse: MessageFns<GetAuthnDescriptorResponse> = {
+  encode(message: GetAuthnDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.authn !== undefined) {
+      AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAuthnDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetAuthnDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.authn = AuthnDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetAuthnDescriptorResponse {
+    return { authn: isSet(object.authn) ? AuthnDescriptor.fromJSON(object.authn) : undefined };
+  },
+
+  toJSON(message: GetAuthnDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.authn !== undefined) {
+      obj.authn = AuthnDescriptor.toJSON(message.authn);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetAuthnDescriptorResponse>, I>>(base?: I): GetAuthnDescriptorResponse {
+    return GetAuthnDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetAuthnDescriptorResponse>, I>>(object: I): GetAuthnDescriptorResponse {
+    const message = createBaseGetAuthnDescriptorResponse();
+    message.authn = (object.authn !== undefined && object.authn !== null)
+      ? AuthnDescriptor.fromPartial(object.authn)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetChainDescriptorRequest(): GetChainDescriptorRequest {
+  return {};
+}
+
+export const GetChainDescriptorRequest: MessageFns<GetChainDescriptorRequest> = {
+  encode(_: GetChainDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetChainDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetChainDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetChainDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetChainDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetChainDescriptorRequest>, I>>(base?: I): GetChainDescriptorRequest {
+    return GetChainDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetChainDescriptorRequest>, I>>(_: I): GetChainDescriptorRequest {
+    const message = createBaseGetChainDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetChainDescriptorResponse(): GetChainDescriptorResponse {
+  return { chain: undefined };
+}
+
+export const GetChainDescriptorResponse: MessageFns<GetChainDescriptorResponse> = {
+  encode(message: GetChainDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.chain !== undefined) {
+      ChainDescriptor.encode(message.chain, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetChainDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetChainDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.chain = ChainDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetChainDescriptorResponse {
+    return { chain: isSet(object.chain) ? ChainDescriptor.fromJSON(object.chain) : undefined };
+  },
+
+  toJSON(message: GetChainDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.chain !== undefined) {
+      obj.chain = ChainDescriptor.toJSON(message.chain);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetChainDescriptorResponse>, I>>(base?: I): GetChainDescriptorResponse {
+    return GetChainDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetChainDescriptorResponse>, I>>(object: I): GetChainDescriptorResponse {
+    const message = createBaseGetChainDescriptorResponse();
+    message.chain = (object.chain !== undefined && object.chain !== null)
+      ? ChainDescriptor.fromPartial(object.chain)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetCodecDescriptorRequest(): GetCodecDescriptorRequest {
+  return {};
+}
+
+export const GetCodecDescriptorRequest: MessageFns<GetCodecDescriptorRequest> = {
+  encode(_: GetCodecDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetCodecDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetCodecDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetCodecDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetCodecDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetCodecDescriptorRequest>, I>>(base?: I): GetCodecDescriptorRequest {
+    return GetCodecDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetCodecDescriptorRequest>, I>>(_: I): GetCodecDescriptorRequest {
+    const message = createBaseGetCodecDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetCodecDescriptorResponse(): GetCodecDescriptorResponse {
+  return { codec: undefined };
+}
+
+export const GetCodecDescriptorResponse: MessageFns<GetCodecDescriptorResponse> = {
+  encode(message: GetCodecDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.codec !== undefined) {
+      CodecDescriptor.encode(message.codec, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetCodecDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetCodecDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.codec = CodecDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetCodecDescriptorResponse {
+    return { codec: isSet(object.codec) ? CodecDescriptor.fromJSON(object.codec) : undefined };
+  },
+
+  toJSON(message: GetCodecDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.codec !== undefined) {
+      obj.codec = CodecDescriptor.toJSON(message.codec);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetCodecDescriptorResponse>, I>>(base?: I): GetCodecDescriptorResponse {
+    return GetCodecDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetCodecDescriptorResponse>, I>>(object: I): GetCodecDescriptorResponse {
+    const message = createBaseGetCodecDescriptorResponse();
+    message.codec = (object.codec !== undefined && object.codec !== null)
+      ? CodecDescriptor.fromPartial(object.codec)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetConfigurationDescriptorRequest(): GetConfigurationDescriptorRequest {
+  return {};
+}
+
+export const GetConfigurationDescriptorRequest: MessageFns<GetConfigurationDescriptorRequest> = {
+  encode(_: GetConfigurationDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetConfigurationDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetConfigurationDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetConfigurationDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetConfigurationDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetConfigurationDescriptorRequest>, I>>(
+    base?: I,
+  ): GetConfigurationDescriptorRequest {
+    return GetConfigurationDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetConfigurationDescriptorRequest>, I>>(
+    _: I,
+  ): GetConfigurationDescriptorRequest {
+    const message = createBaseGetConfigurationDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetConfigurationDescriptorResponse(): GetConfigurationDescriptorResponse {
+  return { config: undefined };
+}
+
+export const GetConfigurationDescriptorResponse: MessageFns<GetConfigurationDescriptorResponse> = {
+  encode(message: GetConfigurationDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.config !== undefined) {
+      ConfigurationDescriptor.encode(message.config, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetConfigurationDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetConfigurationDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.config = ConfigurationDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetConfigurationDescriptorResponse {
+    return { config: isSet(object.config) ? ConfigurationDescriptor.fromJSON(object.config) : undefined };
+  },
+
+  toJSON(message: GetConfigurationDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.config !== undefined) {
+      obj.config = ConfigurationDescriptor.toJSON(message.config);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetConfigurationDescriptorResponse>, I>>(
+    base?: I,
+  ): GetConfigurationDescriptorResponse {
+    return GetConfigurationDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetConfigurationDescriptorResponse>, I>>(
+    object: I,
+  ): GetConfigurationDescriptorResponse {
+    const message = createBaseGetConfigurationDescriptorResponse();
+    message.config = (object.config !== undefined && object.config !== null)
+      ? ConfigurationDescriptor.fromPartial(object.config)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetQueryServicesDescriptorRequest(): GetQueryServicesDescriptorRequest {
+  return {};
+}
+
+export const GetQueryServicesDescriptorRequest: MessageFns<GetQueryServicesDescriptorRequest> = {
+  encode(_: GetQueryServicesDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetQueryServicesDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetQueryServicesDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetQueryServicesDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetQueryServicesDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetQueryServicesDescriptorRequest>, I>>(
+    base?: I,
+  ): GetQueryServicesDescriptorRequest {
+    return GetQueryServicesDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetQueryServicesDescriptorRequest>, I>>(
+    _: I,
+  ): GetQueryServicesDescriptorRequest {
+    const message = createBaseGetQueryServicesDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetQueryServicesDescriptorResponse(): GetQueryServicesDescriptorResponse {
+  return { queries: undefined };
+}
+
+export const GetQueryServicesDescriptorResponse: MessageFns<GetQueryServicesDescriptorResponse> = {
+  encode(message: GetQueryServicesDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.queries !== undefined) {
+      QueryServicesDescriptor.encode(message.queries, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetQueryServicesDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetQueryServicesDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.queries = QueryServicesDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetQueryServicesDescriptorResponse {
+    return { queries: isSet(object.queries) ? QueryServicesDescriptor.fromJSON(object.queries) : undefined };
+  },
+
+  toJSON(message: GetQueryServicesDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.queries !== undefined) {
+      obj.queries = QueryServicesDescriptor.toJSON(message.queries);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetQueryServicesDescriptorResponse>, I>>(
+    base?: I,
+  ): GetQueryServicesDescriptorResponse {
+    return GetQueryServicesDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetQueryServicesDescriptorResponse>, I>>(
+    object: I,
+  ): GetQueryServicesDescriptorResponse {
+    const message = createBaseGetQueryServicesDescriptorResponse();
+    message.queries = (object.queries !== undefined && object.queries !== null)
+      ? QueryServicesDescriptor.fromPartial(object.queries)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetTxDescriptorRequest(): GetTxDescriptorRequest {
+  return {};
+}
+
+export const GetTxDescriptorRequest: MessageFns<GetTxDescriptorRequest> = {
+  encode(_: GetTxDescriptorRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTxDescriptorRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTxDescriptorRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetTxDescriptorRequest {
+    return {};
+  },
+
+  toJSON(_: GetTxDescriptorRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetTxDescriptorRequest>, I>>(base?: I): GetTxDescriptorRequest {
+    return GetTxDescriptorRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetTxDescriptorRequest>, I>>(_: I): GetTxDescriptorRequest {
+    const message = createBaseGetTxDescriptorRequest();
+    return message;
+  },
+};
+
+function createBaseGetTxDescriptorResponse(): GetTxDescriptorResponse {
+  return { tx: undefined };
+}
+
+export const GetTxDescriptorResponse: MessageFns<GetTxDescriptorResponse> = {
+  encode(message: GetTxDescriptorResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.tx !== undefined) {
+      TxDescriptor.encode(message.tx, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTxDescriptorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTxDescriptorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tx = TxDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTxDescriptorResponse {
+    return { tx: isSet(object.tx) ? TxDescriptor.fromJSON(object.tx) : undefined };
+  },
+
+  toJSON(message: GetTxDescriptorResponse): unknown {
+    const obj: any = {};
+    if (message.tx !== undefined) {
+      obj.tx = TxDescriptor.toJSON(message.tx);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetTxDescriptorResponse>, I>>(base?: I): GetTxDescriptorResponse {
+    return GetTxDescriptorResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetTxDescriptorResponse>, I>>(object: I): GetTxDescriptorResponse {
+    const message = createBaseGetTxDescriptorResponse();
+    message.tx = (object.tx !== undefined && object.tx !== null) ? TxDescriptor.fromPartial(object.tx) : undefined;
+    return message;
+  },
+};
+
+function createBaseQueryServicesDescriptor(): QueryServicesDescriptor {
+  return { queryServices: [] };
+}
+
+export const QueryServicesDescriptor: MessageFns<QueryServicesDescriptor> = {
+  encode(message: QueryServicesDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.queryServices) {
+      QueryServiceDescriptor.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryServicesDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryServicesDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.queryServices.push(QueryServiceDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryServicesDescriptor {
+    return {
+      queryServices: globalThis.Array.isArray(object?.queryServices)
+        ? object.queryServices.map((e: any) => QueryServiceDescriptor.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: QueryServicesDescriptor): unknown {
+    const obj: any = {};
+    if (message.queryServices?.length) {
+      obj.queryServices = message.queryServices.map((e) => QueryServiceDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<QueryServicesDescriptor>, I>>(base?: I): QueryServicesDescriptor {
+    return QueryServicesDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<QueryServicesDescriptor>, I>>(object: I): QueryServicesDescriptor {
+    const message = createBaseQueryServicesDescriptor();
+    message.queryServices = object.queryServices?.map((e) => QueryServiceDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseQueryServiceDescriptor(): QueryServiceDescriptor {
+  return { fullname: "", isModule: false, methods: [] };
+}
+
+export const QueryServiceDescriptor: MessageFns<QueryServiceDescriptor> = {
+  encode(message: QueryServiceDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fullname !== "") {
+      writer.uint32(10).string(message.fullname);
+    }
+    if (message.isModule !== false) {
+      writer.uint32(16).bool(message.isModule);
+    }
+    for (const v of message.methods) {
+      QueryMethodDescriptor.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryServiceDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryServiceDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fullname = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.isModule = reader.bool();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.methods.push(QueryMethodDescriptor.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryServiceDescriptor {
+    return {
+      fullname: isSet(object.fullname) ? globalThis.String(object.fullname) : "",
+      isModule: isSet(object.isModule) ? globalThis.Boolean(object.isModule) : false,
+      methods: globalThis.Array.isArray(object?.methods)
+        ? object.methods.map((e: any) => QueryMethodDescriptor.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: QueryServiceDescriptor): unknown {
+    const obj: any = {};
+    if (message.fullname !== "") {
+      obj.fullname = message.fullname;
+    }
+    if (message.isModule !== false) {
+      obj.isModule = message.isModule;
+    }
+    if (message.methods?.length) {
+      obj.methods = message.methods.map((e) => QueryMethodDescriptor.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<QueryServiceDescriptor>, I>>(base?: I): QueryServiceDescriptor {
+    return QueryServiceDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<QueryServiceDescriptor>, I>>(object: I): QueryServiceDescriptor {
+    const message = createBaseQueryServiceDescriptor();
+    message.fullname = object.fullname ?? "";
+    message.isModule = object.isModule ?? false;
+    message.methods = object.methods?.map((e) => QueryMethodDescriptor.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseQueryMethodDescriptor(): QueryMethodDescriptor {
+  return { name: "", fullQueryPath: "" };
+}
+
+export const QueryMethodDescriptor: MessageFns<QueryMethodDescriptor> = {
+  encode(message: QueryMethodDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.fullQueryPath !== "") {
+      writer.uint32(18).string(message.fullQueryPath);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryMethodDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryMethodDescriptor();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.fullQueryPath = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryMethodDescriptor {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      fullQueryPath: isSet(object.fullQueryPath) ? globalThis.String(object.fullQueryPath) : "",
+    };
+  },
+
+  toJSON(message: QueryMethodDescriptor): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.fullQueryPath !== "") {
+      obj.fullQueryPath = message.fullQueryPath;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<QueryMethodDescriptor>, I>>(base?: I): QueryMethodDescriptor {
+    return QueryMethodDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<QueryMethodDescriptor>, I>>(object: I): QueryMethodDescriptor {
+    const message = createBaseQueryMethodDescriptor();
+    message.name = object.name ?? "";
+    message.fullQueryPath = object.fullQueryPath ?? "";
+    return message;
+  },
+};
+
+/** ReflectionService defines a service for application reflection. */
+export interface ReflectionService {
+  /**
+   * GetAuthnDescriptor returns information on how to authenticate transactions in the application
+   * NOTE: this RPC is still experimental and might be subject to breaking changes or removal in
+   * future releases of the cosmos-sdk.
+   */
+  GetAuthnDescriptor(request: GetAuthnDescriptorRequest): Promise<GetAuthnDescriptorResponse>;
+  /** GetChainDescriptor returns the description of the chain */
+  GetChainDescriptor(request: GetChainDescriptorRequest): Promise<GetChainDescriptorResponse>;
+  /** GetCodecDescriptor returns the descriptor of the codec of the application */
+  GetCodecDescriptor(request: GetCodecDescriptorRequest): Promise<GetCodecDescriptorResponse>;
+  /** GetConfigurationDescriptor returns the descriptor for the sdk.Config of the application */
+  GetConfigurationDescriptor(request: GetConfigurationDescriptorRequest): Promise<GetConfigurationDescriptorResponse>;
+  /** GetQueryServicesDescriptor returns the available gRPC queryable services of the application */
+  GetQueryServicesDescriptor(request: GetQueryServicesDescriptorRequest): Promise<GetQueryServicesDescriptorResponse>;
+  /** GetTxDescriptor returns information on the used transaction object and available msgs that can be used */
+  GetTxDescriptor(request: GetTxDescriptorRequest): Promise<GetTxDescriptorResponse>;
+}
+
+export const ReflectionServiceServiceName = "cosmos.base.reflection.v2alpha1.ReflectionService";
+export class ReflectionServiceClientImpl implements ReflectionService {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || ReflectionServiceServiceName;
+    this.rpc = rpc;
+    this.GetAuthnDescriptor = this.GetAuthnDescriptor.bind(this);
+    this.GetChainDescriptor = this.GetChainDescriptor.bind(this);
+    this.GetCodecDescriptor = this.GetCodecDescriptor.bind(this);
+    this.GetConfigurationDescriptor = this.GetConfigurationDescriptor.bind(this);
+    this.GetQueryServicesDescriptor = this.GetQueryServicesDescriptor.bind(this);
+    this.GetTxDescriptor = this.GetTxDescriptor.bind(this);
+  }
+  GetAuthnDescriptor(request: GetAuthnDescriptorRequest): Promise<GetAuthnDescriptorResponse> {
+    const data = GetAuthnDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetAuthnDescriptor", data);
+    return promise.then((data) => GetAuthnDescriptorResponse.decode(new BinaryReader(data)));
+  }
+
+  GetChainDescriptor(request: GetChainDescriptorRequest): Promise<GetChainDescriptorResponse> {
+    const data = GetChainDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetChainDescriptor", data);
+    return promise.then((data) => GetChainDescriptorResponse.decode(new BinaryReader(data)));
+  }
+
+  GetCodecDescriptor(request: GetCodecDescriptorRequest): Promise<GetCodecDescriptorResponse> {
+    const data = GetCodecDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetCodecDescriptor", data);
+    return promise.then((data) => GetCodecDescriptorResponse.decode(new BinaryReader(data)));
+  }
+
+  GetConfigurationDescriptor(request: GetConfigurationDescriptorRequest): Promise<GetConfigurationDescriptorResponse> {
+    const data = GetConfigurationDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetConfigurationDescriptor", data);
+    return promise.then((data) => GetConfigurationDescriptorResponse.decode(new BinaryReader(data)));
+  }
+
+  GetQueryServicesDescriptor(request: GetQueryServicesDescriptorRequest): Promise<GetQueryServicesDescriptorResponse> {
+    const data = GetQueryServicesDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetQueryServicesDescriptor", data);
+    return promise.then((data) => GetQueryServicesDescriptorResponse.decode(new BinaryReader(data)));
+  }
+
+  GetTxDescriptor(request: GetTxDescriptorRequest): Promise<GetTxDescriptorResponse> {
+    const data = GetTxDescriptorRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetTxDescriptor", data);
+    return promise.then((data) => GetTxDescriptorResponse.decode(new BinaryReader(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}