@xpla/xplajs 1.7.0 → 1.8.0-rc.0

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

@@ -12,6 +12,12 @@ function createBasePlan() {
         upgradedClientState: undefined
     };
 }
+/**
+ * Plan specifies information about a planned upgrade and when it should occur.
+ * @name Plan
+ * @package cosmos.upgrade.v1beta1
+ * @see proto type: cosmos.upgrade.v1beta1.Plan
+ */
 export const Plan = {
     typeUrl: "/cosmos.upgrade.v1beta1.Plan",
     aminoType: "cosmos-sdk/Plan",
@@ -135,6 +141,16 @@ function createBaseSoftwareUpgradeProposal() {
         plan: Plan.fromPartial({})
     };
 }
+/**
+ * SoftwareUpgradeProposal is a gov Content type for initiating a software
+ * upgrade.
+ * Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
+ * proposals, see MsgSoftwareUpgrade.
+ * @name SoftwareUpgradeProposal
+ * @package cosmos.upgrade.v1beta1
+ * @see proto type: cosmos.upgrade.v1beta1.SoftwareUpgradeProposal
+ * @deprecated
+ */
 export const SoftwareUpgradeProposal = {
     typeUrl: "/cosmos.upgrade.v1beta1.SoftwareUpgradeProposal",
     aminoType: "cosmos-sdk/SoftwareUpgradeProposal",
@@ -228,6 +244,9 @@ export const SoftwareUpgradeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(SoftwareUpgradeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(SoftwareUpgradeProposal.typeUrl, SoftwareUpgradeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(SoftwareUpgradeProposal.aminoType, SoftwareUpgradeProposal.typeUrl);
         Plan.registerTypeUrl();
@@ -239,6 +258,16 @@ function createBaseCancelSoftwareUpgradeProposal() {
         description: ""
     };
 }
+/**
+ * CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software
+ * upgrade.
+ * Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
+ * proposals, see MsgCancelUpgrade.
+ * @name CancelSoftwareUpgradeProposal
+ * @package cosmos.upgrade.v1beta1
+ * @see proto type: cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal
+ * @deprecated
+ */
 export const CancelSoftwareUpgradeProposal = {
     typeUrl: "/cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal",
     aminoType: "cosmos-sdk/CancelSoftwareUpgradeProposal",
@@ -321,6 +350,9 @@ export const CancelSoftwareUpgradeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CancelSoftwareUpgradeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(CancelSoftwareUpgradeProposal.typeUrl, CancelSoftwareUpgradeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(CancelSoftwareUpgradeProposal.aminoType, CancelSoftwareUpgradeProposal.typeUrl);
     }
@@ -331,6 +363,14 @@ function createBaseModuleVersion() {
         version: BigInt(0)
     };
 }
+/**
+ * ModuleVersion specifies a module and its consensus version.
+ *
+ * Since: cosmos-sdk 0.43
+ * @name ModuleVersion
+ * @package cosmos.upgrade.v1beta1
+ * @see proto type: cosmos.upgrade.v1beta1.ModuleVersion
+ */
 export const ModuleVersion = {
     typeUrl: "/cosmos.upgrade.v1beta1.ModuleVersion",
     aminoType: "cosmos-sdk/ModuleVersion",

package/esm/cosmos_proto/bundle.js

@@ -0,0 +1 @@
+export { ScalarType, ScalarTypeAmino, InterfaceDescriptor, ScalarDescriptor } from "./cosmos";

package/esm/cosmos_proto/cosmos.js

@@ -43,6 +43,13 @@ function createBaseInterfaceDescriptor() {
         description: ""
     };
 }
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ * @name InterfaceDescriptor
+ * @package cosmos_proto
+ * @see proto type: cosmos_proto.InterfaceDescriptor
+ */
 export const InterfaceDescriptor = {
     typeUrl: "/cosmos_proto.InterfaceDescriptor",
     is(o) {
@@ -126,6 +133,18 @@ function createBaseScalarDescriptor() {
         fieldType: []
     };
 }
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ * @name ScalarDescriptor
+ * @package cosmos_proto
+ * @see proto type: cosmos_proto.ScalarDescriptor
+ */
 export const ScalarDescriptor = {
     typeUrl: "/cosmos_proto.ScalarDescriptor",
     is(o) {

package/esm/cosmwasm/bundle.js

@@ -0,0 +1,10 @@
+export * from "./wasm/v1/authz";
+export { GenesisState as CosmwasmWasmV1GenesisState, Code, Contract, Sequence } from "./wasm/v1/genesis";
+export * from "./wasm/v1/ibc";
+export * from "./wasm/v1/proposal_legacy";
+export { QueryContractInfoRequest, QueryContractInfoResponse, QueryContractHistoryRequest, QueryContractHistoryResponse, QueryContractsByCodeRequest, QueryContractsByCodeResponse, QueryAllContractStateRequest, QueryAllContractStateResponse, QueryRawContractStateRequest, QueryRawContractStateResponse, QuerySmartContractStateRequest, QuerySmartContractStateResponse, QueryCodeRequest as CosmwasmWasmV1QueryCodeRequest, QueryCodeInfoRequest, QueryCodeInfoResponse, CodeInfoResponse, QueryCodeResponse as CosmwasmWasmV1QueryCodeResponse, QueryCodesRequest, QueryCodesResponse, QueryPinnedCodesRequest, QueryPinnedCodesResponse, QueryParamsRequest as CosmwasmWasmV1QueryParamsRequest, QueryParamsResponse as CosmwasmWasmV1QueryParamsResponse, QueryContractsByCreatorRequest, QueryContractsByCreatorResponse, QueryWasmLimitsConfigRequest, QueryWasmLimitsConfigResponse, QueryBuildAddressRequest, QueryBuildAddressResponse } from "./wasm/v1/query";
+export { MsgStoreCode, MsgStoreCodeResponse, MsgInstantiateContract, MsgInstantiateContractResponse, MsgInstantiateContract2, MsgInstantiateContract2Response, MsgExecuteContract, MsgExecuteContractResponse, MsgMigrateContract, MsgMigrateContractResponse, MsgUpdateAdmin, MsgUpdateAdminResponse, MsgClearAdmin, MsgClearAdminResponse, MsgUpdateInstantiateConfig, MsgUpdateInstantiateConfigResponse, MsgUpdateParams as CosmwasmWasmV1MsgUpdateParams, MsgUpdateParamsResponse as CosmwasmWasmV1MsgUpdateParamsResponse, MsgSudoContract, MsgSudoContractResponse, MsgPinCodes, MsgPinCodesResponse, MsgUnpinCodes, MsgUnpinCodesResponse, MsgStoreAndInstantiateContract, MsgStoreAndInstantiateContractResponse, MsgAddCodeUploadParamsAddresses, MsgAddCodeUploadParamsAddressesResponse, MsgRemoveCodeUploadParamsAddresses, MsgRemoveCodeUploadParamsAddressesResponse, MsgStoreAndMigrateContract, MsgStoreAndMigrateContractResponse, MsgUpdateContractLabel, MsgUpdateContractLabelResponse } from "./wasm/v1/tx";
+export { AccessType as CosmwasmWasmV1AccessType, AccessTypeAmino as CosmwasmWasmV1AccessTypeAmino, ContractCodeHistoryOperationType, ContractCodeHistoryOperationTypeAmino, AccessTypeParam, AccessConfig, Params as CosmwasmWasmV1Params, CodeInfo, ContractInfo, ContractCodeHistoryEntry, AbsoluteTxPosition, Model } from "./wasm/v1/types";
+export { registry as CosmwasmWasmV1Registry, MessageComposer as CosmwasmWasmV1MessageComposer } from "./wasm/v1/tx.registry";
+export { getContractInfo, getContractHistory, getContractsByCode, getAllContractState, getRawContractState, getSmartContractState, getCode as getCodeCosmwasmWasmV1, getCodes, getCodeInfo, getPinnedCodes, getParams as getParamsCosmwasmWasmV1, getContractsByCreator, getWasmLimitsConfig, getBuildAddress } from "./wasm/v1/query.rpc.func";
+export { storeCode, instantiateContract, instantiateContract2, executeContract, migrateContract, updateAdmin, clearAdmin, updateInstantiateConfig, updateParams as updateParamsCosmwasmWasmV1, sudoContract, pinCodes, unpinCodes, storeAndInstantiateContract, removeCodeUploadParamsAddresses, addCodeUploadParamsAddresses, storeAndMigrateContract, updateContractLabel } from "./wasm/v1/tx.rpc.func";

package/esm/cosmwasm/lcd.js

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

package/esm/cosmwasm/rpc.query.js

@@ -0,0 +1,80 @@
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({ rpcEndpoint }) => {
+    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+    const client = new QueryClient(tmClient);
+    return {
+        cosmos: {
+            app: {
+                v1alpha1: (await import("../cosmos/app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            auth: {
+                v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            authz: {
+                v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            autocli: {
+                v1: (await import("../cosmos/autocli/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            bank: {
+                v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            base: {
+                node: {
+                    v1beta1: (await import("../cosmos/base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+                },
+                tendermint: {
+                    v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+                }
+            },
+            consensus: {
+                v1: (await import("../cosmos/consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            distribution: {
+                v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            evidence: {
+                v1beta1: (await import("../cosmos/evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            evm: {
+                feemarket: {
+                    v1: (await import("../cosmos/evm/feemarket/v1/query.rpc.Query")).createRpcQueryExtension(client)
+                },
+                vm: {
+                    v1: (await import("../cosmos/evm/vm/v1/query.rpc.Query")).createRpcQueryExtension(client)
+                }
+            },
+            feegrant: {
+                v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            gov: {
+                v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            mint: {
+                v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            params: {
+                v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            slashing: {
+                v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            staking: {
+                v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            tx: {
+                v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+            },
+            upgrade: {
+                v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        },
+        cosmwasm: {
+            wasm: {
+                v1: (await import("./wasm/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        }
+    };
+};

package/esm/cosmwasm/rpc.tx.js

@@ -0,0 +1,54 @@
+export const createRPCMsgClient = async ({ rpc }) => ({
+    cosmos: {
+        auth: {
+            v1beta1: new (await import("../cosmos/auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        authz: {
+            v1beta1: new (await import("../cosmos/authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        bank: {
+            v1beta1: new (await import("../cosmos/bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        consensus: {
+            v1: new (await import("../cosmos/consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        distribution: {
+            v1beta1: new (await import("../cosmos/distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        evidence: {
+            v1beta1: new (await import("../cosmos/evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        evm: {
+            feemarket: {
+                v1: new (await import("../cosmos/evm/feemarket/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+            },
+            vm: {
+                v1: new (await import("../cosmos/evm/vm/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+            }
+        },
+        feegrant: {
+            v1beta1: new (await import("../cosmos/feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        gov: {
+            v1: new (await import("../cosmos/gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+            v1beta1: new (await import("../cosmos/gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        mint: {
+            v1beta1: new (await import("../cosmos/mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        slashing: {
+            v1beta1: new (await import("../cosmos/slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        staking: {
+            v1beta1: new (await import("../cosmos/staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        upgrade: {
+            v1beta1: new (await import("../cosmos/upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+    },
+    cosmwasm: {
+        wasm: {
+            v1: new (await import("./wasm/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+    }
+});

package/esm/cosmwasm/wasm/v1/authz.js

@@ -10,6 +10,13 @@ function createBaseStoreCodeAuthorization() {
         grants: []
     };
 }
+/**
+ * StoreCodeAuthorization defines authorization for wasm code upload.
+ * Since: wasmd 0.42
+ * @name StoreCodeAuthorization
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.StoreCodeAuthorization
+ */
 export const StoreCodeAuthorization = {
     typeUrl: "/cosmwasm.wasm.v1.StoreCodeAuthorization",
     aminoType: "wasm/StoreCodeAuthorization",
@@ -84,6 +91,9 @@ export const StoreCodeAuthorization = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(StoreCodeAuthorization.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(StoreCodeAuthorization.typeUrl, StoreCodeAuthorization);
         GlobalDecoderRegistry.registerAminoProtoMapping(StoreCodeAuthorization.aminoType, StoreCodeAuthorization.typeUrl);
         CodeGrant.registerTypeUrl();
@@ -94,6 +104,13 @@ function createBaseContractExecutionAuthorization() {
         grants: []
     };
 }
+/**
+ * ContractExecutionAuthorization defines authorization for wasm execute.
+ * Since: wasmd 0.30
+ * @name ContractExecutionAuthorization
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.ContractExecutionAuthorization
+ */
 export const ContractExecutionAuthorization = {
     typeUrl: "/cosmwasm.wasm.v1.ContractExecutionAuthorization",
     aminoType: "wasm/ContractExecutionAuthorization",
@@ -168,6 +185,9 @@ export const ContractExecutionAuthorization = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ContractExecutionAuthorization.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(ContractExecutionAuthorization.typeUrl, ContractExecutionAuthorization);
         GlobalDecoderRegistry.registerAminoProtoMapping(ContractExecutionAuthorization.aminoType, ContractExecutionAuthorization.typeUrl);
         ContractGrant.registerTypeUrl();
@@ -178,6 +198,13 @@ function createBaseContractMigrationAuthorization() {
         grants: []
     };
 }
+/**
+ * ContractMigrationAuthorization defines authorization for wasm contract
+ * migration. Since: wasmd 0.30
+ * @name ContractMigrationAuthorization
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.ContractMigrationAuthorization
+ */
 export const ContractMigrationAuthorization = {
     typeUrl: "/cosmwasm.wasm.v1.ContractMigrationAuthorization",
     aminoType: "wasm/ContractMigrationAuthorization",
@@ -252,6 +279,9 @@ export const ContractMigrationAuthorization = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ContractMigrationAuthorization.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(ContractMigrationAuthorization.typeUrl, ContractMigrationAuthorization);
         GlobalDecoderRegistry.registerAminoProtoMapping(ContractMigrationAuthorization.aminoType, ContractMigrationAuthorization.typeUrl);
         ContractGrant.registerTypeUrl();
@@ -263,6 +293,12 @@ function createBaseCodeGrant() {
         instantiatePermission: undefined
     };
 }
+/**
+ * CodeGrant a granted permission for a single code
+ * @name CodeGrant
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.CodeGrant
+ */
 export const CodeGrant = {
     typeUrl: "/cosmwasm.wasm.v1.CodeGrant",
     aminoType: "wasm/CodeGrant",
@@ -345,6 +381,9 @@ export const CodeGrant = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CodeGrant.typeUrl)) {
+            return;
+        }
         AccessConfig.registerTypeUrl();
     }
 };
@@ -355,6 +394,13 @@ function createBaseContractGrant() {
         filter: undefined
     };
 }
+/**
+ * ContractGrant a granted permission for a single contract
+ * Since: wasmd 0.30
+ * @name ContractGrant
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.ContractGrant
+ */
 export const ContractGrant = {
     typeUrl: "/cosmwasm.wasm.v1.ContractGrant",
     aminoType: "wasm/ContractGrant",
@@ -448,6 +494,9 @@ export const ContractGrant = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ContractGrant.typeUrl)) {
+            return;
+        }
         AllowAllMessagesFilter.registerTypeUrl();
         AcceptedMessageKeysFilter.registerTypeUrl();
         AcceptedMessagesFilter.registerTypeUrl();
@@ -458,6 +507,13 @@ function createBaseMaxCallsLimit() {
         remaining: BigInt(0)
     };
 }
+/**
+ * MaxCallsLimit limited number of calls to the contract. No funds transferable.
+ * Since: wasmd 0.30
+ * @name MaxCallsLimit
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.MaxCallsLimit
+ */
 export const MaxCallsLimit = {
     typeUrl: "/cosmwasm.wasm.v1.MaxCallsLimit",
     aminoType: "wasm/MaxCallsLimit",
@@ -529,6 +585,9 @@ export const MaxCallsLimit = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MaxCallsLimit.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(MaxCallsLimit.typeUrl, MaxCallsLimit);
         GlobalDecoderRegistry.registerAminoProtoMapping(MaxCallsLimit.aminoType, MaxCallsLimit.typeUrl);
     }
@@ -538,6 +597,13 @@ function createBaseMaxFundsLimit() {
         amounts: []
     };
 }
+/**
+ * MaxFundsLimit defines the maximal amounts that can be sent to the contract.
+ * Since: wasmd 0.30
+ * @name MaxFundsLimit
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.MaxFundsLimit
+ */
 export const MaxFundsLimit = {
     typeUrl: "/cosmwasm.wasm.v1.MaxFundsLimit",
     aminoType: "wasm/MaxFundsLimit",
@@ -612,6 +678,9 @@ export const MaxFundsLimit = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MaxFundsLimit.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(MaxFundsLimit.typeUrl, MaxFundsLimit);
         GlobalDecoderRegistry.registerAminoProtoMapping(MaxFundsLimit.aminoType, MaxFundsLimit.typeUrl);
         Coin.registerTypeUrl();
@@ -623,6 +692,14 @@ function createBaseCombinedLimit() {
         amounts: []
     };
 }
+/**
+ * CombinedLimit defines the maximal amounts that can be sent to a contract and
+ * the maximal number of calls executable. Both need to remain >0 to be valid.
+ * Since: wasmd 0.30
+ * @name CombinedLimit
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.CombinedLimit
+ */
 export const CombinedLimit = {
     typeUrl: "/cosmwasm.wasm.v1.CombinedLimit",
     aminoType: "wasm/CombinedLimit",
@@ -708,6 +785,9 @@ export const CombinedLimit = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CombinedLimit.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(CombinedLimit.typeUrl, CombinedLimit);
         GlobalDecoderRegistry.registerAminoProtoMapping(CombinedLimit.aminoType, CombinedLimit.typeUrl);
         Coin.registerTypeUrl();
@@ -716,6 +796,14 @@ export const CombinedLimit = {
 function createBaseAllowAllMessagesFilter() {
     return {};
 }
+/**
+ * AllowAllMessagesFilter is a wildcard to allow any type of contract payload
+ * message.
+ * Since: wasmd 0.30
+ * @name AllowAllMessagesFilter
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.AllowAllMessagesFilter
+ */
 export const AllowAllMessagesFilter = {
     typeUrl: "/cosmwasm.wasm.v1.AllowAllMessagesFilter",
     aminoType: "wasm/AllowAllMessagesFilter",
@@ -776,6 +864,9 @@ export const AllowAllMessagesFilter = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AllowAllMessagesFilter.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(AllowAllMessagesFilter.typeUrl, AllowAllMessagesFilter);
         GlobalDecoderRegistry.registerAminoProtoMapping(AllowAllMessagesFilter.aminoType, AllowAllMessagesFilter.typeUrl);
     }
@@ -785,6 +876,14 @@ function createBaseAcceptedMessageKeysFilter() {
         keys: []
     };
 }
+/**
+ * AcceptedMessageKeysFilter accept only the specific contract message keys in
+ * the json object to be executed.
+ * Since: wasmd 0.30
+ * @name AcceptedMessageKeysFilter
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.AcceptedMessageKeysFilter
+ */
 export const AcceptedMessageKeysFilter = {
     typeUrl: "/cosmwasm.wasm.v1.AcceptedMessageKeysFilter",
     aminoType: "wasm/AcceptedMessageKeysFilter",
@@ -859,6 +958,9 @@ export const AcceptedMessageKeysFilter = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AcceptedMessageKeysFilter.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(AcceptedMessageKeysFilter.typeUrl, AcceptedMessageKeysFilter);
         GlobalDecoderRegistry.registerAminoProtoMapping(AcceptedMessageKeysFilter.aminoType, AcceptedMessageKeysFilter.typeUrl);
     }
@@ -868,6 +970,14 @@ function createBaseAcceptedMessagesFilter() {
         messages: []
     };
 }
+/**
+ * AcceptedMessagesFilter accept only the specific raw contract messages to be
+ * executed.
+ * Since: wasmd 0.30
+ * @name AcceptedMessagesFilter
+ * @package cosmwasm.wasm.v1
+ * @see proto type: cosmwasm.wasm.v1.AcceptedMessagesFilter
+ */
 export const AcceptedMessagesFilter = {
     typeUrl: "/cosmwasm.wasm.v1.AcceptedMessagesFilter",
     aminoType: "wasm/AcceptedMessagesFilter",
@@ -942,6 +1052,9 @@ export const AcceptedMessagesFilter = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AcceptedMessagesFilter.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(AcceptedMessagesFilter.typeUrl, AcceptedMessagesFilter);
         GlobalDecoderRegistry.registerAminoProtoMapping(AcceptedMessagesFilter.aminoType, AcceptedMessagesFilter.typeUrl);
     }