@xpla/xpla-react 1.7.0 → 1.8.0-rc.0

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

@@ -1,2 +1,82 @@
 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,31 +1,40 @@
 import { buildTx } from "../../../helper-func-types";
-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),
-    deps: [MsgSubmitProposal]
+/**
+ * SubmitProposal defines a method to create new proposal given a content.
+ * @name submitProposal
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.SubmitProposal
+ */
+export const submitProposal = buildTx({
+    msg: MsgSubmitProposal
 });
-export const createVote = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgVote.typeUrl,
-    encoders: toEncoders(MsgVote),
-    converters: toConverters(MsgVote),
-    deps: [MsgVote]
+/**
+ * Vote defines a method to add a vote on a specific proposal.
+ * @name vote
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.Vote
+ */
+export const vote = buildTx({
+    msg: MsgVote
 });
-export const createVoteWeighted = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgVoteWeighted.typeUrl,
-    encoders: toEncoders(MsgVoteWeighted),
-    converters: toConverters(MsgVoteWeighted),
-    deps: [MsgVoteWeighted]
+/**
+ * VoteWeighted defines a method to add a weighted vote on a specific proposal.
+ *
+ * Since: cosmos-sdk 0.43
+ * @name voteWeighted
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.VoteWeighted
+ */
+export const voteWeighted = buildTx({
+    msg: MsgVoteWeighted
 });
-export const createDeposit = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgDeposit.typeUrl,
-    encoders: toEncoders(MsgDeposit),
-    converters: toConverters(MsgDeposit),
-    deps: [MsgDeposit]
+/**
+ * Deposit defines a method to add deposit on a specific proposal.
+ * @name deposit
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.Deposit
+ */
+export const deposit = buildTx({
+    msg: MsgDeposit
 });

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

@@ -1,14 +1,40 @@
 import { buildUseMutation } from "../../../react-query";
-import { createSubmitProposal, createVote, createVoteWeighted, createDeposit } from "./tx.rpc.func";
+import { submitProposal, vote, voteWeighted, deposit } from "./tx.rpc.func";
+/**
+ * SubmitProposal defines a method to create new proposal given a content.
+ * @name useSubmitProposal
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.SubmitProposal
+ */
 export const useSubmitProposal = buildUseMutation({
-    builderMutationFn: createSubmitProposal
+    builderMutationFn: submitProposal
 });
+/**
+ * Vote defines a method to add a vote on a specific proposal.
+ * @name useVote
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.Vote
+ */
 export const useVote = buildUseMutation({
-    builderMutationFn: createVote
+    builderMutationFn: vote
 });
+/**
+ * VoteWeighted defines a method to add a weighted vote on a specific proposal.
+ *
+ * Since: cosmos-sdk 0.43
+ * @name useVoteWeighted
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.VoteWeighted
+ */
 export const useVoteWeighted = buildUseMutation({
-    builderMutationFn: createVoteWeighted
+    builderMutationFn: voteWeighted
 });
+/**
+ * Deposit defines a method to add deposit on a specific proposal.
+ * @name useDeposit
+ * @package cosmos.gov.v1beta1
+ * @see proto service: cosmos.gov.v1beta1.Deposit
+ */
 export const useDeposit = buildUseMutation({
-    builderMutationFn: createDeposit
+    builderMutationFn: deposit
 });

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

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 import { bytesFromBase64, base64FromBytes, isSet } from "../../../helpers";
 export var HashOp;
 (function (HashOp) {
@@ -179,6 +180,30 @@ function createBaseExistenceProof() {
         path: []
     };
 }
+/**
+ * ExistenceProof takes a key and a value and a set of steps to perform on it.
+ * The result of peforming all these steps will provide a "root hash", which can
+ * be compared to the value in a header.
+ *
+ * Since it is computationally infeasible to produce a hash collission for any of the used
+ * cryptographic hash functions, if someone can provide a series of operations to transform
+ * a given key and value into a root hash that matches some trusted root, these key and values
+ * must be in the referenced merkle tree.
+ *
+ * The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
+ * which should be controlled by a spec. Eg. with lengthOp as NONE,
+ * prefix = FOO, key = BAR, value = CHOICE
+ * and
+ * prefix = F, key = OOBAR, value = CHOICE
+ * would produce the same value.
+ *
+ * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
+ * in the ProofSpec is valuable to prevent this mutability. And why all trees should
+ * length-prefix the data before hashing it.
+ * @name ExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ExistenceProof
+ */
 export const ExistenceProof = {
     typeUrl: "/cosmos.ics23.v1.ExistenceProof",
     aminoType: "cosmos-sdk/ExistenceProof",
@@ -286,6 +311,9 @@ export const ExistenceProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ExistenceProof.typeUrl)) {
+            return;
+        }
         LeafOp.registerTypeUrl();
         InnerOp.registerTypeUrl();
     }
@@ -297,6 +325,14 @@ function createBaseNonExistenceProof() {
         right: undefined
     };
 }
+/**
+ * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
+ * one right of the desired key. If both proofs are valid AND they are neighbors,
+ * then there is no valid proof for the given key.
+ * @name NonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.NonExistenceProof
+ */
 export const NonExistenceProof = {
     typeUrl: "/cosmos.ics23.v1.NonExistenceProof",
     aminoType: "cosmos-sdk/NonExistenceProof",
@@ -390,6 +426,9 @@ export const NonExistenceProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(NonExistenceProof.typeUrl)) {
+            return;
+        }
         ExistenceProof.registerTypeUrl();
     }
 };
@@ -401,6 +440,12 @@ function createBaseCommitmentProof() {
         compressed: undefined
     };
 }
+/**
+ * CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+ * @name CommitmentProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CommitmentProof
+ */
 export const CommitmentProof = {
     typeUrl: "/cosmos.ics23.v1.CommitmentProof",
     aminoType: "cosmos-sdk/CommitmentProof",
@@ -505,6 +550,9 @@ export const CommitmentProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CommitmentProof.typeUrl)) {
+            return;
+        }
         ExistenceProof.registerTypeUrl();
         NonExistenceProof.registerTypeUrl();
         BatchProof.registerTypeUrl();
@@ -520,6 +568,25 @@ function createBaseLeafOp() {
         prefix: new Uint8Array()
     };
 }
+/**
+ * LeafOp represents the raw key-value data we wish to prove, and
+ * must be flexible to represent the internal transformation from
+ * the original key-value pairs into the basis hash, for many existing
+ * merkle trees.
+ *
+ * key and value are passed in. So that the signature of this operation is:
+ * leafOp(key, value) -> output
+ *
+ * To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+ * hkey = prehashKey(key)
+ * hvalue = prehashValue(value)
+ *
+ * Then combine the bytes, and hash it
+ * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ * @name LeafOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.LeafOp
+ */
 export const LeafOp = {
     typeUrl: "/cosmos.ics23.v1.LeafOp",
     aminoType: "cosmos-sdk/LeafOp",
@@ -643,6 +710,26 @@ function createBaseInnerOp() {
         suffix: new Uint8Array()
     };
 }
+/**
+ * InnerOp represents a merkle-proof step that is not a leaf.
+ * It represents concatenating two children and hashing them to provide the next result.
+ *
+ * The result of the previous step is passed in, so the signature of this op is:
+ * innerOp(child) -> output
+ *
+ * The result of applying InnerOp should be:
+ * output = op.hash(op.prefix || child || op.suffix)
+ *
+ * where the || operator is concatenation of binary data,
+ * and child is the result of hashing all the tree below this step.
+ *
+ * Any special data, like prepending child with the length, or prepending the entire operation with
+ * some value to differentiate from leaf nodes, should be included in prefix and suffix.
+ * If either of prefix or suffix is empty, we just treat it as an empty string
+ * @name InnerOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerOp
+ */
 export const InnerOp = {
     typeUrl: "/cosmos.ics23.v1.InnerOp",
     aminoType: "cosmos-sdk/InnerOp",
@@ -746,6 +833,21 @@ function createBaseProofSpec() {
         prehashKeyBeforeComparison: false
     };
 }
+/**
+ * ProofSpec defines what the expected parameters are for a given proof type.
+ * This can be stored in the client and used to validate any incoming proofs.
+ *
+ * verify(ProofSpec, Proof) -> Proof | Error
+ *
+ * As demonstrated in tests, if we don't fix the algorithm used to calculate the
+ * LeafHash for a given tree, there are many possible key-value pairs that can
+ * generate a given hash (by interpretting the preimage differently).
+ * We need this for proper security, requires client knows a priori what
+ * tree format server uses. But not in code, rather a configuration object.
+ * @name ProofSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ProofSpec
+ */
 export const ProofSpec = {
     typeUrl: "/cosmos.ics23.v1.ProofSpec",
     aminoType: "cosmos-sdk/ProofSpec",
@@ -861,6 +963,9 @@ export const ProofSpec = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ProofSpec.typeUrl)) {
+            return;
+        }
         LeafOp.registerTypeUrl();
         InnerSpec.registerTypeUrl();
     }
@@ -875,6 +980,19 @@ function createBaseInnerSpec() {
         hash: 0
     };
 }
+/**
+ * InnerSpec contains all store-specific structure info to determine if two proofs from a
+ * given store are neighbors.
+ *
+ * This enables:
+ *
+ * isLeftMost(spec: InnerSpec, op: InnerOp)
+ * isRightMost(spec: InnerSpec, op: InnerOp)
+ * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+ * @name InnerSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerSpec
+ */
 export const InnerSpec = {
     typeUrl: "/cosmos.ics23.v1.InnerSpec",
     aminoType: "cosmos-sdk/InnerSpec",
@@ -1020,6 +1138,12 @@ function createBaseBatchProof() {
         entries: []
     };
 }
+/**
+ * BatchProof is a group of multiple proof types than can be compressed
+ * @name BatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchProof
+ */
 export const BatchProof = {
     typeUrl: "/cosmos.ics23.v1.BatchProof",
     aminoType: "cosmos-sdk/BatchProof",
@@ -1094,6 +1218,9 @@ export const BatchProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BatchProof.typeUrl)) {
+            return;
+        }
         BatchEntry.registerTypeUrl();
     }
 };
@@ -1103,6 +1230,12 @@ function createBaseBatchEntry() {
         nonexist: undefined
     };
 }
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name BatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchEntry
+ */
 export const BatchEntry = {
     typeUrl: "/cosmos.ics23.v1.BatchEntry",
     aminoType: "cosmos-sdk/BatchEntry",
@@ -1185,6 +1318,9 @@ export const BatchEntry = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BatchEntry.typeUrl)) {
+            return;
+        }
         ExistenceProof.registerTypeUrl();
         NonExistenceProof.registerTypeUrl();
     }
@@ -1195,6 +1331,11 @@ function createBaseCompressedBatchProof() {
         lookupInners: []
     };
 }
+/**
+ * @name CompressedBatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchProof
+ */
 export const CompressedBatchProof = {
     typeUrl: "/cosmos.ics23.v1.CompressedBatchProof",
     aminoType: "cosmos-sdk/CompressedBatchProof",
@@ -1283,6 +1424,9 @@ export const CompressedBatchProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedBatchProof.typeUrl)) {
+            return;
+        }
         CompressedBatchEntry.registerTypeUrl();
         InnerOp.registerTypeUrl();
     }
@@ -1293,6 +1437,12 @@ function createBaseCompressedBatchEntry() {
         nonexist: undefined
     };
 }
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name CompressedBatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchEntry
+ */
 export const CompressedBatchEntry = {
     typeUrl: "/cosmos.ics23.v1.CompressedBatchEntry",
     aminoType: "cosmos-sdk/CompressedBatchEntry",
@@ -1375,6 +1525,9 @@ export const CompressedBatchEntry = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedBatchEntry.typeUrl)) {
+            return;
+        }
         CompressedExistenceProof.registerTypeUrl();
         CompressedNonExistenceProof.registerTypeUrl();
     }
@@ -1387,6 +1540,11 @@ function createBaseCompressedExistenceProof() {
         path: []
     };
 }
+/**
+ * @name CompressedExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedExistenceProof
+ */
 export const CompressedExistenceProof = {
     typeUrl: "/cosmos.ics23.v1.CompressedExistenceProof",
     aminoType: "cosmos-sdk/CompressedExistenceProof",
@@ -1504,6 +1662,9 @@ export const CompressedExistenceProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedExistenceProof.typeUrl)) {
+            return;
+        }
         LeafOp.registerTypeUrl();
     }
 };
@@ -1514,6 +1675,11 @@ function createBaseCompressedNonExistenceProof() {
         right: undefined
     };
 }
+/**
+ * @name CompressedNonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedNonExistenceProof
+ */
 export const CompressedNonExistenceProof = {
     typeUrl: "/cosmos.ics23.v1.CompressedNonExistenceProof",
     aminoType: "cosmos-sdk/CompressedNonExistenceProof",
@@ -1607,6 +1773,9 @@ export const CompressedNonExistenceProof = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedNonExistenceProof.typeUrl)) {
+            return;
+        }
         CompressedExistenceProof.registerTypeUrl();
     }
 };

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

@@ -5,6 +5,12 @@ function createBaseModule() {
         authority: ""
     };
 }
+/**
+ * Module is the config object of the mint module.
+ * @name Module
+ * @package cosmos.mint.module.v1
+ * @see proto type: cosmos.mint.module.v1.Module
+ */
 export const Module = {
     typeUrl: "/cosmos.mint.module.v1.Module",
     aminoType: "cosmos-sdk/Module",

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

@@ -1,11 +1,18 @@
 import { Minter, Params } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         minter: Minter.fromPartial({}),
         params: Params.fromPartial({})
     };
 }
+/**
+ * GenesisState defines the mint module's genesis state.
+ * @name GenesisState
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.GenesisState
+ */
 export const GenesisState = {
     typeUrl: "/cosmos.mint.v1beta1.GenesisState",
     aminoType: "cosmos-sdk/GenesisState",
@@ -88,6 +95,9 @@ export const GenesisState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) {
+            return;
+        }
         Minter.registerTypeUrl();
         Params.registerTypeUrl();
     }

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

@@ -6,6 +6,12 @@ function createBaseMinter() {
         annualProvisions: ""
     };
 }
+/**
+ * Minter represents the minting state.
+ * @name Minter
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.Minter
+ */
 export const Minter = {
     typeUrl: "/cosmos.mint.v1beta1.Minter",
     aminoType: "cosmos-sdk/Minter",
@@ -99,6 +105,12 @@ function createBaseParams() {
         blocksPerYear: BigInt(0)
     };
 }
+/**
+ * Params defines the parameters for the x/mint module.
+ * @name Params
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.Params
+ */
 export const Params = {
     typeUrl: "/cosmos.mint.v1beta1.Params",
     aminoType: "cosmos-sdk/x/mint/Params",

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

@@ -1,9 +1,16 @@
 import { Params } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryParamsRequest() {
     return {};
 }
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryParamsRequest
+ */
 export const QueryParamsRequest = {
     typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest",
     aminoType: "cosmos-sdk/QueryParamsRequest",
@@ -70,6 +77,12 @@ function createBaseQueryParamsResponse() {
         params: Params.fromPartial({})
     };
 }
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryParamsResponse
+ */
 export const QueryParamsResponse = {
     typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
     aminoType: "cosmos-sdk/QueryParamsResponse",
@@ -141,12 +154,21 @@ export const QueryParamsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryParamsResponse.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };
 function createBaseQueryInflationRequest() {
     return {};
 }
+/**
+ * QueryInflationRequest is the request type for the Query/Inflation RPC method.
+ * @name QueryInflationRequest
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryInflationRequest
+ */
 export const QueryInflationRequest = {
     typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
     aminoType: "cosmos-sdk/QueryInflationRequest",
@@ -213,6 +235,13 @@ function createBaseQueryInflationResponse() {
         inflation: new Uint8Array()
     };
 }
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ * @name QueryInflationResponse
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryInflationResponse
+ */
 export const QueryInflationResponse = {
     typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
     aminoType: "cosmos-sdk/QueryInflationResponse",
@@ -288,6 +317,13 @@ export const QueryInflationResponse = {
 function createBaseQueryAnnualProvisionsRequest() {
     return {};
 }
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ * @name QueryAnnualProvisionsRequest
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryAnnualProvisionsRequest
+ */
 export const QueryAnnualProvisionsRequest = {
     typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
     aminoType: "cosmos-sdk/QueryAnnualProvisionsRequest",
@@ -354,6 +390,13 @@ function createBaseQueryAnnualProvisionsResponse() {
         annualProvisions: new Uint8Array()
     };
 }
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ * @name QueryAnnualProvisionsResponse
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.QueryAnnualProvisionsResponse
+ */
 export const QueryAnnualProvisionsResponse = {
     typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
     aminoType: "cosmos-sdk/QueryAnnualProvisionsResponse",