injectivejs 1.6.5 → 1.7.1

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

@@ -2,7 +2,6 @@ import { CompactBitArray } from "../../../crypto/multisig/v1beta1/multisig";
 import { Any } from "../../../../google/protobuf/any";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 /**
  * SignMode represents a signing mode with its own security guarantees.
  *
@@ -184,10 +183,11 @@ export const SignatureDescriptors = {
             typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptors",
             value: SignatureDescriptors.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptors.typeUrl, SignatureDescriptors);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptors.aminoType, SignatureDescriptors.typeUrl);
 function createBaseSignatureDescriptor() {
     return {
         publicKey: undefined,
@@ -286,10 +286,11 @@ export const SignatureDescriptor = {
             typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptor",
             value: SignatureDescriptor.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor_Data.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor.typeUrl, SignatureDescriptor);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor.aminoType, SignatureDescriptor.typeUrl);
 function createBaseSignatureDescriptor_Data() {
     return {
         single: undefined,
@@ -376,10 +377,12 @@ export const SignatureDescriptor_Data = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Data",
             value: SignatureDescriptor_Data.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor_Data_Single.registerTypeUrl();
+        SignatureDescriptor_Data_Multi.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data.typeUrl, SignatureDescriptor_Data);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data.aminoType, SignatureDescriptor_Data.typeUrl);
 function createBaseSignatureDescriptor_Data_Single() {
     return {
         mode: 0,
@@ -466,10 +469,9 @@ export const SignatureDescriptor_Data_Single = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Single",
             value: SignatureDescriptor_Data_Single.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data_Single.typeUrl, SignatureDescriptor_Data_Single);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data_Single.aminoType, SignatureDescriptor_Data_Single.typeUrl);
 function createBaseSignatureDescriptor_Data_Multi() {
     return {
         bitarray: undefined,
@@ -559,7 +561,9 @@ export const SignatureDescriptor_Data_Multi = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Multi",
             value: SignatureDescriptor_Data_Multi.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompactBitArray.registerTypeUrl();
+        SignatureDescriptor_Data.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data_Multi.typeUrl, SignatureDescriptor_Data_Multi);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data_Multi.aminoType, SignatureDescriptor_Data_Multi.typeUrl);

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

@@ -5,7 +5,6 @@ import { BlockID } from "../../../tendermint/types/types";
 import { Block } from "../../../tendermint/types/block";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** OrderBy defines the sorting order */
 export var OrderBy;
 (function (OrderBy) {
@@ -249,10 +248,11 @@ export const GetTxsEventRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxsEventRequest",
             value: GetTxsEventRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxsEventRequest.typeUrl, GetTxsEventRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxsEventRequest.aminoType, GetTxsEventRequest.typeUrl);
 function createBaseGetTxsEventResponse() {
     return {
         txs: [],
@@ -369,10 +369,13 @@ export const GetTxsEventResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxsEventResponse",
             value: GetTxsEventResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        TxResponse.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxsEventResponse.typeUrl, GetTxsEventResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxsEventResponse.aminoType, GetTxsEventResponse.typeUrl);
 function createBaseBroadcastTxRequest() {
     return {
         txBytes: new Uint8Array(),
@@ -459,10 +462,9 @@ export const BroadcastTxRequest = {
             typeUrl: "/cosmos.tx.v1beta1.BroadcastTxRequest",
             value: BroadcastTxRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(BroadcastTxRequest.typeUrl, BroadcastTxRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(BroadcastTxRequest.aminoType, BroadcastTxRequest.typeUrl);
 function createBaseBroadcastTxResponse() {
     return {
         txResponse: undefined
@@ -537,10 +539,11 @@ export const BroadcastTxResponse = {
             typeUrl: "/cosmos.tx.v1beta1.BroadcastTxResponse",
             value: BroadcastTxResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TxResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(BroadcastTxResponse.typeUrl, BroadcastTxResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(BroadcastTxResponse.aminoType, BroadcastTxResponse.typeUrl);
 function createBaseSimulateRequest() {
     return {
         tx: undefined,
@@ -627,10 +630,11 @@ export const SimulateRequest = {
             typeUrl: "/cosmos.tx.v1beta1.SimulateRequest",
             value: SimulateRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SimulateRequest.typeUrl, SimulateRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(SimulateRequest.aminoType, SimulateRequest.typeUrl);
 function createBaseSimulateResponse() {
     return {
         gasInfo: undefined,
@@ -717,10 +721,12 @@ export const SimulateResponse = {
             typeUrl: "/cosmos.tx.v1beta1.SimulateResponse",
             value: SimulateResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GasInfo.registerTypeUrl();
+        Result.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SimulateResponse.typeUrl, SimulateResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(SimulateResponse.aminoType, SimulateResponse.typeUrl);
 function createBaseGetTxRequest() {
     return {
         hash: ""
@@ -795,10 +801,9 @@ export const GetTxRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxRequest",
             value: GetTxRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(GetTxRequest.typeUrl, GetTxRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxRequest.aminoType, GetTxRequest.typeUrl);
 function createBaseGetTxResponse() {
     return {
         tx: undefined,
@@ -885,10 +890,12 @@ export const GetTxResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxResponse",
             value: GetTxResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        TxResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxResponse.typeUrl, GetTxResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxResponse.aminoType, GetTxResponse.typeUrl);
 function createBaseGetBlockWithTxsRequest() {
     return {
         height: BigInt(0),
@@ -975,10 +982,11 @@ export const GetBlockWithTxsRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetBlockWithTxsRequest",
             value: GetBlockWithTxsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetBlockWithTxsRequest.typeUrl, GetBlockWithTxsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetBlockWithTxsRequest.aminoType, GetBlockWithTxsRequest.typeUrl);
 function createBaseGetBlockWithTxsResponse() {
     return {
         txs: [],
@@ -1092,10 +1100,14 @@ export const GetBlockWithTxsResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetBlockWithTxsResponse",
             value: GetBlockWithTxsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        BlockID.registerTypeUrl();
+        Block.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetBlockWithTxsResponse.typeUrl, GetBlockWithTxsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetBlockWithTxsResponse.aminoType, GetBlockWithTxsResponse.typeUrl);
 function createBaseTxDecodeRequest() {
     return {
         txBytes: new Uint8Array()
@@ -1170,10 +1182,9 @@ export const TxDecodeRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeRequest",
             value: TxDecodeRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeRequest.typeUrl, TxDecodeRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeRequest.aminoType, TxDecodeRequest.typeUrl);
 function createBaseTxDecodeResponse() {
     return {
         tx: undefined
@@ -1248,10 +1259,11 @@ export const TxDecodeResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeResponse",
             value: TxDecodeResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(TxDecodeResponse.typeUrl, TxDecodeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeResponse.aminoType, TxDecodeResponse.typeUrl);
 function createBaseTxEncodeRequest() {
     return {
         tx: undefined
@@ -1326,10 +1338,11 @@ export const TxEncodeRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeRequest",
             value: TxEncodeRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(TxEncodeRequest.typeUrl, TxEncodeRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeRequest.aminoType, TxEncodeRequest.typeUrl);
 function createBaseTxEncodeResponse() {
     return {
         txBytes: new Uint8Array()
@@ -1404,10 +1417,9 @@ export const TxEncodeResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeResponse",
             value: TxEncodeResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeResponse.typeUrl, TxEncodeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeResponse.aminoType, TxEncodeResponse.typeUrl);
 function createBaseTxEncodeAminoRequest() {
     return {
         aminoJson: ""
@@ -1482,10 +1494,9 @@ export const TxEncodeAminoRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeAminoRequest",
             value: TxEncodeAminoRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeAminoRequest.typeUrl, TxEncodeAminoRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeAminoRequest.aminoType, TxEncodeAminoRequest.typeUrl);
 function createBaseTxEncodeAminoResponse() {
     return {
         aminoBinary: new Uint8Array()
@@ -1560,10 +1571,9 @@ export const TxEncodeAminoResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeAminoResponse",
             value: TxEncodeAminoResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeAminoResponse.typeUrl, TxEncodeAminoResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeAminoResponse.aminoType, TxEncodeAminoResponse.typeUrl);
 function createBaseTxDecodeAminoRequest() {
     return {
         aminoBinary: new Uint8Array()
@@ -1638,10 +1648,9 @@ export const TxDecodeAminoRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeAminoRequest",
             value: TxDecodeAminoRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeAminoRequest.typeUrl, TxDecodeAminoRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeAminoRequest.aminoType, TxDecodeAminoRequest.typeUrl);
 function createBaseTxDecodeAminoResponse() {
     return {
         aminoJson: ""
@@ -1716,7 +1725,6 @@ export const TxDecodeAminoResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeAminoResponse",
             value: TxDecodeAminoResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeAminoResponse.typeUrl, TxDecodeAminoResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeAminoResponse.aminoType, TxDecodeAminoResponse.typeUrl);

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

@@ -5,61 +5,70 @@ export const createGetSimulate = (clientResolver) => buildQuery({
     decode: SimulateResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "Simulate",
-    clientResolver
+    clientResolver,
+    deps: [SimulateRequest, SimulateResponse]
 });
 export const createGetGetTx = (clientResolver) => buildQuery({
     encode: GetTxRequest.encode,
     decode: GetTxResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetTx",
-    clientResolver
+    clientResolver,
+    deps: [GetTxRequest, GetTxResponse]
 });
 export const createGetBroadcastTx = (clientResolver) => buildQuery({
     encode: BroadcastTxRequest.encode,
     decode: BroadcastTxResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "BroadcastTx",
-    clientResolver
+    clientResolver,
+    deps: [BroadcastTxRequest, BroadcastTxResponse]
 });
 export const createGetGetTxsEvent = (clientResolver) => buildQuery({
     encode: GetTxsEventRequest.encode,
     decode: GetTxsEventResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetTxsEvent",
-    clientResolver
+    clientResolver,
+    deps: [GetTxsEventRequest, GetTxsEventResponse]
 });
 export const createGetGetBlockWithTxs = (clientResolver) => buildQuery({
     encode: GetBlockWithTxsRequest.encode,
     decode: GetBlockWithTxsResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetBlockWithTxs",
-    clientResolver
+    clientResolver,
+    deps: [GetBlockWithTxsRequest, GetBlockWithTxsResponse]
 });
 export const createGetTxDecode = (clientResolver) => buildQuery({
     encode: TxDecodeRequest.encode,
     decode: TxDecodeResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxDecode",
-    clientResolver
+    clientResolver,
+    deps: [TxDecodeRequest, TxDecodeResponse]
 });
 export const createGetTxEncode = (clientResolver) => buildQuery({
     encode: TxEncodeRequest.encode,
     decode: TxEncodeResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxEncode",
-    clientResolver
+    clientResolver,
+    deps: [TxEncodeRequest, TxEncodeResponse]
 });
 export const createGetTxEncodeAmino = (clientResolver) => buildQuery({
     encode: TxEncodeAminoRequest.encode,
     decode: TxEncodeAminoResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxEncodeAmino",
-    clientResolver
+    clientResolver,
+    deps: [TxEncodeAminoRequest, TxEncodeAminoResponse]
 });
 export const createGetTxDecodeAmino = (clientResolver) => buildQuery({
     encode: TxDecodeAminoRequest.encode,
     decode: TxDecodeAminoResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxDecodeAmino",
-    clientResolver
+    clientResolver,
+    deps: [TxDecodeAminoRequest, TxDecodeAminoResponse]
 });

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

@@ -3,7 +3,6 @@ import { CompactBitArray } from "../../crypto/multisig/v1beta1/multisig";
 import { Coin } from "../../base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes, isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseTx() {
     return {
         body: undefined,
@@ -105,10 +104,12 @@ export const Tx = {
             typeUrl: "/cosmos.tx.v1beta1.Tx",
             value: Tx.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TxBody.registerTypeUrl();
+        AuthInfo.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Tx.typeUrl, Tx);
-GlobalDecoderRegistry.registerAminoProtoMapping(Tx.aminoType, Tx.typeUrl);
 function createBaseTxRaw() {
     return {
         bodyBytes: new Uint8Array(),
@@ -210,10 +211,9 @@ export const TxRaw = {
             typeUrl: "/cosmos.tx.v1beta1.TxRaw",
             value: TxRaw.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxRaw.typeUrl, TxRaw);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxRaw.aminoType, TxRaw.typeUrl);
 function createBaseSignDoc() {
     return {
         bodyBytes: new Uint8Array(),
@@ -324,10 +324,9 @@ export const SignDoc = {
             typeUrl: "/cosmos.tx.v1beta1.SignDoc",
             value: SignDoc.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(SignDoc.typeUrl, SignDoc);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignDoc.aminoType, SignDoc.typeUrl);
 function createBaseSignDocDirectAux() {
     return {
         bodyBytes: new Uint8Array(),
@@ -462,10 +461,11 @@ export const SignDocDirectAux = {
             typeUrl: "/cosmos.tx.v1beta1.SignDocDirectAux",
             value: SignDocDirectAux.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tip.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignDocDirectAux.typeUrl, SignDocDirectAux);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignDocDirectAux.aminoType, SignDocDirectAux.typeUrl);
 function createBaseTxBody() {
     return {
         messages: [],
@@ -597,10 +597,9 @@ export const TxBody = {
             typeUrl: "/cosmos.tx.v1beta1.TxBody",
             value: TxBody.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxBody.typeUrl, TxBody);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxBody.aminoType, TxBody.typeUrl);
 function createBaseAuthInfo() {
     return {
         signerInfos: [],
@@ -702,10 +701,13 @@ export const AuthInfo = {
             typeUrl: "/cosmos.tx.v1beta1.AuthInfo",
             value: AuthInfo.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignerInfo.registerTypeUrl();
+        Fee.registerTypeUrl();
+        Tip.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(AuthInfo.typeUrl, AuthInfo);
-GlobalDecoderRegistry.registerAminoProtoMapping(AuthInfo.aminoType, AuthInfo.typeUrl);
 function createBaseSignerInfo() {
     return {
         publicKey: undefined,
@@ -804,10 +806,11 @@ export const SignerInfo = {
             typeUrl: "/cosmos.tx.v1beta1.SignerInfo",
             value: SignerInfo.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ModeInfo.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignerInfo.typeUrl, SignerInfo);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignerInfo.aminoType, SignerInfo.typeUrl);
 function createBaseModeInfo() {
     return {
         single: undefined,
@@ -894,10 +897,12 @@ export const ModeInfo = {
             typeUrl: "/cosmos.tx.v1beta1.ModeInfo",
             value: ModeInfo.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ModeInfo_Single.registerTypeUrl();
+        ModeInfo_Multi.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ModeInfo.typeUrl, ModeInfo);
-GlobalDecoderRegistry.registerAminoProtoMapping(ModeInfo.aminoType, ModeInfo.typeUrl);
 function createBaseModeInfo_Single() {
     return {
         mode: 0
@@ -972,10 +977,9 @@ export const ModeInfo_Single = {
             typeUrl: "/cosmos.tx.v1beta1.Single",
             value: ModeInfo_Single.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ModeInfo_Single.typeUrl, ModeInfo_Single);
-GlobalDecoderRegistry.registerAminoProtoMapping(ModeInfo_Single.aminoType, ModeInfo_Single.typeUrl);
 function createBaseModeInfo_Multi() {
     return {
         bitarray: undefined,
@@ -1065,10 +1069,12 @@ export const ModeInfo_Multi = {
             typeUrl: "/cosmos.tx.v1beta1.Multi",
             value: ModeInfo_Multi.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompactBitArray.registerTypeUrl();
+        ModeInfo.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ModeInfo_Multi.typeUrl, ModeInfo_Multi);
-GlobalDecoderRegistry.registerAminoProtoMapping(ModeInfo_Multi.aminoType, ModeInfo_Multi.typeUrl);
 function createBaseFee() {
     return {
         amount: [],
@@ -1182,10 +1188,11 @@ export const Fee = {
             typeUrl: "/cosmos.tx.v1beta1.Fee",
             value: Fee.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Fee.typeUrl, Fee);
-GlobalDecoderRegistry.registerAminoProtoMapping(Fee.aminoType, Fee.typeUrl);
 function createBaseTip() {
     return {
         amount: [],
@@ -1275,10 +1282,11 @@ export const Tip = {
             typeUrl: "/cosmos.tx.v1beta1.Tip",
             value: Tip.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Tip.typeUrl, Tip);
-GlobalDecoderRegistry.registerAminoProtoMapping(Tip.aminoType, Tip.typeUrl);
 function createBaseAuxSignerData() {
     return {
         address: "",
@@ -1389,7 +1397,8 @@ export const AuxSignerData = {
             typeUrl: "/cosmos.tx.v1beta1.AuxSignerData",
             value: AuxSignerData.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignDocDirectAux.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(AuxSignerData.typeUrl, AuxSignerData);
-GlobalDecoderRegistry.registerAminoProtoMapping(AuxSignerData.aminoType, AuxSignerData.typeUrl);

package/esm/cosmos/upgrade/v1beta1/upgrade.js

@@ -125,10 +125,9 @@ export const Plan = {
             typeUrl: "/cosmos.upgrade.v1beta1.Plan",
             value: Plan.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Plan.typeUrl, Plan);
-GlobalDecoderRegistry.registerAminoProtoMapping(Plan.aminoType, Plan.typeUrl);
 function createBaseSoftwareUpgradeProposal() {
     return {
         title: "",
@@ -227,10 +226,13 @@ export const SoftwareUpgradeProposal = {
             typeUrl: "/cosmos.upgrade.v1beta1.SoftwareUpgradeProposal",
             value: SoftwareUpgradeProposal.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GlobalDecoderRegistry.register(SoftwareUpgradeProposal.typeUrl, SoftwareUpgradeProposal);
+        GlobalDecoderRegistry.registerAminoProtoMapping(SoftwareUpgradeProposal.aminoType, SoftwareUpgradeProposal.typeUrl);
+        Plan.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SoftwareUpgradeProposal.typeUrl, SoftwareUpgradeProposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(SoftwareUpgradeProposal.aminoType, SoftwareUpgradeProposal.typeUrl);
 function createBaseCancelSoftwareUpgradeProposal() {
     return {
         title: "",
@@ -317,10 +319,12 @@ export const CancelSoftwareUpgradeProposal = {
             typeUrl: "/cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal",
             value: CancelSoftwareUpgradeProposal.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GlobalDecoderRegistry.register(CancelSoftwareUpgradeProposal.typeUrl, CancelSoftwareUpgradeProposal);
+        GlobalDecoderRegistry.registerAminoProtoMapping(CancelSoftwareUpgradeProposal.aminoType, CancelSoftwareUpgradeProposal.typeUrl);
     }
 };
-GlobalDecoderRegistry.register(CancelSoftwareUpgradeProposal.typeUrl, CancelSoftwareUpgradeProposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(CancelSoftwareUpgradeProposal.aminoType, CancelSoftwareUpgradeProposal.typeUrl);
 function createBaseModuleVersion() {
     return {
         name: "",
@@ -407,7 +411,6 @@ export const ModuleVersion = {
             typeUrl: "/cosmos.upgrade.v1beta1.ModuleVersion",
             value: ModuleVersion.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ModuleVersion.typeUrl, ModuleVersion);
-GlobalDecoderRegistry.registerAminoProtoMapping(ModuleVersion.aminoType, ModuleVersion.typeUrl);