@xpla/xplajs 1.7.0-beta.8 → 1.7.0

package/esm/cosmos/auth/v1beta1/query.js

@@ -3,8 +3,8 @@ import { Any } from "../../../google/protobuf/any";
 import { Params, BaseAccount, ModuleAccount } from "./auth";
 import { EthAccount } from "../../../ethermint/types/v1/account";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
 function createBaseQueryAccountsRequest() {
     return {
         pagination: undefined
@@ -79,10 +79,11 @@ export const QueryAccountsRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountsRequest",
             value: QueryAccountsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryAccountsRequest.typeUrl, QueryAccountsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountsRequest.aminoType, QueryAccountsRequest.typeUrl);
 function createBaseQueryAccountsResponse() {
     return {
         accounts: [],
@@ -172,10 +173,13 @@ export const QueryAccountsResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountsResponse",
             value: QueryAccountsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        BaseAccount.registerTypeUrl();
+        EthAccount.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryAccountsResponse.typeUrl, QueryAccountsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountsResponse.aminoType, QueryAccountsResponse.typeUrl);
 function createBaseQueryAccountRequest() {
     return {
         address: ""
@@ -250,10 +254,9 @@ export const QueryAccountRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountRequest",
             value: QueryAccountRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAccountRequest.typeUrl, QueryAccountRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountRequest.aminoType, QueryAccountRequest.typeUrl);
 function createBaseQueryAccountResponse() {
     return {
         account: undefined
@@ -328,10 +331,12 @@ export const QueryAccountResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountResponse",
             value: QueryAccountResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        BaseAccount.registerTypeUrl();
+        EthAccount.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryAccountResponse.typeUrl, QueryAccountResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountResponse.aminoType, QueryAccountResponse.typeUrl);
 function createBaseQueryParamsRequest() {
     return {};
 }
@@ -393,10 +398,9 @@ export const QueryParamsRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryParamsRequest",
             value: QueryParamsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsRequest.aminoType, QueryParamsRequest.typeUrl);
 function createBaseQueryParamsResponse() {
     return {
         params: Params.fromPartial({})
@@ -471,10 +475,11 @@ export const QueryParamsResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryParamsResponse",
             value: QueryParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
 function createBaseQueryModuleAccountsRequest() {
     return {};
 }
@@ -536,10 +541,9 @@ export const QueryModuleAccountsRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountsRequest",
             value: QueryModuleAccountsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryModuleAccountsRequest.typeUrl, QueryModuleAccountsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleAccountsRequest.aminoType, QueryModuleAccountsRequest.typeUrl);
 function createBaseQueryModuleAccountsResponse() {
     return {
         accounts: []
@@ -617,10 +621,11 @@ export const QueryModuleAccountsResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountsResponse",
             value: QueryModuleAccountsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ModuleAccount.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryModuleAccountsResponse.typeUrl, QueryModuleAccountsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleAccountsResponse.aminoType, QueryModuleAccountsResponse.typeUrl);
 function createBaseQueryModuleAccountByNameRequest() {
     return {
         name: ""
@@ -695,10 +700,9 @@ export const QueryModuleAccountByNameRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameRequest",
             value: QueryModuleAccountByNameRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryModuleAccountByNameRequest.typeUrl, QueryModuleAccountByNameRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleAccountByNameRequest.aminoType, QueryModuleAccountByNameRequest.typeUrl);
 function createBaseQueryModuleAccountByNameResponse() {
     return {
         account: undefined
@@ -773,10 +777,11 @@ export const QueryModuleAccountByNameResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameResponse",
             value: QueryModuleAccountByNameResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ModuleAccount.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryModuleAccountByNameResponse.typeUrl, QueryModuleAccountByNameResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleAccountByNameResponse.aminoType, QueryModuleAccountByNameResponse.typeUrl);
 function createBaseBech32PrefixRequest() {
     return {};
 }
@@ -838,10 +843,9 @@ export const Bech32PrefixRequest = {
             typeUrl: "/cosmos.auth.v1beta1.Bech32PrefixRequest",
             value: Bech32PrefixRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Bech32PrefixRequest.typeUrl, Bech32PrefixRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(Bech32PrefixRequest.aminoType, Bech32PrefixRequest.typeUrl);
 function createBaseBech32PrefixResponse() {
     return {
         bech32Prefix: ""
@@ -916,10 +920,9 @@ export const Bech32PrefixResponse = {
             typeUrl: "/cosmos.auth.v1beta1.Bech32PrefixResponse",
             value: Bech32PrefixResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Bech32PrefixResponse.typeUrl, Bech32PrefixResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(Bech32PrefixResponse.aminoType, Bech32PrefixResponse.typeUrl);
 function createBaseAddressBytesToStringRequest() {
     return {
         addressBytes: new Uint8Array()
@@ -994,10 +997,9 @@ export const AddressBytesToStringRequest = {
             typeUrl: "/cosmos.auth.v1beta1.AddressBytesToStringRequest",
             value: AddressBytesToStringRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(AddressBytesToStringRequest.typeUrl, AddressBytesToStringRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(AddressBytesToStringRequest.aminoType, AddressBytesToStringRequest.typeUrl);
 function createBaseAddressBytesToStringResponse() {
     return {
         addressString: ""
@@ -1072,10 +1074,9 @@ export const AddressBytesToStringResponse = {
             typeUrl: "/cosmos.auth.v1beta1.AddressBytesToStringResponse",
             value: AddressBytesToStringResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(AddressBytesToStringResponse.typeUrl, AddressBytesToStringResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(AddressBytesToStringResponse.aminoType, AddressBytesToStringResponse.typeUrl);
 function createBaseAddressStringToBytesRequest() {
     return {
         addressString: ""
@@ -1150,10 +1151,9 @@ export const AddressStringToBytesRequest = {
             typeUrl: "/cosmos.auth.v1beta1.AddressStringToBytesRequest",
             value: AddressStringToBytesRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(AddressStringToBytesRequest.typeUrl, AddressStringToBytesRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(AddressStringToBytesRequest.aminoType, AddressStringToBytesRequest.typeUrl);
 function createBaseAddressStringToBytesResponse() {
     return {
         addressBytes: new Uint8Array()
@@ -1228,10 +1228,9 @@ export const AddressStringToBytesResponse = {
             typeUrl: "/cosmos.auth.v1beta1.AddressStringToBytesResponse",
             value: AddressStringToBytesResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(AddressStringToBytesResponse.typeUrl, AddressStringToBytesResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(AddressStringToBytesResponse.aminoType, AddressStringToBytesResponse.typeUrl);
 function createBaseQueryAccountAddressByIDRequest() {
     return {
         id: BigInt(0),
@@ -1318,10 +1317,9 @@ export const QueryAccountAddressByIDRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountAddressByIDRequest",
             value: QueryAccountAddressByIDRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAccountAddressByIDRequest.typeUrl, QueryAccountAddressByIDRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountAddressByIDRequest.aminoType, QueryAccountAddressByIDRequest.typeUrl);
 function createBaseQueryAccountAddressByIDResponse() {
     return {
         accountAddress: ""
@@ -1396,10 +1394,9 @@ export const QueryAccountAddressByIDResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountAddressByIDResponse",
             value: QueryAccountAddressByIDResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAccountAddressByIDResponse.typeUrl, QueryAccountAddressByIDResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountAddressByIDResponse.aminoType, QueryAccountAddressByIDResponse.typeUrl);
 function createBaseQueryAccountInfoRequest() {
     return {
         address: ""
@@ -1474,10 +1471,9 @@ export const QueryAccountInfoRequest = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountInfoRequest",
             value: QueryAccountInfoRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAccountInfoRequest.typeUrl, QueryAccountInfoRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountInfoRequest.aminoType, QueryAccountInfoRequest.typeUrl);
 function createBaseQueryAccountInfoResponse() {
     return {
         info: undefined
@@ -1552,7 +1548,8 @@ export const QueryAccountInfoResponse = {
             typeUrl: "/cosmos.auth.v1beta1.QueryAccountInfoResponse",
             value: QueryAccountInfoResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        BaseAccount.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryAccountInfoResponse.typeUrl, QueryAccountInfoResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAccountInfoResponse.aminoType, QueryAccountInfoResponse.typeUrl);

package/esm/cosmos/auth/v1beta1/query.rpc.func.js

@@ -5,68 +5,78 @@ export const createGetAccounts = (clientResolver) => buildQuery({
     decode: QueryAccountsResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "Accounts",
-    clientResolver
+    clientResolver,
+    deps: [QueryAccountsRequest, QueryAccountsResponse]
 });
 export const createGetAccount = (clientResolver) => buildQuery({
     encode: QueryAccountRequest.encode,
     decode: QueryAccountResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "Account",
-    clientResolver
+    clientResolver,
+    deps: [QueryAccountRequest, QueryAccountResponse]
 });
 export const createGetAccountAddressByID = (clientResolver) => buildQuery({
     encode: QueryAccountAddressByIDRequest.encode,
     decode: QueryAccountAddressByIDResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "AccountAddressByID",
-    clientResolver
+    clientResolver,
+    deps: [QueryAccountAddressByIDRequest, QueryAccountAddressByIDResponse]
 });
 export const createGetParams = (clientResolver) => buildQuery({
     encode: QueryParamsRequest.encode,
     decode: QueryParamsResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "Params",
-    clientResolver
+    clientResolver,
+    deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetModuleAccounts = (clientResolver) => buildQuery({
     encode: QueryModuleAccountsRequest.encode,
     decode: QueryModuleAccountsResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "ModuleAccounts",
-    clientResolver
+    clientResolver,
+    deps: [QueryModuleAccountsRequest, QueryModuleAccountsResponse]
 });
 export const createGetModuleAccountByName = (clientResolver) => buildQuery({
     encode: QueryModuleAccountByNameRequest.encode,
     decode: QueryModuleAccountByNameResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "ModuleAccountByName",
-    clientResolver
+    clientResolver,
+    deps: [QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse]
 });
 export const createGetBech32Prefix = (clientResolver) => buildQuery({
     encode: Bech32PrefixRequest.encode,
     decode: Bech32PrefixResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "Bech32Prefix",
-    clientResolver
+    clientResolver,
+    deps: [Bech32PrefixRequest, Bech32PrefixResponse]
 });
 export const createGetAddressBytesToString = (clientResolver) => buildQuery({
     encode: AddressBytesToStringRequest.encode,
     decode: AddressBytesToStringResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "AddressBytesToString",
-    clientResolver
+    clientResolver,
+    deps: [AddressBytesToStringRequest, AddressBytesToStringResponse]
 });
 export const createGetAddressStringToBytes = (clientResolver) => buildQuery({
     encode: AddressStringToBytesRequest.encode,
     decode: AddressStringToBytesResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "AddressStringToBytes",
-    clientResolver
+    clientResolver,
+    deps: [AddressStringToBytesRequest, AddressStringToBytesResponse]
 });
 export const createGetAccountInfo = (clientResolver) => buildQuery({
     encode: QueryAccountInfoRequest.encode,
     decode: QueryAccountInfoResponse.decode,
     service: "cosmos.auth.v1beta1.Query",
     method: "AccountInfo",
-    clientResolver
+    clientResolver,
+    deps: [QueryAccountInfoRequest, QueryAccountInfoResponse]
 });

package/esm/cosmos/auth/v1beta1/tx.js

@@ -1,6 +1,5 @@
 import { Params } from "./auth";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgUpdateParams() {
     return {
         authority: "",
@@ -87,10 +86,11 @@ export const MsgUpdateParams = {
             typeUrl: "/cosmos.auth.v1beta1.MsgUpdateParams",
             value: MsgUpdateParams.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
 function createBaseMsgUpdateParamsResponse() {
     return {};
 }
@@ -152,7 +152,6 @@ export const MsgUpdateParamsResponse = {
             typeUrl: "/cosmos.auth.v1beta1.MsgUpdateParamsResponse",
             value: MsgUpdateParamsResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);

package/esm/cosmos/auth/v1beta1/tx.registry.js

@@ -1,2 +1,28 @@
 import { MsgUpdateParams } from "./tx";
 export const registry = [["/cosmos.auth.v1beta1.MsgUpdateParams", MsgUpdateParams]];
+export const MessageComposer = {
+    encoded: {
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.auth.v1beta1.MsgUpdateParams",
+                value: MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.auth.v1beta1.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.auth.v1beta1.MsgUpdateParams",
+                value: MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

package/esm/cosmos/auth/v1beta1/tx.rpc.func.js

@@ -5,5 +5,6 @@ export const createUpdateParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });

package/esm/cosmos/authz/module/v1/module.js

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseModule() {
     return {};
 }
@@ -61,7 +60,6 @@ export const Module = {
             typeUrl: "/cosmos.authz.module.v1.Module",
             value: Module.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/esm/cosmos/authz/v1beta1/authz.js

@@ -1,5 +1,9 @@
 import { Any } from "../../../google/protobuf/any";
 import { Timestamp } from "../../../google/protobuf/timestamp";
+import { SendAuthorization } from "../../bank/v1beta1/authz";
+import { StakeAuthorization } from "../../staking/v1beta1/authz";
+import { StoreCodeAuthorization, ContractExecutionAuthorization, ContractMigrationAuthorization } from "../../../cosmwasm/wasm/v1/authz";
+import { TransferAuthorization } from "../../../ibc/applications/transfer/v1/authz";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { toTimestamp, fromTimestamp } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
@@ -77,10 +81,12 @@ export const GenericAuthorization = {
             typeUrl: "/cosmos.authz.v1beta1.GenericAuthorization",
             value: GenericAuthorization.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GlobalDecoderRegistry.register(GenericAuthorization.typeUrl, GenericAuthorization);
+        GlobalDecoderRegistry.registerAminoProtoMapping(GenericAuthorization.aminoType, GenericAuthorization.typeUrl);
     }
 };
-GlobalDecoderRegistry.register(GenericAuthorization.typeUrl, GenericAuthorization);
-GlobalDecoderRegistry.registerAminoProtoMapping(GenericAuthorization.aminoType, GenericAuthorization.typeUrl);
 function createBaseGrant() {
     return {
         authorization: undefined,
@@ -167,10 +173,17 @@ export const Grant = {
             typeUrl: "/cosmos.authz.v1beta1.Grant",
             value: Grant.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GenericAuthorization.registerTypeUrl();
+        SendAuthorization.registerTypeUrl();
+        StakeAuthorization.registerTypeUrl();
+        StoreCodeAuthorization.registerTypeUrl();
+        ContractExecutionAuthorization.registerTypeUrl();
+        ContractMigrationAuthorization.registerTypeUrl();
+        TransferAuthorization.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Grant.typeUrl, Grant);
-GlobalDecoderRegistry.registerAminoProtoMapping(Grant.aminoType, Grant.typeUrl);
 function createBaseGrantAuthorization() {
     return {
         granter: "",
@@ -281,10 +294,17 @@ export const GrantAuthorization = {
             typeUrl: "/cosmos.authz.v1beta1.GrantAuthorization",
             value: GrantAuthorization.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GenericAuthorization.registerTypeUrl();
+        SendAuthorization.registerTypeUrl();
+        StakeAuthorization.registerTypeUrl();
+        StoreCodeAuthorization.registerTypeUrl();
+        ContractExecutionAuthorization.registerTypeUrl();
+        ContractMigrationAuthorization.registerTypeUrl();
+        TransferAuthorization.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GrantAuthorization.typeUrl, GrantAuthorization);
-GlobalDecoderRegistry.registerAminoProtoMapping(GrantAuthorization.aminoType, GrantAuthorization.typeUrl);
 function createBaseGrantQueueItem() {
     return {
         msgTypeUrls: []
@@ -362,7 +382,6 @@ export const GrantQueueItem = {
             typeUrl: "/cosmos.authz.v1beta1.GrantQueueItem",
             value: GrantQueueItem.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(GrantQueueItem.typeUrl, GrantQueueItem);
-GlobalDecoderRegistry.registerAminoProtoMapping(GrantQueueItem.aminoType, GrantQueueItem.typeUrl);

package/esm/cosmos/authz/v1beta1/event.js

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseEventGrant() {
     return {
         msgTypeUrl: "",
@@ -98,10 +97,9 @@ export const EventGrant = {
             typeUrl: "/cosmos.authz.v1beta1.EventGrant",
             value: EventGrant.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(EventGrant.typeUrl, EventGrant);
-GlobalDecoderRegistry.registerAminoProtoMapping(EventGrant.aminoType, EventGrant.typeUrl);
 function createBaseEventRevoke() {
     return {
         msgTypeUrl: "",
@@ -200,7 +198,6 @@ export const EventRevoke = {
             typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
             value: EventRevoke.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(EventRevoke.typeUrl, EventRevoke);
-GlobalDecoderRegistry.registerAminoProtoMapping(EventRevoke.aminoType, EventRevoke.typeUrl);

package/esm/cosmos/authz/v1beta1/genesis.js

@@ -1,6 +1,5 @@
 import { GrantAuthorization } from "./authz";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         authorization: []
@@ -78,7 +77,8 @@ export const GenesisState = {
             typeUrl: "/cosmos.authz.v1beta1.GenesisState",
             value: GenesisState.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GrantAuthorization.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
-GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

package/esm/cosmos/authz/v1beta1/query.js

@@ -1,7 +1,6 @@
 import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
 import { Grant, GrantAuthorization } from "./authz";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryGrantsRequest() {
     return {
         granter: "",
@@ -112,10 +111,11 @@ export const QueryGrantsRequest = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGrantsRequest",
             value: QueryGrantsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGrantsRequest.typeUrl, QueryGrantsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGrantsRequest.aminoType, QueryGrantsRequest.typeUrl);
 function createBaseQueryGrantsResponse() {
     return {
         grants: [],
@@ -205,10 +205,12 @@ export const QueryGrantsResponse = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGrantsResponse",
             value: QueryGrantsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Grant.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGrantsResponse.typeUrl, QueryGrantsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGrantsResponse.aminoType, QueryGrantsResponse.typeUrl);
 function createBaseQueryGranterGrantsRequest() {
     return {
         granter: "",
@@ -295,10 +297,11 @@ export const QueryGranterGrantsRequest = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsRequest",
             value: QueryGranterGrantsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGranterGrantsRequest.typeUrl, QueryGranterGrantsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGranterGrantsRequest.aminoType, QueryGranterGrantsRequest.typeUrl);
 function createBaseQueryGranterGrantsResponse() {
     return {
         grants: [],
@@ -388,10 +391,12 @@ export const QueryGranterGrantsResponse = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsResponse",
             value: QueryGranterGrantsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GrantAuthorization.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGranterGrantsResponse.typeUrl, QueryGranterGrantsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGranterGrantsResponse.aminoType, QueryGranterGrantsResponse.typeUrl);
 function createBaseQueryGranteeGrantsRequest() {
     return {
         grantee: "",
@@ -478,10 +483,11 @@ export const QueryGranteeGrantsRequest = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsRequest",
             value: QueryGranteeGrantsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGranteeGrantsRequest.typeUrl, QueryGranteeGrantsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGranteeGrantsRequest.aminoType, QueryGranteeGrantsRequest.typeUrl);
 function createBaseQueryGranteeGrantsResponse() {
     return {
         grants: [],
@@ -571,7 +577,9 @@ export const QueryGranteeGrantsResponse = {
             typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsResponse",
             value: QueryGranteeGrantsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GrantAuthorization.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryGranteeGrantsResponse.typeUrl, QueryGranteeGrantsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryGranteeGrantsResponse.aminoType, QueryGranteeGrantsResponse.typeUrl);