injectivejs 1.6.5 → 1.7.1

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

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

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

@@ -1,7 +1,6 @@
 import { Coin } from "../../base/v1beta1/coin";
 import { Input, Output, Params, SendEnabled } from "./bank";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgSend() {
     return {
         fromAddress: "",
@@ -103,10 +102,11 @@ export const MsgSend = {
             typeUrl: "/cosmos.bank.v1beta1.MsgSend",
             value: MsgSend.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgSend.typeUrl, MsgSend);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSend.aminoType, MsgSend.typeUrl);
 function createBaseMsgSendResponse() {
     return {};
 }
@@ -168,10 +168,9 @@ export const MsgSendResponse = {
             typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse",
             value: MsgSendResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgSendResponse.typeUrl, MsgSendResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSendResponse.aminoType, MsgSendResponse.typeUrl);
 function createBaseMsgMultiSend() {
     return {
         inputs: [],
@@ -264,10 +263,12 @@ export const MsgMultiSend = {
             typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
             value: MsgMultiSend.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Input.registerTypeUrl();
+        Output.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgMultiSend.typeUrl, MsgMultiSend);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgMultiSend.aminoType, MsgMultiSend.typeUrl);
 function createBaseMsgMultiSendResponse() {
     return {};
 }
@@ -329,10 +330,9 @@ export const MsgMultiSendResponse = {
             typeUrl: "/cosmos.bank.v1beta1.MsgMultiSendResponse",
             value: MsgMultiSendResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgMultiSendResponse.typeUrl, MsgMultiSendResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgMultiSendResponse.aminoType, MsgMultiSendResponse.typeUrl);
 function createBaseMsgUpdateParams() {
     return {
         authority: "",
@@ -419,10 +419,11 @@ export const MsgUpdateParams = {
             typeUrl: "/cosmos.bank.v1beta1.MsgUpdateParams",
             value: MsgUpdateParams.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
 function createBaseMsgUpdateParamsResponse() {
     return {};
 }
@@ -484,10 +485,9 @@ export const MsgUpdateParamsResponse = {
             typeUrl: "/cosmos.bank.v1beta1.MsgUpdateParamsResponse",
             value: MsgUpdateParamsResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);
 function createBaseMsgSetSendEnabled() {
     return {
         authority: "",
@@ -592,10 +592,11 @@ export const MsgSetSendEnabled = {
             typeUrl: "/cosmos.bank.v1beta1.MsgSetSendEnabled",
             value: MsgSetSendEnabled.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SendEnabled.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgSetSendEnabled.typeUrl, MsgSetSendEnabled);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetSendEnabled.aminoType, MsgSetSendEnabled.typeUrl);
 function createBaseMsgSetSendEnabledResponse() {
     return {};
 }
@@ -657,7 +658,6 @@ export const MsgSetSendEnabledResponse = {
             typeUrl: "/cosmos.bank.v1beta1.MsgSetSendEnabledResponse",
             value: MsgSetSendEnabledResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgSetSendEnabledResponse.typeUrl, MsgSetSendEnabledResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetSendEnabledResponse.aminoType, MsgSetSendEnabledResponse.typeUrl);

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

@@ -5,23 +5,27 @@ export const createSend = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSend.typeUrl,
     encoders: toEncoders(MsgSend),
-    converters: toConverters(MsgSend)
+    converters: toConverters(MsgSend),
+    deps: [MsgSend]
 });
 export const createMultiSend = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgMultiSend.typeUrl,
     encoders: toEncoders(MsgMultiSend),
-    converters: toConverters(MsgMultiSend)
+    converters: toConverters(MsgMultiSend),
+    deps: [MsgMultiSend]
 });
 export const createUpdateParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });
 export const createSetSendEnabled = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSetSendEnabled.typeUrl,
     encoders: toEncoders(MsgSetSendEnabled),
-    converters: toConverters(MsgSetSendEnabled)
+    converters: toConverters(MsgSetSendEnabled),
+    deps: [MsgSetSendEnabled]
 });

package/esm/cosmos/base/abci/v1beta1/abci.js

@@ -3,7 +3,6 @@ import { Event } from "../../../../tendermint/abci/types";
 import { Block } from "../../../../tendermint/types/block";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseTxResponse() {
     return {
         height: BigInt(0),
@@ -228,10 +227,11 @@ export const TxResponse = {
             typeUrl: "/cosmos.base.abci.v1beta1.TxResponse",
             value: TxResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Event.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(TxResponse.typeUrl, TxResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxResponse.aminoType, TxResponse.typeUrl);
 function createBaseABCIMessageLog() {
     return {
         msgIndex: 0,
@@ -333,10 +333,11 @@ export const ABCIMessageLog = {
             typeUrl: "/cosmos.base.abci.v1beta1.ABCIMessageLog",
             value: ABCIMessageLog.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        StringEvent.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ABCIMessageLog.typeUrl, ABCIMessageLog);
-GlobalDecoderRegistry.registerAminoProtoMapping(ABCIMessageLog.aminoType, ABCIMessageLog.typeUrl);
 function createBaseStringEvent() {
     return {
         type: "",
@@ -426,10 +427,11 @@ export const StringEvent = {
             typeUrl: "/cosmos.base.abci.v1beta1.StringEvent",
             value: StringEvent.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Attribute.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(StringEvent.typeUrl, StringEvent);
-GlobalDecoderRegistry.registerAminoProtoMapping(StringEvent.aminoType, StringEvent.typeUrl);
 function createBaseAttribute() {
     return {
         key: "",
@@ -516,10 +518,9 @@ export const Attribute = {
             typeUrl: "/cosmos.base.abci.v1beta1.Attribute",
             value: Attribute.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Attribute.typeUrl, Attribute);
-GlobalDecoderRegistry.registerAminoProtoMapping(Attribute.aminoType, Attribute.typeUrl);
 function createBaseGasInfo() {
     return {
         gasWanted: BigInt(0),
@@ -606,10 +607,9 @@ export const GasInfo = {
             typeUrl: "/cosmos.base.abci.v1beta1.GasInfo",
             value: GasInfo.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(GasInfo.typeUrl, GasInfo);
-GlobalDecoderRegistry.registerAminoProtoMapping(GasInfo.aminoType, GasInfo.typeUrl);
 function createBaseResult() {
     return {
         data: new Uint8Array(),
@@ -726,10 +726,9 @@ export const Result = {
             typeUrl: "/cosmos.base.abci.v1beta1.Result",
             value: Result.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Result.typeUrl, Result);
-GlobalDecoderRegistry.registerAminoProtoMapping(Result.aminoType, Result.typeUrl);
 function createBaseSimulationResponse() {
     return {
         gasInfo: GasInfo.fromPartial({}),
@@ -816,10 +815,12 @@ export const SimulationResponse = {
             typeUrl: "/cosmos.base.abci.v1beta1.SimulationResponse",
             value: SimulationResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GasInfo.registerTypeUrl();
+        Result.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SimulationResponse.typeUrl, SimulationResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(SimulationResponse.aminoType, SimulationResponse.typeUrl);
 function createBaseMsgData() {
     return {
         msgType: "",
@@ -906,10 +907,9 @@ export const MsgData = {
             typeUrl: "/cosmos.base.abci.v1beta1.MsgData",
             value: MsgData.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgData.typeUrl, MsgData);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgData.aminoType, MsgData.typeUrl);
 function createBaseTxMsgData() {
     return {
         data: [],
@@ -1002,10 +1002,9 @@ export const TxMsgData = {
             typeUrl: "/cosmos.base.abci.v1beta1.TxMsgData",
             value: TxMsgData.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxMsgData.typeUrl, TxMsgData);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxMsgData.aminoType, TxMsgData.typeUrl);
 function createBaseSearchTxsResult() {
     return {
         totalCount: BigInt(0),
@@ -1143,10 +1142,11 @@ export const SearchTxsResult = {
             typeUrl: "/cosmos.base.abci.v1beta1.SearchTxsResult",
             value: SearchTxsResult.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TxResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SearchTxsResult.typeUrl, SearchTxsResult);
-GlobalDecoderRegistry.registerAminoProtoMapping(SearchTxsResult.aminoType, SearchTxsResult.typeUrl);
 function createBaseSearchBlocksResult() {
     return {
         totalCount: BigInt(0),
@@ -1284,7 +1284,8 @@ export const SearchBlocksResult = {
             typeUrl: "/cosmos.base.abci.v1beta1.SearchBlocksResult",
             value: SearchBlocksResult.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Block.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SearchBlocksResult.typeUrl, SearchBlocksResult);
-GlobalDecoderRegistry.registerAminoProtoMapping(SearchBlocksResult.aminoType, SearchBlocksResult.typeUrl);

package/esm/cosmos/base/query/v1beta1/pagination.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBasePageRequest() {
     return {
         key: new Uint8Array(),
@@ -123,10 +122,9 @@ export const PageRequest = {
             typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
             value: PageRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PageRequest.typeUrl, PageRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(PageRequest.aminoType, PageRequest.typeUrl);
 function createBasePageResponse() {
     return {
         nextKey: new Uint8Array(),
@@ -213,7 +211,6 @@ export const PageResponse = {
             typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
             value: PageResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PageResponse.typeUrl, PageResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(PageResponse.aminoType, PageResponse.typeUrl);

package/esm/cosmos/base/v1beta1/coin.js

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseCoin() {
     return {
         denom: "",
@@ -86,10 +85,9 @@ export const Coin = {
             typeUrl: "/cosmos.base.v1beta1.Coin",
             value: Coin.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Coin.typeUrl, Coin);
-GlobalDecoderRegistry.registerAminoProtoMapping(Coin.aminoType, Coin.typeUrl);
 function createBaseDecCoin() {
     return {
         denom: "",
@@ -176,10 +174,9 @@ export const DecCoin = {
             typeUrl: "/cosmos.base.v1beta1.DecCoin",
             value: DecCoin.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(DecCoin.typeUrl, DecCoin);
-GlobalDecoderRegistry.registerAminoProtoMapping(DecCoin.aminoType, DecCoin.typeUrl);
 function createBaseIntProto() {
     return {
         int: ""
@@ -254,10 +251,9 @@ export const IntProto = {
             typeUrl: "/cosmos.base.v1beta1.IntProto",
             value: IntProto.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(IntProto.typeUrl, IntProto);
-GlobalDecoderRegistry.registerAminoProtoMapping(IntProto.aminoType, IntProto.typeUrl);
 function createBaseDecProto() {
     return {
         dec: ""
@@ -332,7 +328,6 @@ export const DecProto = {
             typeUrl: "/cosmos.base.v1beta1.DecProto",
             value: DecProto.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(DecProto.typeUrl, DecProto);
-GlobalDecoderRegistry.registerAminoProtoMapping(DecProto.aminoType, DecProto.typeUrl);

package/esm/cosmos/crypto/ed25519/keys.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBasePubKey() {
     return {
         key: new Uint8Array()
@@ -75,10 +74,9 @@ export const PubKey = {
             typeUrl: "/cosmos.crypto.ed25519.PubKey",
             value: PubKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PubKey.typeUrl, PubKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PubKey.aminoType, PubKey.typeUrl);
 function createBasePrivKey() {
     return {
         key: new Uint8Array()
@@ -153,7 +151,6 @@ export const PrivKey = {
             typeUrl: "/cosmos.crypto.ed25519.PrivKey",
             value: PrivKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PrivKey.typeUrl, PrivKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PrivKey.aminoType, PrivKey.typeUrl);

package/esm/cosmos/crypto/multisig/v1beta1/multisig.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseMultiSignature() {
     return {
         signatures: []
@@ -78,10 +77,9 @@ export const MultiSignature = {
             typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
             value: MultiSignature.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MultiSignature.typeUrl, MultiSignature);
-GlobalDecoderRegistry.registerAminoProtoMapping(MultiSignature.aminoType, MultiSignature.typeUrl);
 function createBaseCompactBitArray() {
     return {
         extraBitsStored: 0,
@@ -168,7 +166,6 @@ export const CompactBitArray = {
             typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
             value: CompactBitArray.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(CompactBitArray.typeUrl, CompactBitArray);
-GlobalDecoderRegistry.registerAminoProtoMapping(CompactBitArray.aminoType, CompactBitArray.typeUrl);

package/esm/cosmos/crypto/secp256k1/keys.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBasePubKey() {
     return {
         key: new Uint8Array()
@@ -75,10 +74,9 @@ export const PubKey = {
             typeUrl: "/cosmos.crypto.secp256k1.PubKey",
             value: PubKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PubKey.typeUrl, PubKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PubKey.aminoType, PubKey.typeUrl);
 function createBasePrivKey() {
     return {
         key: new Uint8Array()
@@ -153,7 +151,6 @@ export const PrivKey = {
             typeUrl: "/cosmos.crypto.secp256k1.PrivKey",
             value: PrivKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PrivKey.typeUrl, PrivKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PrivKey.aminoType, PrivKey.typeUrl);

package/esm/cosmos/crypto/secp256r1/keys.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBasePubKey() {
     return {
         key: new Uint8Array()
@@ -75,10 +74,9 @@ export const PubKey = {
             typeUrl: "/cosmos.crypto.secp256r1.PubKey",
             value: PubKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PubKey.typeUrl, PubKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PubKey.aminoType, PubKey.typeUrl);
 function createBasePrivKey() {
     return {
         secret: new Uint8Array()
@@ -153,7 +151,6 @@ export const PrivKey = {
             typeUrl: "/cosmos.crypto.secp256r1.PrivKey",
             value: PrivKey.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(PrivKey.typeUrl, PrivKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PrivKey.aminoType, PrivKey.typeUrl);