@xpla/xplajs 1.7.0-beta.8 → 1.7.0

package/esm/cosmos/ics23/v1/proofs.js

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes, isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 export var HashOp;
 (function (HashOp) {
     /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
@@ -285,10 +284,12 @@ export const ExistenceProof = {
             typeUrl: "/cosmos.ics23.v1.ExistenceProof",
             value: ExistenceProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        LeafOp.registerTypeUrl();
+        InnerOp.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ExistenceProof.typeUrl, ExistenceProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(ExistenceProof.aminoType, ExistenceProof.typeUrl);
 function createBaseNonExistenceProof() {
     return {
         key: new Uint8Array(),
@@ -387,10 +388,11 @@ export const NonExistenceProof = {
             typeUrl: "/cosmos.ics23.v1.NonExistenceProof",
             value: NonExistenceProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ExistenceProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(NonExistenceProof.typeUrl, NonExistenceProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(NonExistenceProof.aminoType, NonExistenceProof.typeUrl);
 function createBaseCommitmentProof() {
     return {
         exist: undefined,
@@ -501,10 +503,14 @@ export const CommitmentProof = {
             typeUrl: "/cosmos.ics23.v1.CommitmentProof",
             value: CommitmentProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ExistenceProof.registerTypeUrl();
+        NonExistenceProof.registerTypeUrl();
+        BatchProof.registerTypeUrl();
+        CompressedBatchProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(CommitmentProof.typeUrl, CommitmentProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(CommitmentProof.aminoType, CommitmentProof.typeUrl);
 function createBaseLeafOp() {
     return {
         hash: 0,
@@ -627,10 +633,9 @@ export const LeafOp = {
             typeUrl: "/cosmos.ics23.v1.LeafOp",
             value: LeafOp.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(LeafOp.typeUrl, LeafOp);
-GlobalDecoderRegistry.registerAminoProtoMapping(LeafOp.aminoType, LeafOp.typeUrl);
 function createBaseInnerOp() {
     return {
         hash: 0,
@@ -729,10 +734,9 @@ export const InnerOp = {
             typeUrl: "/cosmos.ics23.v1.InnerOp",
             value: InnerOp.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(InnerOp.typeUrl, InnerOp);
-GlobalDecoderRegistry.registerAminoProtoMapping(InnerOp.aminoType, InnerOp.typeUrl);
 function createBaseProofSpec() {
     return {
         leafSpec: undefined,
@@ -855,10 +859,12 @@ export const ProofSpec = {
             typeUrl: "/cosmos.ics23.v1.ProofSpec",
             value: ProofSpec.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        LeafOp.registerTypeUrl();
+        InnerSpec.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ProofSpec.typeUrl, ProofSpec);
-GlobalDecoderRegistry.registerAminoProtoMapping(ProofSpec.aminoType, ProofSpec.typeUrl);
 function createBaseInnerSpec() {
     return {
         childOrder: [],
@@ -1006,10 +1012,9 @@ export const InnerSpec = {
             typeUrl: "/cosmos.ics23.v1.InnerSpec",
             value: InnerSpec.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(InnerSpec.typeUrl, InnerSpec);
-GlobalDecoderRegistry.registerAminoProtoMapping(InnerSpec.aminoType, InnerSpec.typeUrl);
 function createBaseBatchProof() {
     return {
         entries: []
@@ -1087,10 +1092,11 @@ export const BatchProof = {
             typeUrl: "/cosmos.ics23.v1.BatchProof",
             value: BatchProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        BatchEntry.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(BatchProof.typeUrl, BatchProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(BatchProof.aminoType, BatchProof.typeUrl);
 function createBaseBatchEntry() {
     return {
         exist: undefined,
@@ -1177,10 +1183,12 @@ export const BatchEntry = {
             typeUrl: "/cosmos.ics23.v1.BatchEntry",
             value: BatchEntry.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ExistenceProof.registerTypeUrl();
+        NonExistenceProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(BatchEntry.typeUrl, BatchEntry);
-GlobalDecoderRegistry.registerAminoProtoMapping(BatchEntry.aminoType, BatchEntry.typeUrl);
 function createBaseCompressedBatchProof() {
     return {
         entries: [],
@@ -1273,10 +1281,12 @@ export const CompressedBatchProof = {
             typeUrl: "/cosmos.ics23.v1.CompressedBatchProof",
             value: CompressedBatchProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompressedBatchEntry.registerTypeUrl();
+        InnerOp.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(CompressedBatchProof.typeUrl, CompressedBatchProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(CompressedBatchProof.aminoType, CompressedBatchProof.typeUrl);
 function createBaseCompressedBatchEntry() {
     return {
         exist: undefined,
@@ -1363,10 +1373,12 @@ export const CompressedBatchEntry = {
             typeUrl: "/cosmos.ics23.v1.CompressedBatchEntry",
             value: CompressedBatchEntry.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompressedExistenceProof.registerTypeUrl();
+        CompressedNonExistenceProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(CompressedBatchEntry.typeUrl, CompressedBatchEntry);
-GlobalDecoderRegistry.registerAminoProtoMapping(CompressedBatchEntry.aminoType, CompressedBatchEntry.typeUrl);
 function createBaseCompressedExistenceProof() {
     return {
         key: new Uint8Array(),
@@ -1490,10 +1502,11 @@ export const CompressedExistenceProof = {
             typeUrl: "/cosmos.ics23.v1.CompressedExistenceProof",
             value: CompressedExistenceProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        LeafOp.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(CompressedExistenceProof.typeUrl, CompressedExistenceProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(CompressedExistenceProof.aminoType, CompressedExistenceProof.typeUrl);
 function createBaseCompressedNonExistenceProof() {
     return {
         key: new Uint8Array(),
@@ -1592,7 +1605,8 @@ export const CompressedNonExistenceProof = {
             typeUrl: "/cosmos.ics23.v1.CompressedNonExistenceProof",
             value: CompressedNonExistenceProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompressedExistenceProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(CompressedNonExistenceProof.typeUrl, CompressedNonExistenceProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(CompressedNonExistenceProof.aminoType, CompressedNonExistenceProof.typeUrl);

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

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

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

@@ -1,6 +1,5 @@
 import { Minter, Params } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         minter: Minter.fromPartial({}),
@@ -87,7 +86,9 @@ export const GenesisState = {
             typeUrl: "/cosmos.mint.v1beta1.GenesisState",
             value: GenesisState.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Minter.registerTypeUrl();
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
-GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

package/esm/cosmos/mint/v1beta1/mint.js

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
+import { Decimal } from "@interchainjs/math";
 function createBaseMinter() {
     return {
         inflation: "",
@@ -17,10 +17,10 @@ export const Minter = {
     },
     encode(message, writer = BinaryWriter.create()) {
         if (message.inflation !== "") {
-            writer.uint32(10).string(message.inflation);
+            writer.uint32(10).string(Decimal.fromUserInput(message.inflation, 18).atomics);
         }
         if (message.annualProvisions !== "") {
-            writer.uint32(18).string(message.annualProvisions);
+            writer.uint32(18).string(Decimal.fromUserInput(message.annualProvisions, 18).atomics);
         }
         return writer;
     },
@@ -32,10 +32,10 @@ export const Minter = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.inflation = reader.string();
+                    message.inflation = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 2:
-                    message.annualProvisions = reader.string();
+                    message.annualProvisions = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -62,8 +62,8 @@ export const Minter = {
     },
     toAmino(message) {
         const obj = {};
-        obj.inflation = message.inflation === "" ? undefined : message.inflation;
-        obj.annual_provisions = message.annualProvisions === "" ? undefined : message.annualProvisions;
+        obj.inflation = message.inflation === "" ? undefined : Decimal.fromUserInput(message.inflation, 18).atomics;
+        obj.annual_provisions = message.annualProvisions === "" ? undefined : Decimal.fromUserInput(message.annualProvisions, 18).atomics;
         return obj;
     },
     fromAminoMsg(object) {
@@ -86,10 +86,9 @@ export const Minter = {
             typeUrl: "/cosmos.mint.v1beta1.Minter",
             value: Minter.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Minter.typeUrl, Minter);
-GlobalDecoderRegistry.registerAminoProtoMapping(Minter.aminoType, Minter.typeUrl);
 function createBaseParams() {
     return {
         mintDenom: "",
@@ -114,16 +113,16 @@ export const Params = {
             writer.uint32(10).string(message.mintDenom);
         }
         if (message.inflationRateChange !== "") {
-            writer.uint32(18).string(message.inflationRateChange);
+            writer.uint32(18).string(Decimal.fromUserInput(message.inflationRateChange, 18).atomics);
         }
         if (message.inflationMax !== "") {
-            writer.uint32(26).string(message.inflationMax);
+            writer.uint32(26).string(Decimal.fromUserInput(message.inflationMax, 18).atomics);
         }
         if (message.inflationMin !== "") {
-            writer.uint32(34).string(message.inflationMin);
+            writer.uint32(34).string(Decimal.fromUserInput(message.inflationMin, 18).atomics);
         }
         if (message.goalBonded !== "") {
-            writer.uint32(42).string(message.goalBonded);
+            writer.uint32(42).string(Decimal.fromUserInput(message.goalBonded, 18).atomics);
         }
         if (message.blocksPerYear !== BigInt(0)) {
             writer.uint32(48).uint64(message.blocksPerYear);
@@ -141,16 +140,16 @@ export const Params = {
                     message.mintDenom = reader.string();
                     break;
                 case 2:
-                    message.inflationRateChange = reader.string();
+                    message.inflationRateChange = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 3:
-                    message.inflationMax = reader.string();
+                    message.inflationMax = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 4:
-                    message.inflationMin = reader.string();
+                    message.inflationMin = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 5:
-                    message.goalBonded = reader.string();
+                    message.goalBonded = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 6:
                     message.blocksPerYear = reader.uint64();
@@ -197,10 +196,10 @@ export const Params = {
     toAmino(message) {
         const obj = {};
         obj.mint_denom = message.mintDenom === "" ? undefined : message.mintDenom;
-        obj.inflation_rate_change = message.inflationRateChange ?? "";
-        obj.inflation_max = message.inflationMax ?? "";
-        obj.inflation_min = message.inflationMin ?? "";
-        obj.goal_bonded = message.goalBonded ?? "";
+        obj.inflation_rate_change = Decimal.fromUserInput(message.inflationRateChange, 18).atomics ?? "";
+        obj.inflation_max = Decimal.fromUserInput(message.inflationMax, 18).atomics ?? "";
+        obj.inflation_min = Decimal.fromUserInput(message.inflationMin, 18).atomics ?? "";
+        obj.goal_bonded = Decimal.fromUserInput(message.goalBonded, 18).atomics ?? "";
         obj.blocks_per_year = message.blocksPerYear !== BigInt(0) ? message.blocksPerYear?.toString() : undefined;
         return obj;
     },
@@ -224,7 +223,6 @@ export const Params = {
             typeUrl: "/cosmos.mint.v1beta1.Params",
             value: Params.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

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

@@ -1,7 +1,6 @@
 import { Params } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryParamsRequest() {
     return {};
 }
@@ -63,10 +62,9 @@ export const QueryParamsRequest = {
             typeUrl: "/cosmos.mint.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({})
@@ -141,10 +139,11 @@ export const QueryParamsResponse = {
             typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
             value: QueryParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
 function createBaseQueryInflationRequest() {
     return {};
 }
@@ -206,10 +205,9 @@ export const QueryInflationRequest = {
             typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
             value: QueryInflationRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryInflationRequest.typeUrl, QueryInflationRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryInflationRequest.aminoType, QueryInflationRequest.typeUrl);
 function createBaseQueryInflationResponse() {
     return {
         inflation: new Uint8Array()
@@ -284,10 +282,9 @@ export const QueryInflationResponse = {
             typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
             value: QueryInflationResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryInflationResponse.typeUrl, QueryInflationResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryInflationResponse.aminoType, QueryInflationResponse.typeUrl);
 function createBaseQueryAnnualProvisionsRequest() {
     return {};
 }
@@ -349,10 +346,9 @@ export const QueryAnnualProvisionsRequest = {
             typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
             value: QueryAnnualProvisionsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAnnualProvisionsRequest.typeUrl, QueryAnnualProvisionsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAnnualProvisionsRequest.aminoType, QueryAnnualProvisionsRequest.typeUrl);
 function createBaseQueryAnnualProvisionsResponse() {
     return {
         annualProvisions: new Uint8Array()
@@ -427,7 +423,6 @@ export const QueryAnnualProvisionsResponse = {
             typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
             value: QueryAnnualProvisionsResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryAnnualProvisionsResponse.typeUrl, QueryAnnualProvisionsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAnnualProvisionsResponse.aminoType, QueryAnnualProvisionsResponse.typeUrl);

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

@@ -5,19 +5,22 @@ export const createGetParams = (clientResolver) => buildQuery({
     decode: QueryParamsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Params",
-    clientResolver
+    clientResolver,
+    deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetInflation = (clientResolver) => buildQuery({
     encode: QueryInflationRequest.encode,
     decode: QueryInflationResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Inflation",
-    clientResolver
+    clientResolver,
+    deps: [QueryInflationRequest, QueryInflationResponse]
 });
 export const createGetAnnualProvisions = (clientResolver) => buildQuery({
     encode: QueryAnnualProvisionsRequest.encode,
     decode: QueryAnnualProvisionsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "AnnualProvisions",
-    clientResolver
+    clientResolver,
+    deps: [QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse]
 });

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

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

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

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

package/esm/cosmos/mint/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/params/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.params.module.v1.Module",
             value: Module.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/esm/cosmos/params/v1beta1/params.js

@@ -101,10 +101,13 @@ export const ParameterChangeProposal = {
             typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
             value: ParameterChangeProposal.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GlobalDecoderRegistry.register(ParameterChangeProposal.typeUrl, ParameterChangeProposal);
+        GlobalDecoderRegistry.registerAminoProtoMapping(ParameterChangeProposal.aminoType, ParameterChangeProposal.typeUrl);
+        ParamChange.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ParameterChangeProposal.typeUrl, ParameterChangeProposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(ParameterChangeProposal.aminoType, ParameterChangeProposal.typeUrl);
 function createBaseParamChange() {
     return {
         subspace: "",
@@ -203,7 +206,6 @@ export const ParamChange = {
             typeUrl: "/cosmos.params.v1beta1.ParamChange",
             value: ParamChange.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ParamChange.typeUrl, ParamChange);
-GlobalDecoderRegistry.registerAminoProtoMapping(ParamChange.aminoType, ParamChange.typeUrl);

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

@@ -1,6 +1,5 @@
 import { ParamChange } from "./params";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryParamsRequest() {
     return {
         subspace: "",
@@ -87,10 +86,9 @@ export const QueryParamsRequest = {
             typeUrl: "/cosmos.params.v1beta1.QueryParamsRequest",
             value: QueryParamsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsRequest.aminoType, QueryParamsRequest.typeUrl);
 function createBaseQueryParamsResponse() {
     return {
         param: ParamChange.fromPartial({})
@@ -165,10 +163,11 @@ export const QueryParamsResponse = {
             typeUrl: "/cosmos.params.v1beta1.QueryParamsResponse",
             value: QueryParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ParamChange.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
 function createBaseQuerySubspacesRequest() {
     return {};
 }
@@ -230,10 +229,9 @@ export const QuerySubspacesRequest = {
             typeUrl: "/cosmos.params.v1beta1.QuerySubspacesRequest",
             value: QuerySubspacesRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QuerySubspacesRequest.typeUrl, QuerySubspacesRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QuerySubspacesRequest.aminoType, QuerySubspacesRequest.typeUrl);
 function createBaseQuerySubspacesResponse() {
     return {
         subspaces: []
@@ -311,10 +309,11 @@ export const QuerySubspacesResponse = {
             typeUrl: "/cosmos.params.v1beta1.QuerySubspacesResponse",
             value: QuerySubspacesResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Subspace.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QuerySubspacesResponse.typeUrl, QuerySubspacesResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QuerySubspacesResponse.aminoType, QuerySubspacesResponse.typeUrl);
 function createBaseSubspace() {
     return {
         subspace: "",
@@ -404,7 +403,6 @@ export const Subspace = {
             typeUrl: "/cosmos.params.v1beta1.Subspace",
             value: Subspace.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Subspace.typeUrl, Subspace);
-GlobalDecoderRegistry.registerAminoProtoMapping(Subspace.aminoType, Subspace.typeUrl);

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

@@ -5,12 +5,14 @@ export const createGetParams = (clientResolver) => buildQuery({
     decode: QueryParamsResponse.decode,
     service: "cosmos.params.v1beta1.Query",
     method: "Params",
-    clientResolver
+    clientResolver,
+    deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetSubspaces = (clientResolver) => buildQuery({
     encode: QuerySubspacesRequest.encode,
     decode: QuerySubspacesResponse.decode,
     service: "cosmos.params.v1beta1.Query",
     method: "Subspaces",
-    clientResolver
+    clientResolver,
+    deps: [QuerySubspacesRequest, QuerySubspacesResponse]
 });

package/esm/cosmos/slashing/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.slashing.module.v1.Module",
             value: Module.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);