@xpla/xplajs 1.7.0 → 1.8.0-rc.0

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/lcd.js

@@ -0,0 +1,107 @@
+import { LCDClient } from "@cosmology/lcd";
+export const createLCDClient = async ({ restEndpoint }) => {
+    const requestClient = new LCDClient({
+        restEndpoint
+    });
+    return {
+        cosmos: {
+            auth: {
+                v1beta1: new (await import("./auth/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            authz: {
+                v1beta1: new (await import("./authz/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            bank: {
+                v1beta1: new (await import("./bank/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            base: {
+                node: {
+                    v1beta1: new (await import("./base/node/v1beta1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                },
+                tendermint: {
+                    v1beta1: new (await import("./base/tendermint/v1beta1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                }
+            },
+            consensus: {
+                v1: new (await import("./consensus/v1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            distribution: {
+                v1beta1: new (await import("./distribution/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            evidence: {
+                v1beta1: new (await import("./evidence/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            evm: {
+                feemarket: {
+                    v1: new (await import("./evm/feemarket/v1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                },
+                vm: {
+                    v1: new (await import("./evm/vm/v1/query.lcd")).LCDQueryClient({
+                        requestClient
+                    })
+                }
+            },
+            feegrant: {
+                v1beta1: new (await import("./feegrant/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            gov: {
+                v1: new (await import("./gov/v1/query.lcd")).LCDQueryClient({
+                    requestClient
+                }),
+                v1beta1: new (await import("./gov/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            mint: {
+                v1beta1: new (await import("./mint/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            params: {
+                v1beta1: new (await import("./params/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            slashing: {
+                v1beta1: new (await import("./slashing/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            staking: {
+                v1beta1: new (await import("./staking/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            tx: {
+                v1beta1: new (await import("./tx/v1beta1/service.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            },
+            upgrade: {
+                v1beta1: new (await import("./upgrade/v1beta1/query.lcd")).LCDQueryClient({
+                    requestClient
+                })
+            }
+        }
+    };
+};

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",

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

@@ -1,26 +1,41 @@
 import { buildQuery } from "../../../helper-func-types";
 import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
-export const createGetParams = (clientResolver) => buildQuery({
+/**
+ * Params returns the total set of minting parameters.
+ * @name getParams
+ * @package cosmos.mint.v1beta1
+ * @see proto service: cosmos.mint.v1beta1.Params
+ */
+export const getParams = buildQuery({
     encode: QueryParamsRequest.encode,
     decode: QueryParamsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Params",
-    clientResolver,
     deps: [QueryParamsRequest, QueryParamsResponse]
 });
-export const createGetInflation = (clientResolver) => buildQuery({
+/**
+ * Inflation returns the current minting inflation value.
+ * @name getInflation
+ * @package cosmos.mint.v1beta1
+ * @see proto service: cosmos.mint.v1beta1.Inflation
+ */
+export const getInflation = buildQuery({
     encode: QueryInflationRequest.encode,
     decode: QueryInflationResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "Inflation",
-    clientResolver,
     deps: [QueryInflationRequest, QueryInflationResponse]
 });
-export const createGetAnnualProvisions = (clientResolver) => buildQuery({
+/**
+ * AnnualProvisions current minting annual provisions value.
+ * @name getAnnualProvisions
+ * @package cosmos.mint.v1beta1
+ * @see proto service: cosmos.mint.v1beta1.AnnualProvisions
+ */
+export const getAnnualProvisions = buildQuery({
     encode: QueryAnnualProvisionsRequest.encode,
     decode: QueryAnnualProvisionsResponse.decode,
     service: "cosmos.mint.v1beta1.Query",
     method: "AnnualProvisions",
-    clientResolver,
     deps: [QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse]
 });

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

@@ -1,11 +1,20 @@
 import { Params } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgUpdateParams() {
     return {
         authority: "",
         params: Params.fromPartial({})
     };
 }
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ *
+ * Since: cosmos-sdk 0.47
+ * @name MsgUpdateParams
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.MsgUpdateParams
+ */
 export const MsgUpdateParams = {
     typeUrl: "/cosmos.mint.v1beta1.MsgUpdateParams",
     aminoType: "cosmos-sdk/x/mint/MsgUpdateParams",
@@ -88,12 +97,24 @@ export const MsgUpdateParams = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };
 function createBaseMsgUpdateParamsResponse() {
     return {};
 }
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ *
+ * Since: cosmos-sdk 0.47
+ * @name MsgUpdateParamsResponse
+ * @package cosmos.mint.v1beta1
+ * @see proto type: cosmos.mint.v1beta1.MsgUpdateParamsResponse
+ */
 export const MsgUpdateParamsResponse = {
     typeUrl: "/cosmos.mint.v1beta1.MsgUpdateParamsResponse",
     aminoType: "cosmos-sdk/MsgUpdateParamsResponse",