@xpla/xplajs 1.7.0-beta.1 → 1.7.0-beta.11

package/src/cosmos/gov/v1beta1/tx.ts

@@ -1,21 +1,21 @@
 import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
 import { Coin, CoinAmino } from "../../base/v1beta1/coin";
 import { VoteOption, WeightedVoteOption, WeightedVoteOptionAmino, TextProposal, TextProposalProtoMsg } from "./gov";
-import { ClientUpdateProposal, ClientUpdateProposalProtoMsg, UpgradeProposal, UpgradeProposalProtoMsg } from "../../../ibc/core/client/v1/client";
-import { StoreCodeProposal, StoreCodeProposalProtoMsg, InstantiateContractProposal, InstantiateContractProposalProtoMsg, InstantiateContract2Proposal, InstantiateContract2ProposalProtoMsg, MigrateContractProposal, MigrateContractProposalProtoMsg, SudoContractProposal, SudoContractProposalProtoMsg, ExecuteContractProposal, ExecuteContractProposalProtoMsg, UpdateAdminProposal, UpdateAdminProposalProtoMsg, ClearAdminProposal, ClearAdminProposalProtoMsg, PinCodesProposal, PinCodesProposalProtoMsg, UnpinCodesProposal, UnpinCodesProposalProtoMsg, UpdateInstantiateConfigProposal, UpdateInstantiateConfigProposalProtoMsg, StoreAndInstantiateContractProposal, StoreAndInstantiateContractProposalProtoMsg } from "../../../cosmwasm/wasm/v1/proposal_legacy";
-import { SoftwareUpgradeProposal, SoftwareUpgradeProposalProtoMsg, CancelSoftwareUpgradeProposal, CancelSoftwareUpgradeProposalProtoMsg } from "../../upgrade/v1beta1/upgrade";
-import { ParameterChangeProposal, ParameterChangeProposalProtoMsg } from "../../params/v1beta1/params";
 import { CommunityPoolSpendProposal, CommunityPoolSpendProposalProtoMsg, CommunityPoolSpendProposalWithDeposit, CommunityPoolSpendProposalWithDepositProtoMsg } from "../../distribution/v1beta1/distribution";
+import { ParameterChangeProposal, ParameterChangeProposalProtoMsg } from "../../params/v1beta1/params";
+import { SoftwareUpgradeProposal, SoftwareUpgradeProposalProtoMsg, CancelSoftwareUpgradeProposal, CancelSoftwareUpgradeProposalProtoMsg } from "../../upgrade/v1beta1/upgrade";
+import { StoreCodeProposal, StoreCodeProposalProtoMsg, InstantiateContractProposal, InstantiateContractProposalProtoMsg, InstantiateContract2Proposal, InstantiateContract2ProposalProtoMsg, MigrateContractProposal, MigrateContractProposalProtoMsg, SudoContractProposal, SudoContractProposalProtoMsg, ExecuteContractProposal, ExecuteContractProposalProtoMsg, UpdateAdminProposal, UpdateAdminProposalProtoMsg, ClearAdminProposal, ClearAdminProposalProtoMsg, PinCodesProposal, PinCodesProposalProtoMsg, UnpinCodesProposal, UnpinCodesProposalProtoMsg, UpdateInstantiateConfigProposal, UpdateInstantiateConfigProposalProtoMsg, StoreAndInstantiateContractProposal, StoreAndInstantiateContractProposalProtoMsg } from "../../../cosmwasm/wasm/v1/proposal_legacy";
+import { ClientUpdateProposal, ClientUpdateProposalProtoMsg, UpgradeProposal, UpgradeProposalProtoMsg } from "../../../ibc/core/client/v1/client";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { DeepPartial, isSet } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
+import { DeepPartial, isSet } from "../../../helpers";
 /**
  * MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary
  * proposal Content.
  */
 export interface MsgSubmitProposal {
   /** content is the proposal's content. */
-  content?: ClientUpdateProposal | UpgradeProposal | StoreCodeProposal | InstantiateContractProposal | InstantiateContract2Proposal | MigrateContractProposal | SudoContractProposal | ExecuteContractProposal | UpdateAdminProposal | ClearAdminProposal | PinCodesProposal | UnpinCodesProposal | UpdateInstantiateConfigProposal | StoreAndInstantiateContractProposal | SoftwareUpgradeProposal | CancelSoftwareUpgradeProposal | ParameterChangeProposal | TextProposal | CommunityPoolSpendProposal | CommunityPoolSpendProposalWithDeposit | Any | undefined;
+  content?: CommunityPoolSpendProposal | CommunityPoolSpendProposalWithDeposit | TextProposal | ParameterChangeProposal | SoftwareUpgradeProposal | CancelSoftwareUpgradeProposal | StoreCodeProposal | InstantiateContractProposal | InstantiateContract2Proposal | MigrateContractProposal | SudoContractProposal | ExecuteContractProposal | UpdateAdminProposal | ClearAdminProposal | PinCodesProposal | UnpinCodesProposal | UpdateInstantiateConfigProposal | StoreAndInstantiateContractProposal | ClientUpdateProposal | UpgradeProposal | Any | undefined;
   /** initial_deposit is the deposit value that must be paid at proposal submission. */
   initialDeposit: Coin[];
   /** proposer is the account address of the proposer. */
@@ -26,7 +26,7 @@ export interface MsgSubmitProposalProtoMsg {
   value: Uint8Array;
 }
 export type MsgSubmitProposalEncoded = Omit<MsgSubmitProposal, "content"> & {
-  /** content is the proposal's content. */content?: ClientUpdateProposalProtoMsg | UpgradeProposalProtoMsg | StoreCodeProposalProtoMsg | InstantiateContractProposalProtoMsg | InstantiateContract2ProposalProtoMsg | MigrateContractProposalProtoMsg | SudoContractProposalProtoMsg | ExecuteContractProposalProtoMsg | UpdateAdminProposalProtoMsg | ClearAdminProposalProtoMsg | PinCodesProposalProtoMsg | UnpinCodesProposalProtoMsg | UpdateInstantiateConfigProposalProtoMsg | StoreAndInstantiateContractProposalProtoMsg | SoftwareUpgradeProposalProtoMsg | CancelSoftwareUpgradeProposalProtoMsg | ParameterChangeProposalProtoMsg | TextProposalProtoMsg | CommunityPoolSpendProposalProtoMsg | CommunityPoolSpendProposalWithDepositProtoMsg | AnyProtoMsg | undefined;
+  /** content is the proposal's content. */content?: CommunityPoolSpendProposalProtoMsg | CommunityPoolSpendProposalWithDepositProtoMsg | TextProposalProtoMsg | ParameterChangeProposalProtoMsg | SoftwareUpgradeProposalProtoMsg | CancelSoftwareUpgradeProposalProtoMsg | StoreCodeProposalProtoMsg | InstantiateContractProposalProtoMsg | InstantiateContract2ProposalProtoMsg | MigrateContractProposalProtoMsg | SudoContractProposalProtoMsg | ExecuteContractProposalProtoMsg | UpdateAdminProposalProtoMsg | ClearAdminProposalProtoMsg | PinCodesProposalProtoMsg | UnpinCodesProposalProtoMsg | UpdateInstantiateConfigProposalProtoMsg | StoreAndInstantiateContractProposalProtoMsg | ClientUpdateProposalProtoMsg | UpgradeProposalProtoMsg | AnyProtoMsg | undefined;
 };
 /**
  * MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary
@@ -292,10 +292,31 @@ export const MsgSubmitProposal = {
       typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
       value: MsgSubmitProposal.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    CommunityPoolSpendProposal.registerTypeUrl();
+    CommunityPoolSpendProposalWithDeposit.registerTypeUrl();
+    TextProposal.registerTypeUrl();
+    ParameterChangeProposal.registerTypeUrl();
+    SoftwareUpgradeProposal.registerTypeUrl();
+    CancelSoftwareUpgradeProposal.registerTypeUrl();
+    StoreCodeProposal.registerTypeUrl();
+    InstantiateContractProposal.registerTypeUrl();
+    InstantiateContract2Proposal.registerTypeUrl();
+    MigrateContractProposal.registerTypeUrl();
+    SudoContractProposal.registerTypeUrl();
+    ExecuteContractProposal.registerTypeUrl();
+    UpdateAdminProposal.registerTypeUrl();
+    ClearAdminProposal.registerTypeUrl();
+    PinCodesProposal.registerTypeUrl();
+    UnpinCodesProposal.registerTypeUrl();
+    UpdateInstantiateConfigProposal.registerTypeUrl();
+    StoreAndInstantiateContractProposal.registerTypeUrl();
+    ClientUpdateProposal.registerTypeUrl();
+    UpgradeProposal.registerTypeUrl();
+    Coin.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(MsgSubmitProposal.typeUrl, MsgSubmitProposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSubmitProposal.aminoType, MsgSubmitProposal.typeUrl);
 function createBaseMsgSubmitProposalResponse(): MsgSubmitProposalResponse {
   return {
     proposalId: BigInt(0)
@@ -370,10 +391,9 @@ export const MsgSubmitProposalResponse = {
       typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposalResponse",
       value: MsgSubmitProposalResponse.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgSubmitProposalResponse.typeUrl, MsgSubmitProposalResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSubmitProposalResponse.aminoType, MsgSubmitProposalResponse.typeUrl);
 function createBaseMsgVote(): MsgVote {
   return {
     proposalId: BigInt(0),
@@ -472,10 +492,9 @@ export const MsgVote = {
       typeUrl: "/cosmos.gov.v1beta1.MsgVote",
       value: MsgVote.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgVote.typeUrl, MsgVote);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVote.aminoType, MsgVote.typeUrl);
 function createBaseMsgVoteResponse(): MsgVoteResponse {
   return {};
 }
@@ -537,10 +556,9 @@ export const MsgVoteResponse = {
       typeUrl: "/cosmos.gov.v1beta1.MsgVoteResponse",
       value: MsgVoteResponse.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgVoteResponse.typeUrl, MsgVoteResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVoteResponse.aminoType, MsgVoteResponse.typeUrl);
 function createBaseMsgVoteWeighted(): MsgVoteWeighted {
   return {
     proposalId: BigInt(0),
@@ -641,10 +659,11 @@ export const MsgVoteWeighted = {
       typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
       value: MsgVoteWeighted.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    WeightedVoteOption.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(MsgVoteWeighted.typeUrl, MsgVoteWeighted);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVoteWeighted.aminoType, MsgVoteWeighted.typeUrl);
 function createBaseMsgVoteWeightedResponse(): MsgVoteWeightedResponse {
   return {};
 }
@@ -706,10 +725,9 @@ export const MsgVoteWeightedResponse = {
       typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeightedResponse",
       value: MsgVoteWeightedResponse.encode(message).finish()
     };
-  }
+  },
+  registerTypeUrl() {}
 };
-GlobalDecoderRegistry.register(MsgVoteWeightedResponse.typeUrl, MsgVoteWeightedResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVoteWeightedResponse.aminoType, MsgVoteWeightedResponse.typeUrl);
 function createBaseMsgDeposit(): MsgDeposit {
   return {
     proposalId: BigInt(0),
@@ -810,10 +828,11 @@ export const MsgDeposit = {
       typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
       value: MsgDeposit.encode(message).finish()
     };
+  },
+  registerTypeUrl() {
+    Coin.registerTypeUrl();
   }
 };
-GlobalDecoderRegistry.register(MsgDeposit.typeUrl, MsgDeposit);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgDeposit.aminoType, MsgDeposit.typeUrl);
 function createBaseMsgDepositResponse(): MsgDepositResponse {
   return {};
 }
@@ -875,7 +894,6 @@ export const MsgDepositResponse = {
       typeUrl: "/cosmos.gov.v1beta1.MsgDepositResponse",
       value: MsgDepositResponse.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(MsgDepositResponse.typeUrl, MsgDepositResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgDepositResponse.aminoType, MsgDepositResponse.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/ics23/v1/proofs.ts

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial, bytesFromBase64, base64FromBytes, isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 export enum HashOp {
   /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
   NO_HASH = 0,
@@ -754,10 +753,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(): NonExistenceProof {
   return {
     key: new Uint8Array(),
@@ -856,10 +857,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(): CommitmentProof {
   return {
     exist: undefined,
@@ -970,10 +972,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(): LeafOp {
   return {
     hash: 0,
@@ -1096,10 +1102,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(): InnerOp {
   return {
     hash: 0,
@@ -1198,10 +1203,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(): ProofSpec {
   return {
     leafSpec: undefined,
@@ -1324,10 +1328,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(): InnerSpec {
   return {
     childOrder: [],
@@ -1473,10 +1479,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(): BatchProof {
   return {
     entries: []
@@ -1553,10 +1558,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(): BatchEntry {
   return {
     exist: undefined,
@@ -1643,10 +1649,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(): CompressedBatchProof {
   return {
     entries: [],
@@ -1737,10 +1745,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(): CompressedBatchEntry {
   return {
     exist: undefined,
@@ -1827,10 +1837,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(): CompressedExistenceProof {
   return {
     key: new Uint8Array(),
@@ -1952,10 +1964,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(): CompressedNonExistenceProof {
   return {
     key: new Uint8Array(),
@@ -2054,7 +2067,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/src/cosmos/mint/module/v1/module.ts

@@ -1,6 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { DeepPartial } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 /** Module is the config object of the mint module. */
 export interface Module {
   feeCollectorName: string;
@@ -107,7 +106,6 @@ export const Module = {
       typeUrl: "/cosmos.mint.module.v1.Module",
       value: Module.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/mint/v1beta1/genesis.ts

@@ -1,7 +1,6 @@
 import { Minter, MinterAmino, Params, ParamsAmino } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** GenesisState defines the mint module's genesis state. */
 export interface GenesisState {
   /** minter is a space for holding current inflation information. */
@@ -110,7 +109,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/src/cosmos/mint/v1beta1/mint.ts

@@ -1,6 +1,6 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
 import { DeepPartial } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** Minter represents the minting state. */
 export interface Minter {
   /** current annual inflation rate */
@@ -78,10 +78,10 @@ export const Minter = {
   },
   encode(message: Minter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     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;
   },
@@ -93,10 +93,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);
@@ -123,8 +123,8 @@ export const Minter = {
   },
   toAmino(message: Minter): MinterAmino {
     const obj: any = {};
-    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: MinterAminoMsg): Minter {
@@ -147,10 +147,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(): Params {
   return {
     mintDenom: "",
@@ -175,16 +174,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);
@@ -202,16 +201,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();
@@ -258,10 +257,10 @@ export const Params = {
   toAmino(message: Params): ParamsAmino {
     const obj: any = {};
     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;
   },
@@ -285,7 +284,6 @@ export const Params = {
       typeUrl: "/cosmos.mint.v1beta1.Params",
       value: Params.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/mint/v1beta1/query.rpc.func.ts

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

package/src/cosmos/mint/v1beta1/query.ts

@@ -1,7 +1,6 @@
 import { Params, ParamsAmino } from "./mint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** QueryParamsRequest is the request type for the Query/Params RPC method. */
 export interface QueryParamsRequest {}
 export interface QueryParamsRequestProtoMsg {
@@ -171,10 +170,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(): QueryParamsResponse {
   return {
     params: Params.fromPartial({})
@@ -249,10 +247,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(): QueryInflationRequest {
   return {};
 }
@@ -314,10 +313,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(): QueryInflationResponse {
   return {
     inflation: new Uint8Array()
@@ -392,10 +390,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(): QueryAnnualProvisionsRequest {
   return {};
 }
@@ -457,10 +454,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(): QueryAnnualProvisionsResponse {
   return {
     annualProvisions: new Uint8Array()
@@ -535,7 +531,6 @@ export const QueryAnnualProvisionsResponse = {
       typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
       value: QueryAnnualProvisionsResponse.encode(message).finish()
     };
-  }
-};
-GlobalDecoderRegistry.register(QueryAnnualProvisionsResponse.typeUrl, QueryAnnualProvisionsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryAnnualProvisionsResponse.aminoType, QueryAnnualProvisionsResponse.typeUrl);
+  },
+  registerTypeUrl() {}
+};

package/src/cosmos/mint/v1beta1/tx.registry.ts

@@ -1,3 +1,29 @@
 import { TelescopeGeneratedType } from "../../../types";
 import { MsgUpdateParams } from "./tx";
-export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.mint.v1beta1.MsgUpdateParams", MsgUpdateParams]];
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.mint.v1beta1.MsgUpdateParams", MsgUpdateParams]];
+export const MessageComposer = {
+  encoded: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/cosmos.mint.v1beta1.MsgUpdateParams",
+        value: MsgUpdateParams.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/cosmos.mint.v1beta1.MsgUpdateParams",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/cosmos.mint.v1beta1.MsgUpdateParams",
+        value: MsgUpdateParams.fromPartial(value)
+      };
+    }
+  }
+};

package/src/cosmos/mint/v1beta1/tx.rpc.func.ts

@@ -5,5 +5,6 @@ export const createUpdateParams = (clientResolver?: SigningClientResolver) => bu
   clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
-  converters: toConverters(MsgUpdateParams)
+  converters: toConverters(MsgUpdateParams),
+  deps: [MsgUpdateParams]
 });