@xpla/xplajs 1.7.0-beta.1 → 1.7.0-beta.11

package/src/cosmos/authz/v1beta1/tx.registry.ts

@@ -1,3 +1,65 @@
 import { TelescopeGeneratedType } from "../../../types";
 import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
-export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.authz.v1beta1.MsgGrant", MsgGrant], ["/cosmos.authz.v1beta1.MsgExec", MsgExec], ["/cosmos.authz.v1beta1.MsgRevoke", MsgRevoke]];
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.authz.v1beta1.MsgGrant", MsgGrant], ["/cosmos.authz.v1beta1.MsgExec", MsgExec], ["/cosmos.authz.v1beta1.MsgRevoke", MsgRevoke]];
+export const MessageComposer = {
+  encoded: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value: MsgGrant.encode(value).finish()
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value: MsgExec.encode(value).finish()
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value: MsgRevoke.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value: MsgGrant.fromPartial(value)
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value: MsgExec.fromPartial(value)
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value: MsgRevoke.fromPartial(value)
+      };
+    }
+  }
+};

package/src/cosmos/authz/v1beta1/tx.rpc.func.ts

@@ -5,17 +5,20 @@ export const createGrant = (clientResolver?: SigningClientResolver) => buildTx<M
   clientResolver,
   typeUrl: MsgGrant.typeUrl,
   encoders: toEncoders(MsgGrant),
-  converters: toConverters(MsgGrant)
+  converters: toConverters(MsgGrant),
+  deps: [MsgGrant]
 });
 export const createExec = (clientResolver?: SigningClientResolver) => buildTx<MsgExec>({
   clientResolver,
   typeUrl: MsgExec.typeUrl,
   encoders: toEncoders(MsgExec),
-  converters: toConverters(MsgExec)
+  converters: toConverters(MsgExec),
+  deps: [MsgExec]
 });
 export const createRevoke = (clientResolver?: SigningClientResolver) => buildTx<MsgRevoke>({
   clientResolver,
   typeUrl: MsgRevoke.typeUrl,
   encoders: toEncoders(MsgRevoke),
-  converters: toConverters(MsgRevoke)
+  converters: toConverters(MsgRevoke),
+  deps: [MsgRevoke]
 });

package/src/cosmos/authz/v1beta1/tx.ts

@@ -1,8 +1,8 @@
 import { Grant, GrantAmino } from "./authz";
 import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
+import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
 /**
  * MsgGrant is a request type for Grant method. It declares authorization to the grantee
  * on behalf of the granter with the provided expiration time.
@@ -237,10 +237,11 @@ export const MsgGrant = {
       typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
       value: MsgGrant.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Grant.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(MsgGrant.typeUrl, MsgGrant);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgGrant.aminoType, MsgGrant.typeUrl);
 function createBaseMsgGrantResponse(): MsgGrantResponse {
   return {};
 }
@@ -302,10 +303,9 @@ export const MsgGrantResponse = {
       typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse",
       value: MsgGrantResponse.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgGrantResponse.typeUrl, MsgGrantResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgGrantResponse.aminoType, MsgGrantResponse.typeUrl);
 function createBaseMsgExec(): MsgExec {
   return {
     grantee: "",
@@ -394,10 +394,9 @@ export const MsgExec = {
       typeUrl: "/cosmos.authz.v1beta1.MsgExec",
       value: MsgExec.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgExec.typeUrl, MsgExec);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgExec.aminoType, MsgExec.typeUrl);
 function createBaseMsgExecResponse(): MsgExecResponse {
   return {
     results: []
@@ -474,10 +473,9 @@ export const MsgExecResponse = {
       typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse",
       value: MsgExecResponse.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgExecResponse.typeUrl, MsgExecResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgExecResponse.aminoType, MsgExecResponse.typeUrl);
 function createBaseMsgRevoke(): MsgRevoke {
   return {
     granter: "",
@@ -576,10 +574,9 @@ export const MsgRevoke = {
       typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
       value: MsgRevoke.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgRevoke.typeUrl, MsgRevoke);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRevoke.aminoType, MsgRevoke.typeUrl);
 function createBaseMsgRevokeResponse(): MsgRevokeResponse {
   return {};
 }
@@ -641,7 +638,6 @@ export const MsgRevokeResponse = {
       typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse",
       value: MsgRevokeResponse.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(MsgRevokeResponse.typeUrl, MsgRevokeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRevokeResponse.aminoType, MsgRevokeResponse.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/autocli/v1/options.ts

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial, isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** ModuleOptions describes the CLI options for a Cosmos SDK module. */
 export interface ModuleOptions {
   /** tx describes the tx commands for the module. */
@@ -397,10 +396,11 @@ export const ModuleOptions = {
       typeUrl: "/cosmos.autocli.v1.ModuleOptions",
       value: ModuleOptions.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    ServiceCommandDescriptor.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(ModuleOptions.typeUrl, ModuleOptions);
-GlobalDecoderRegistry.registerAminoProtoMapping(ModuleOptions.aminoType, ModuleOptions.typeUrl);
 function createBaseServiceCommandDescriptor_SubCommandsEntry(): ServiceCommandDescriptor_SubCommandsEntry {
   return {
     key: "",
@@ -467,6 +467,9 @@ export const ServiceCommandDescriptor_SubCommandsEntry = {
   },
   toProto(message: ServiceCommandDescriptor_SubCommandsEntry): Uint8Array {
     return ServiceCommandDescriptor_SubCommandsEntry.encode(message).finish();
+  },
+  registerTypeUrl() {
+    ServiceCommandDescriptor.registerTypeUrl();
   }
 };
 function createBaseServiceCommandDescriptor(): ServiceCommandDescriptor {
@@ -592,10 +595,12 @@ export const ServiceCommandDescriptor = {
       typeUrl: "/cosmos.autocli.v1.ServiceCommandDescriptor",
       value: ServiceCommandDescriptor.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    RpcCommandOptions.registerTypeUrl();
+    ServiceCommandDescriptor.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(ServiceCommandDescriptor.typeUrl, ServiceCommandDescriptor);
-GlobalDecoderRegistry.registerAminoProtoMapping(ServiceCommandDescriptor.aminoType, ServiceCommandDescriptor.typeUrl);
 function createBaseRpcCommandOptions_FlagOptionsEntry(): RpcCommandOptions_FlagOptionsEntry {
   return {
     key: "",
@@ -662,6 +667,9 @@ export const RpcCommandOptions_FlagOptionsEntry = {
   },
   toProto(message: RpcCommandOptions_FlagOptionsEntry): Uint8Array {
     return RpcCommandOptions_FlagOptionsEntry.encode(message).finish();
+  },
+  registerTypeUrl() {
+    FlagOptions.registerTypeUrl();
   }
 };
 function createBaseRpcCommandOptions(): RpcCommandOptions {
@@ -899,10 +907,12 @@ export const RpcCommandOptions = {
       typeUrl: "/cosmos.autocli.v1.RpcCommandOptions",
       value: RpcCommandOptions.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    FlagOptions.registerTypeUrl();
+    PositionalArgDescriptor.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(RpcCommandOptions.typeUrl, RpcCommandOptions);
-GlobalDecoderRegistry.registerAminoProtoMapping(RpcCommandOptions.aminoType, RpcCommandOptions.typeUrl);
 function createBaseFlagOptions(): FlagOptions {
   return {
     name: "",
@@ -1049,10 +1059,9 @@ export const FlagOptions = {
       typeUrl: "/cosmos.autocli.v1.FlagOptions",
       value: FlagOptions.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(FlagOptions.typeUrl, FlagOptions);
-GlobalDecoderRegistry.registerAminoProtoMapping(FlagOptions.aminoType, FlagOptions.typeUrl);
 function createBasePositionalArgDescriptor(): PositionalArgDescriptor {
   return {
     protoField: "",
@@ -1139,7 +1148,6 @@ export const PositionalArgDescriptor = {
       typeUrl: "/cosmos.autocli.v1.PositionalArgDescriptor",
       value: PositionalArgDescriptor.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(PositionalArgDescriptor.typeUrl, PositionalArgDescriptor);
-GlobalDecoderRegistry.registerAminoProtoMapping(PositionalArgDescriptor.aminoType, PositionalArgDescriptor.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/autocli/v1/query.rpc.func.ts

@@ -5,5 +5,6 @@ export const createGetAppOptions = (clientResolver?: RpcResolver) => buildQuery<
   decode: AppOptionsResponse.decode,
   service: "cosmos.autocli.v1.Query",
   method: "AppOptions",
-  clientResolver
+  clientResolver,
+  deps: [AppOptionsRequest, AppOptionsResponse]
 });

package/src/cosmos/autocli/v1/query.ts

@@ -1,7 +1,6 @@
 import { ModuleOptions, ModuleOptionsAmino } from "./options";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial, isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
 export interface AppOptionsRequest {}
 export interface AppOptionsRequestProtoMsg {
@@ -113,10 +112,9 @@ export const AppOptionsRequest = {
       typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
       value: AppOptionsRequest.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(AppOptionsRequest.typeUrl, AppOptionsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(AppOptionsRequest.aminoType, AppOptionsRequest.typeUrl);
 function createBaseAppOptionsResponse_ModuleOptionsEntry(): AppOptionsResponse_ModuleOptionsEntry {
   return {
     key: "",
@@ -183,6 +181,9 @@ export const AppOptionsResponse_ModuleOptionsEntry = {
   },
   toProto(message: AppOptionsResponse_ModuleOptionsEntry): Uint8Array {
     return AppOptionsResponse_ModuleOptionsEntry.encode(message).finish();
+  },
+  registerTypeUrl() {
+    ModuleOptions.registerTypeUrl();
   }
 };
 function createBaseAppOptionsResponse(): AppOptionsResponse {
@@ -282,7 +283,8 @@ export const AppOptionsResponse = {
       typeUrl: "/cosmos.autocli.v1.AppOptionsResponse",
       value: AppOptionsResponse.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    ModuleOptions.registerTypeUrl();
   }
-};
-GlobalDecoderRegistry.register(AppOptionsResponse.typeUrl, AppOptionsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(AppOptionsResponse.aminoType, AppOptionsResponse.typeUrl);
+};

package/src/cosmos/bank/module/v1/module.ts

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { DeepPartial } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 /** Module is the config object of the bank module. */
 export interface Module {
   /**
@@ -147,7 +146,6 @@ export const Module = {
       typeUrl: "/cosmos.bank.module.v1.Module",
       value: Module.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/bank/v1beta1/authz.ts

@@ -132,7 +132,10 @@ export const SendAuthorization = {
       typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
       value: SendAuthorization.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    GlobalDecoderRegistry.register(SendAuthorization.typeUrl, SendAuthorization);
+    GlobalDecoderRegistry.registerAminoProtoMapping(SendAuthorization.aminoType, SendAuthorization.typeUrl);
+    Coin.registerTypeUrl();
   }
-};
-GlobalDecoderRegistry.register(SendAuthorization.typeUrl, SendAuthorization);
-GlobalDecoderRegistry.registerAminoProtoMapping(SendAuthorization.aminoType, SendAuthorization.typeUrl);
+};

package/src/cosmos/bank/v1beta1/bank.ts

@@ -346,10 +346,11 @@ export const Params = {
       typeUrl: "/cosmos.bank.v1beta1.Params",
       value: Params.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    SendEnabled.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);
 function createBaseSendEnabled(): SendEnabled {
   return {
     denom: "",
@@ -436,10 +437,9 @@ export const SendEnabled = {
       typeUrl: "/cosmos.bank.v1beta1.SendEnabled",
       value: SendEnabled.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(SendEnabled.typeUrl, SendEnabled);
-GlobalDecoderRegistry.registerAminoProtoMapping(SendEnabled.aminoType, SendEnabled.typeUrl);
 function createBaseInput(): Input {
   return {
     address: "",
@@ -528,10 +528,11 @@ export const Input = {
       typeUrl: "/cosmos.bank.v1beta1.Input",
       value: Input.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Coin.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(Input.typeUrl, Input);
-GlobalDecoderRegistry.registerAminoProtoMapping(Input.aminoType, Input.typeUrl);
 function createBaseOutput(): Output {
   return {
     address: "",
@@ -620,10 +621,11 @@ export const Output = {
       typeUrl: "/cosmos.bank.v1beta1.Output",
       value: Output.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Coin.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(Output.typeUrl, Output);
-GlobalDecoderRegistry.registerAminoProtoMapping(Output.aminoType, Output.typeUrl);
 function createBaseSupply(): Supply {
   return {
     total: []
@@ -700,10 +702,13 @@ export const Supply = {
       typeUrl: "/cosmos.bank.v1beta1.Supply",
       value: Supply.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    GlobalDecoderRegistry.register(Supply.typeUrl, Supply);
+    GlobalDecoderRegistry.registerAminoProtoMapping(Supply.aminoType, Supply.typeUrl);
+    Coin.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(Supply.typeUrl, Supply);
-GlobalDecoderRegistry.registerAminoProtoMapping(Supply.aminoType, Supply.typeUrl);
 function createBaseDenomUnit(): DenomUnit {
   return {
     denom: "",
@@ -804,10 +809,9 @@ export const DenomUnit = {
       typeUrl: "/cosmos.bank.v1beta1.DenomUnit",
       value: DenomUnit.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(DenomUnit.typeUrl, DenomUnit);
-GlobalDecoderRegistry.registerAminoProtoMapping(DenomUnit.aminoType, DenomUnit.typeUrl);
 function createBaseMetadata(): Metadata {
   return {
     description: "",
@@ -968,7 +972,8 @@ export const Metadata = {
       typeUrl: "/cosmos.bank.v1beta1.Metadata",
       value: Metadata.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    DenomUnit.registerTypeUrl();
   }
-};
-GlobalDecoderRegistry.register(Metadata.typeUrl, Metadata);
-GlobalDecoderRegistry.registerAminoProtoMapping(Metadata.aminoType, Metadata.typeUrl);
+};

package/src/cosmos/bank/v1beta1/genesis.ts

@@ -2,7 +2,6 @@ import { Params, ParamsAmino, Metadata, MetadataAmino, SendEnabled, SendEnabledA
 import { Coin, CoinAmino } from "../../base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** GenesisState defines the bank module's genesis state. */
 export interface GenesisState {
   /** params defines all the parameters of the module. */
@@ -209,10 +208,15 @@ export const GenesisState = {
       typeUrl: "/cosmos.bank.v1beta1.GenesisState",
       value: GenesisState.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Params.registerTypeUrl();
+    Balance.registerTypeUrl();
+    Coin.registerTypeUrl();
+    Metadata.registerTypeUrl();
+    SendEnabled.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
-GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);
 function createBaseBalance(): Balance {
   return {
     address: "",
@@ -301,7 +305,8 @@ export const Balance = {
       typeUrl: "/cosmos.bank.v1beta1.Balance",
       value: Balance.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Coin.registerTypeUrl();
   }
-};
-GlobalDecoderRegistry.register(Balance.typeUrl, Balance);
-GlobalDecoderRegistry.registerAminoProtoMapping(Balance.aminoType, Balance.typeUrl);
+};

package/src/cosmos/bank/v1beta1/query.rpc.func.ts

@@ -5,89 +5,102 @@ export const createGetBalance = (clientResolver?: RpcResolver) => buildQuery<Que
   decode: QueryBalanceResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "Balance",
-  clientResolver
+  clientResolver,
+  deps: [QueryBalanceRequest, QueryBalanceResponse]
 });
 export const createGetAllBalances = (clientResolver?: RpcResolver) => buildQuery<QueryAllBalancesRequest, QueryAllBalancesResponse>({
   encode: QueryAllBalancesRequest.encode,
   decode: QueryAllBalancesResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "AllBalances",
-  clientResolver
+  clientResolver,
+  deps: [QueryAllBalancesRequest, QueryAllBalancesResponse]
 });
 export const createGetSpendableBalances = (clientResolver?: RpcResolver) => buildQuery<QuerySpendableBalancesRequest, QuerySpendableBalancesResponse>({
   encode: QuerySpendableBalancesRequest.encode,
   decode: QuerySpendableBalancesResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SpendableBalances",
-  clientResolver
+  clientResolver,
+  deps: [QuerySpendableBalancesRequest, QuerySpendableBalancesResponse]
 });
 export const createGetSpendableBalanceByDenom = (clientResolver?: RpcResolver) => buildQuery<QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse>({
   encode: QuerySpendableBalanceByDenomRequest.encode,
   decode: QuerySpendableBalanceByDenomResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SpendableBalanceByDenom",
-  clientResolver
+  clientResolver,
+  deps: [QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse]
 });
 export const createGetTotalSupply = (clientResolver?: RpcResolver) => buildQuery<QueryTotalSupplyRequest, QueryTotalSupplyResponse>({
   encode: QueryTotalSupplyRequest.encode,
   decode: QueryTotalSupplyResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "TotalSupply",
-  clientResolver
+  clientResolver,
+  deps: [QueryTotalSupplyRequest, QueryTotalSupplyResponse]
 });
 export const createGetSupplyOf = (clientResolver?: RpcResolver) => buildQuery<QuerySupplyOfRequest, QuerySupplyOfResponse>({
   encode: QuerySupplyOfRequest.encode,
   decode: QuerySupplyOfResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SupplyOf",
-  clientResolver
+  clientResolver,
+  deps: [QuerySupplyOfRequest, QuerySupplyOfResponse]
 });
 export const createGetParams = (clientResolver?: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "Params",
-  clientResolver
+  clientResolver,
+  deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetDenomMetadata = (clientResolver?: RpcResolver) => buildQuery<QueryDenomMetadataRequest, QueryDenomMetadataResponse>({
   encode: QueryDenomMetadataRequest.encode,
   decode: QueryDenomMetadataResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomMetadata",
-  clientResolver
+  clientResolver,
+  deps: [QueryDenomMetadataRequest, QueryDenomMetadataResponse]
 });
 export const createGetDenomMetadataByQueryString = (clientResolver?: RpcResolver) => buildQuery<QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse>({
   encode: QueryDenomMetadataByQueryStringRequest.encode,
   decode: QueryDenomMetadataByQueryStringResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomMetadataByQueryString",
-  clientResolver
+  clientResolver,
+  deps: [QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse]
 });
 export const createGetDenomsMetadata = (clientResolver?: RpcResolver) => buildQuery<QueryDenomsMetadataRequest, QueryDenomsMetadataResponse>({
   encode: QueryDenomsMetadataRequest.encode,
   decode: QueryDenomsMetadataResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomsMetadata",
-  clientResolver
+  clientResolver,
+  deps: [QueryDenomsMetadataRequest, QueryDenomsMetadataResponse]
 });
 export const createGetDenomOwners = (clientResolver?: RpcResolver) => buildQuery<QueryDenomOwnersRequest, QueryDenomOwnersResponse>({
   encode: QueryDenomOwnersRequest.encode,
   decode: QueryDenomOwnersResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomOwners",
-  clientResolver
+  clientResolver,
+  deps: [QueryDenomOwnersRequest, QueryDenomOwnersResponse]
 });
 export const createGetDenomOwnersByQuery = (clientResolver?: RpcResolver) => buildQuery<QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse>({
   encode: QueryDenomOwnersByQueryRequest.encode,
   decode: QueryDenomOwnersByQueryResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomOwnersByQuery",
-  clientResolver
+  clientResolver,
+  deps: [QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse]
 });
 export const createGetSendEnabled = (clientResolver?: RpcResolver) => buildQuery<QuerySendEnabledRequest, QuerySendEnabledResponse>({
   encode: QuerySendEnabledRequest.encode,
   decode: QuerySendEnabledResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SendEnabled",
-  clientResolver
+  clientResolver,
+  deps: [QuerySendEnabledRequest, QuerySendEnabledResponse]
 });