@xpla/xplajs 1.7.0-beta.8 → 1.7.0

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/module/v1/module.js

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

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

@@ -1,7 +1,6 @@
 import { Plan, ModuleVersion } from "./upgrade";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryCurrentPlanRequest() {
     return {};
 }
@@ -63,10 +62,9 @@ export const QueryCurrentPlanRequest = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryCurrentPlanRequest",
             value: QueryCurrentPlanRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryCurrentPlanRequest.typeUrl, QueryCurrentPlanRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryCurrentPlanRequest.aminoType, QueryCurrentPlanRequest.typeUrl);
 function createBaseQueryCurrentPlanResponse() {
     return {
         plan: undefined
@@ -141,10 +139,11 @@ export const QueryCurrentPlanResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryCurrentPlanResponse",
             value: QueryCurrentPlanResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Plan.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryCurrentPlanResponse.typeUrl, QueryCurrentPlanResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryCurrentPlanResponse.aminoType, QueryCurrentPlanResponse.typeUrl);
 function createBaseQueryAppliedPlanRequest() {
     return {
         name: ""
@@ -219,10 +218,9 @@ export const QueryAppliedPlanRequest = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryAppliedPlanRequest",
             value: QueryAppliedPlanRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAppliedPlanRequest.typeUrl, QueryAppliedPlanRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAppliedPlanRequest.aminoType, QueryAppliedPlanRequest.typeUrl);
 function createBaseQueryAppliedPlanResponse() {
     return {
         height: BigInt(0)
@@ -297,10 +295,9 @@ export const QueryAppliedPlanResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryAppliedPlanResponse",
             value: QueryAppliedPlanResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAppliedPlanResponse.typeUrl, QueryAppliedPlanResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAppliedPlanResponse.aminoType, QueryAppliedPlanResponse.typeUrl);
 function createBaseQueryUpgradedConsensusStateRequest() {
     return {
         lastHeight: BigInt(0)
@@ -375,10 +372,9 @@ export const QueryUpgradedConsensusStateRequest = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateRequest",
             value: QueryUpgradedConsensusStateRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryUpgradedConsensusStateRequest.typeUrl, QueryUpgradedConsensusStateRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryUpgradedConsensusStateRequest.aminoType, QueryUpgradedConsensusStateRequest.typeUrl);
 function createBaseQueryUpgradedConsensusStateResponse() {
     return {
         upgradedConsensusState: new Uint8Array()
@@ -453,10 +449,9 @@ export const QueryUpgradedConsensusStateResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateResponse",
             value: QueryUpgradedConsensusStateResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryUpgradedConsensusStateResponse.typeUrl, QueryUpgradedConsensusStateResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryUpgradedConsensusStateResponse.aminoType, QueryUpgradedConsensusStateResponse.typeUrl);
 function createBaseQueryModuleVersionsRequest() {
     return {
         moduleName: ""
@@ -531,10 +526,9 @@ export const QueryModuleVersionsRequest = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryModuleVersionsRequest",
             value: QueryModuleVersionsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryModuleVersionsRequest.typeUrl, QueryModuleVersionsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleVersionsRequest.aminoType, QueryModuleVersionsRequest.typeUrl);
 function createBaseQueryModuleVersionsResponse() {
     return {
         moduleVersions: []
@@ -612,10 +606,11 @@ export const QueryModuleVersionsResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryModuleVersionsResponse",
             value: QueryModuleVersionsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ModuleVersion.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryModuleVersionsResponse.typeUrl, QueryModuleVersionsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryModuleVersionsResponse.aminoType, QueryModuleVersionsResponse.typeUrl);
 function createBaseQueryAuthorityRequest() {
     return {};
 }
@@ -677,10 +672,9 @@ export const QueryAuthorityRequest = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryAuthorityRequest",
             value: QueryAuthorityRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAuthorityRequest.typeUrl, QueryAuthorityRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAuthorityRequest.aminoType, QueryAuthorityRequest.typeUrl);
 function createBaseQueryAuthorityResponse() {
     return {
         address: ""
@@ -755,7 +749,6 @@ export const QueryAuthorityResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.QueryAuthorityResponse",
             value: QueryAuthorityResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAuthorityResponse.typeUrl, QueryAuthorityResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAuthorityResponse.aminoType, QueryAuthorityResponse.typeUrl);

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

@@ -5,33 +5,38 @@ export const createGetCurrentPlan = (clientResolver) => buildQuery({
     decode: QueryCurrentPlanResponse.decode,
     service: "cosmos.upgrade.v1beta1.Query",
     method: "CurrentPlan",
-    clientResolver
+    clientResolver,
+    deps: [QueryCurrentPlanRequest, QueryCurrentPlanResponse]
 });
 export const createGetAppliedPlan = (clientResolver) => buildQuery({
     encode: QueryAppliedPlanRequest.encode,
     decode: QueryAppliedPlanResponse.decode,
     service: "cosmos.upgrade.v1beta1.Query",
     method: "AppliedPlan",
-    clientResolver
+    clientResolver,
+    deps: [QueryAppliedPlanRequest, QueryAppliedPlanResponse]
 });
 export const createGetUpgradedConsensusState = (clientResolver) => buildQuery({
     encode: QueryUpgradedConsensusStateRequest.encode,
     decode: QueryUpgradedConsensusStateResponse.decode,
     service: "cosmos.upgrade.v1beta1.Query",
     method: "UpgradedConsensusState",
-    clientResolver
+    clientResolver,
+    deps: [QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse]
 });
 export const createGetModuleVersions = (clientResolver) => buildQuery({
     encode: QueryModuleVersionsRequest.encode,
     decode: QueryModuleVersionsResponse.decode,
     service: "cosmos.upgrade.v1beta1.Query",
     method: "ModuleVersions",
-    clientResolver
+    clientResolver,
+    deps: [QueryModuleVersionsRequest, QueryModuleVersionsResponse]
 });
 export const createGetAuthority = (clientResolver) => buildQuery({
     encode: QueryAuthorityRequest.encode,
     decode: QueryAuthorityResponse.decode,
     service: "cosmos.upgrade.v1beta1.Query",
     method: "Authority",
-    clientResolver
+    clientResolver,
+    deps: [QueryAuthorityRequest, QueryAuthorityResponse]
 });

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

@@ -1,6 +1,5 @@
 import { Plan } from "./upgrade";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgSoftwareUpgrade() {
     return {
         authority: "",
@@ -87,10 +86,11 @@ export const MsgSoftwareUpgrade = {
             typeUrl: "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
             value: MsgSoftwareUpgrade.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Plan.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgSoftwareUpgrade.typeUrl, MsgSoftwareUpgrade);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSoftwareUpgrade.aminoType, MsgSoftwareUpgrade.typeUrl);
 function createBaseMsgSoftwareUpgradeResponse() {
     return {};
 }
@@ -152,10 +152,9 @@ export const MsgSoftwareUpgradeResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.MsgSoftwareUpgradeResponse",
             value: MsgSoftwareUpgradeResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgSoftwareUpgradeResponse.typeUrl, MsgSoftwareUpgradeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSoftwareUpgradeResponse.aminoType, MsgSoftwareUpgradeResponse.typeUrl);
 function createBaseMsgCancelUpgrade() {
     return {
         authority: ""
@@ -230,10 +229,9 @@ export const MsgCancelUpgrade = {
             typeUrl: "/cosmos.upgrade.v1beta1.MsgCancelUpgrade",
             value: MsgCancelUpgrade.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgCancelUpgrade.typeUrl, MsgCancelUpgrade);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgCancelUpgrade.aminoType, MsgCancelUpgrade.typeUrl);
 function createBaseMsgCancelUpgradeResponse() {
     return {};
 }
@@ -295,7 +293,6 @@ export const MsgCancelUpgradeResponse = {
             typeUrl: "/cosmos.upgrade.v1beta1.MsgCancelUpgradeResponse",
             value: MsgCancelUpgradeResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgCancelUpgradeResponse.typeUrl, MsgCancelUpgradeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgCancelUpgradeResponse.aminoType, MsgCancelUpgradeResponse.typeUrl);

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

@@ -1,2 +1,46 @@
 import { MsgSoftwareUpgrade, MsgCancelUpgrade } from "./tx";
 export const registry = [["/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade", MsgSoftwareUpgrade], ["/cosmos.upgrade.v1beta1.MsgCancelUpgrade", MsgCancelUpgrade]];
+export const MessageComposer = {
+    encoded: {
+        softwareUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
+                value: MsgSoftwareUpgrade.encode(value).finish()
+            };
+        },
+        cancelUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgCancelUpgrade",
+                value: MsgCancelUpgrade.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        softwareUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
+                value
+            };
+        },
+        cancelUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgCancelUpgrade",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        softwareUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
+                value: MsgSoftwareUpgrade.fromPartial(value)
+            };
+        },
+        cancelUpgrade(value) {
+            return {
+                typeUrl: "/cosmos.upgrade.v1beta1.MsgCancelUpgrade",
+                value: MsgCancelUpgrade.fromPartial(value)
+            };
+        }
+    }
+};

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

@@ -5,11 +5,13 @@ export const createSoftwareUpgrade = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSoftwareUpgrade.typeUrl,
     encoders: toEncoders(MsgSoftwareUpgrade),
-    converters: toConverters(MsgSoftwareUpgrade)
+    converters: toConverters(MsgSoftwareUpgrade),
+    deps: [MsgSoftwareUpgrade]
 });
 export const createCancelUpgrade = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCancelUpgrade.typeUrl,
     encoders: toEncoders(MsgCancelUpgrade),
-    converters: toConverters(MsgCancelUpgrade)
+    converters: toConverters(MsgCancelUpgrade),
+    deps: [MsgCancelUpgrade]
 });

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);

package/esm/cosmos_proto/cosmos.js

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../binary";
-import { GlobalDecoderRegistry } from "../registry";
 export var ScalarType;
 (function (ScalarType) {
     ScalarType[ScalarType["SCALAR_TYPE_UNSPECIFIED"] = 0] = "SCALAR_TYPE_UNSPECIFIED";
@@ -117,9 +116,9 @@ export const InterfaceDescriptor = {
             typeUrl: "/cosmos_proto.InterfaceDescriptor",
             value: InterfaceDescriptor.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(InterfaceDescriptor.typeUrl, InterfaceDescriptor);
 function createBaseScalarDescriptor() {
     return {
         name: "",
@@ -224,6 +223,6 @@ export const ScalarDescriptor = {
             typeUrl: "/cosmos_proto.ScalarDescriptor",
             value: ScalarDescriptor.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ScalarDescriptor.typeUrl, ScalarDescriptor);