@xpla/xpla-react 1.7.0-beta.10 → 1.7.0-beta.12

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

@@ -1,82 +1,2 @@
 import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
 export const registry = [["/cosmos.gov.v1beta1.MsgSubmitProposal", MsgSubmitProposal], ["/cosmos.gov.v1beta1.MsgVote", MsgVote], ["/cosmos.gov.v1beta1.MsgVoteWeighted", MsgVoteWeighted], ["/cosmos.gov.v1beta1.MsgDeposit", MsgDeposit]];
-export const MessageComposer = {
-    encoded: {
-        submitProposal(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
-                value: MsgSubmitProposal.encode(value).finish()
-            };
-        },
-        vote(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVote",
-                value: MsgVote.encode(value).finish()
-            };
-        },
-        voteWeighted(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
-                value: MsgVoteWeighted.encode(value).finish()
-            };
-        },
-        deposit(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
-                value: MsgDeposit.encode(value).finish()
-            };
-        }
-    },
-    withTypeUrl: {
-        submitProposal(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
-                value
-            };
-        },
-        vote(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVote",
-                value
-            };
-        },
-        voteWeighted(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
-                value
-            };
-        },
-        deposit(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
-                value
-            };
-        }
-    },
-    fromPartial: {
-        submitProposal(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
-                value: MsgSubmitProposal.fromPartial(value)
-            };
-        },
-        vote(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVote",
-                value: MsgVote.fromPartial(value)
-            };
-        },
-        voteWeighted(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
-                value: MsgVoteWeighted.fromPartial(value)
-            };
-        },
-        deposit(value) {
-            return {
-                typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
-                value: MsgDeposit.fromPartial(value)
-            };
-        }
-    }
-};

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

@@ -1,40 +1,31 @@
 import { buildTx } from "../../../helper-func-types";
-import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
 export const createSubmitProposal = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSubmitProposal.typeUrl,
     encoders: toEncoders(MsgSubmitProposal),
-    converters: toConverters(MsgSubmitProposal)
-});
-export const useSubmitProposal = buildUseMutation({
-    builderMutationFn: createSubmitProposal
+    converters: toConverters(MsgSubmitProposal),
+    deps: [MsgSubmitProposal]
 });
 export const createVote = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgVote.typeUrl,
     encoders: toEncoders(MsgVote),
-    converters: toConverters(MsgVote)
-});
-export const useVote = buildUseMutation({
-    builderMutationFn: createVote
+    converters: toConverters(MsgVote),
+    deps: [MsgVote]
 });
 export const createVoteWeighted = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgVoteWeighted.typeUrl,
     encoders: toEncoders(MsgVoteWeighted),
-    converters: toConverters(MsgVoteWeighted)
-});
-export const useVoteWeighted = buildUseMutation({
-    builderMutationFn: createVoteWeighted
+    converters: toConverters(MsgVoteWeighted),
+    deps: [MsgVoteWeighted]
 });
 export const createDeposit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgDeposit.typeUrl,
     encoders: toEncoders(MsgDeposit),
-    converters: toConverters(MsgDeposit)
-});
-export const useDeposit = buildUseMutation({
-    builderMutationFn: createDeposit
+    converters: toConverters(MsgDeposit),
+    deps: [MsgDeposit]
 });

package/esm/cosmos/gov/v1beta1/tx.rpc.react.js

@@ -0,0 +1,14 @@
+import { buildUseMutation } from "../../../react-query";
+import { createSubmitProposal, createVote, createVoteWeighted, createDeposit } from "./tx.rpc.func";
+export const useSubmitProposal = buildUseMutation({
+    builderMutationFn: createSubmitProposal
+});
+export const useVote = buildUseMutation({
+    builderMutationFn: createVote
+});
+export const useVoteWeighted = buildUseMutation({
+    builderMutationFn: createVoteWeighted
+});
+export const useDeposit = buildUseMutation({
+    builderMutationFn: createDeposit
+});

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

@@ -1,36 +1,26 @@
 import { buildQuery } from "../../../helper-func-types";
-import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
 export const createGetParams = (clientResolver) => buildQuery({
     encode: QueryParamsRequest.encode,
     decode: QueryParamsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Params",
-    clientResolver
-});
-export const useGetParams = buildUseQuery({
-    builderQueryFn: createGetParams,
-    queryKeyPrefix: "ParamsQuery"
+    clientResolver,
+    deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetInflation = (clientResolver) => buildQuery({
     encode: QueryInflationRequest.encode,
     decode: QueryInflationResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Inflation",
-    clientResolver
-});
-export const useGetInflation = buildUseQuery({
-    builderQueryFn: createGetInflation,
-    queryKeyPrefix: "InflationQuery"
+    clientResolver,
+    deps: [QueryInflationRequest, QueryInflationResponse]
 });
 export const createGetAnnualProvisions = (clientResolver) => buildQuery({
     encode: QueryAnnualProvisionsRequest.encode,
     decode: QueryAnnualProvisionsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "AnnualProvisions",
-    clientResolver
-});
-export const useGetAnnualProvisions = buildUseQuery({
-    builderQueryFn: createGetAnnualProvisions,
-    queryKeyPrefix: "AnnualProvisionsQuery"
+    clientResolver,
+    deps: [QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse]
 });

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

@@ -0,0 +1,14 @@
+import { buildUseQuery } from "../../../react-query";
+import { createGetParams, createGetInflation, createGetAnnualProvisions } from "./query.rpc.func";
+export const useGetParams = buildUseQuery({
+    builderQueryFn: createGetParams,
+    queryKeyPrefix: "ParamsQuery"
+});
+export const useGetInflation = buildUseQuery({
+    builderQueryFn: createGetInflation,
+    queryKeyPrefix: "InflationQuery"
+});
+export const useGetAnnualProvisions = buildUseQuery({
+    builderQueryFn: createGetAnnualProvisions,
+    queryKeyPrefix: "AnnualProvisionsQuery"
+});

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