@xpla/xplajs 1.7.0-beta.8 → 1.7.0

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

@@ -2,7 +2,6 @@ import { Proposal, Vote, VotingParams, DepositParams, TallyParams, Deposit, Tall
 import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryProposalRequest() {
     return {
         proposalId: BigInt(0)
@@ -77,10 +76,9 @@ export const QueryProposalRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryProposalRequest",
             value: QueryProposalRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryProposalRequest.typeUrl, QueryProposalRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalRequest.aminoType, QueryProposalRequest.typeUrl);
 function createBaseQueryProposalResponse() {
     return {
         proposal: Proposal.fromPartial({})
@@ -155,10 +153,11 @@ export const QueryProposalResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryProposalResponse",
             value: QueryProposalResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Proposal.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryProposalResponse.typeUrl, QueryProposalResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalResponse.aminoType, QueryProposalResponse.typeUrl);
 function createBaseQueryProposalsRequest() {
     return {
         proposalStatus: 0,
@@ -269,10 +268,11 @@ export const QueryProposalsRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryProposalsRequest",
             value: QueryProposalsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryProposalsRequest.typeUrl, QueryProposalsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalsRequest.aminoType, QueryProposalsRequest.typeUrl);
 function createBaseQueryProposalsResponse() {
     return {
         proposals: [],
@@ -362,10 +362,12 @@ export const QueryProposalsResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryProposalsResponse",
             value: QueryProposalsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Proposal.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryProposalsResponse.typeUrl, QueryProposalsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalsResponse.aminoType, QueryProposalsResponse.typeUrl);
 function createBaseQueryVoteRequest() {
     return {
         proposalId: BigInt(0),
@@ -452,10 +454,9 @@ export const QueryVoteRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryVoteRequest",
             value: QueryVoteRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryVoteRequest.typeUrl, QueryVoteRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVoteRequest.aminoType, QueryVoteRequest.typeUrl);
 function createBaseQueryVoteResponse() {
     return {
         vote: Vote.fromPartial({})
@@ -530,10 +531,11 @@ export const QueryVoteResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryVoteResponse",
             value: QueryVoteResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Vote.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryVoteResponse.typeUrl, QueryVoteResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVoteResponse.aminoType, QueryVoteResponse.typeUrl);
 function createBaseQueryVotesRequest() {
     return {
         proposalId: BigInt(0),
@@ -620,10 +622,11 @@ export const QueryVotesRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryVotesRequest",
             value: QueryVotesRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryVotesRequest.typeUrl, QueryVotesRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVotesRequest.aminoType, QueryVotesRequest.typeUrl);
 function createBaseQueryVotesResponse() {
     return {
         votes: [],
@@ -713,10 +716,12 @@ export const QueryVotesResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryVotesResponse",
             value: QueryVotesResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Vote.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryVotesResponse.typeUrl, QueryVotesResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVotesResponse.aminoType, QueryVotesResponse.typeUrl);
 function createBaseQueryParamsRequest() {
     return {
         paramsType: ""
@@ -791,10 +796,9 @@ export const QueryParamsRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryParamsRequest",
             value: QueryParamsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsRequest.aminoType, QueryParamsRequest.typeUrl);
 function createBaseQueryParamsResponse() {
     return {
         votingParams: VotingParams.fromPartial({}),
@@ -893,10 +897,13 @@ export const QueryParamsResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryParamsResponse",
             value: QueryParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        VotingParams.registerTypeUrl();
+        DepositParams.registerTypeUrl();
+        TallyParams.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
 function createBaseQueryDepositRequest() {
     return {
         proposalId: BigInt(0),
@@ -983,10 +990,9 @@ export const QueryDepositRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryDepositRequest",
             value: QueryDepositRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryDepositRequest.typeUrl, QueryDepositRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositRequest.aminoType, QueryDepositRequest.typeUrl);
 function createBaseQueryDepositResponse() {
     return {
         deposit: Deposit.fromPartial({})
@@ -1061,10 +1067,11 @@ export const QueryDepositResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryDepositResponse",
             value: QueryDepositResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Deposit.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryDepositResponse.typeUrl, QueryDepositResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositResponse.aminoType, QueryDepositResponse.typeUrl);
 function createBaseQueryDepositsRequest() {
     return {
         proposalId: BigInt(0),
@@ -1151,10 +1158,11 @@ export const QueryDepositsRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryDepositsRequest",
             value: QueryDepositsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryDepositsRequest.typeUrl, QueryDepositsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositsRequest.aminoType, QueryDepositsRequest.typeUrl);
 function createBaseQueryDepositsResponse() {
     return {
         deposits: [],
@@ -1244,10 +1252,12 @@ export const QueryDepositsResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryDepositsResponse",
             value: QueryDepositsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Deposit.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryDepositsResponse.typeUrl, QueryDepositsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositsResponse.aminoType, QueryDepositsResponse.typeUrl);
 function createBaseQueryTallyResultRequest() {
     return {
         proposalId: BigInt(0)
@@ -1322,10 +1332,9 @@ export const QueryTallyResultRequest = {
             typeUrl: "/cosmos.gov.v1beta1.QueryTallyResultRequest",
             value: QueryTallyResultRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryTallyResultRequest.typeUrl, QueryTallyResultRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryTallyResultRequest.aminoType, QueryTallyResultRequest.typeUrl);
 function createBaseQueryTallyResultResponse() {
     return {
         tally: TallyResult.fromPartial({})
@@ -1400,7 +1409,8 @@ export const QueryTallyResultResponse = {
             typeUrl: "/cosmos.gov.v1beta1.QueryTallyResultResponse",
             value: QueryTallyResultResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TallyResult.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryTallyResultResponse.typeUrl, QueryTallyResultResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryTallyResultResponse.aminoType, QueryTallyResultResponse.typeUrl);

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

@@ -5,54 +5,62 @@ export const createGetProposal = (clientResolver) => buildQuery({
     decode: QueryProposalResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Proposal",
-    clientResolver
+    clientResolver,
+    deps: [QueryProposalRequest, QueryProposalResponse]
 });
 export const createGetProposals = (clientResolver) => buildQuery({
     encode: QueryProposalsRequest.encode,
     decode: QueryProposalsResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Proposals",
-    clientResolver
+    clientResolver,
+    deps: [QueryProposalsRequest, QueryProposalsResponse]
 });
 export const createGetVote = (clientResolver) => buildQuery({
     encode: QueryVoteRequest.encode,
     decode: QueryVoteResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Vote",
-    clientResolver
+    clientResolver,
+    deps: [QueryVoteRequest, QueryVoteResponse]
 });
 export const createGetVotes = (clientResolver) => buildQuery({
     encode: QueryVotesRequest.encode,
     decode: QueryVotesResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Votes",
-    clientResolver
+    clientResolver,
+    deps: [QueryVotesRequest, QueryVotesResponse]
 });
 export const createGetParams = (clientResolver) => buildQuery({
     encode: QueryParamsRequest.encode,
     decode: QueryParamsResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Params",
-    clientResolver
+    clientResolver,
+    deps: [QueryParamsRequest, QueryParamsResponse]
 });
 export const createGetDeposit = (clientResolver) => buildQuery({
     encode: QueryDepositRequest.encode,
     decode: QueryDepositResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Deposit",
-    clientResolver
+    clientResolver,
+    deps: [QueryDepositRequest, QueryDepositResponse]
 });
 export const createGetDeposits = (clientResolver) => buildQuery({
     encode: QueryDepositsRequest.encode,
     decode: QueryDepositsResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "Deposits",
-    clientResolver
+    clientResolver,
+    deps: [QueryDepositsRequest, QueryDepositsResponse]
 });
 export const createGetTallyResult = (clientResolver) => buildQuery({
     encode: QueryTallyResultRequest.encode,
     decode: QueryTallyResultResponse.decode,
     service: "cosmos.gov.v1beta1.Query",
     method: "TallyResult",
-    clientResolver
+    clientResolver,
+    deps: [QueryTallyResultRequest, QueryTallyResultResponse]
 });

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

@@ -1,9 +1,14 @@
 import { Any } from "../../../google/protobuf/any";
 import { Coin } from "../../base/v1beta1/coin";
-import { WeightedVoteOption } from "./gov";
+import { WeightedVoteOption, TextProposal } from "./gov";
+import { CommunityPoolSpendProposal, CommunityPoolSpendProposalWithDeposit } from "../../distribution/v1beta1/distribution";
+import { ParameterChangeProposal } from "../../params/v1beta1/params";
+import { SoftwareUpgradeProposal, CancelSoftwareUpgradeProposal } from "../../upgrade/v1beta1/upgrade";
+import { StoreCodeProposal, InstantiateContractProposal, InstantiateContract2Proposal, MigrateContractProposal, SudoContractProposal, ExecuteContractProposal, UpdateAdminProposal, ClearAdminProposal, PinCodesProposal, UnpinCodesProposal, UpdateInstantiateConfigProposal, StoreAndInstantiateContractProposal } from "../../../cosmwasm/wasm/v1/proposal_legacy";
+import { ClientUpdateProposal, UpgradeProposal } from "../../../ibc/core/client/v1/client";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { isSet } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
+import { isSet } from "../../../helpers";
 function createBaseMsgSubmitProposal() {
     return {
         content: undefined,
@@ -105,10 +110,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() {
     return {
         proposalId: BigInt(0)
@@ -183,10 +209,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() {
     return {
         proposalId: BigInt(0),
@@ -285,10 +310,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() {
     return {};
 }
@@ -350,10 +374,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() {
     return {
         proposalId: BigInt(0),
@@ -455,10 +478,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() {
     return {};
 }
@@ -520,10 +544,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() {
     return {
         proposalId: BigInt(0),
@@ -625,10 +648,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() {
     return {};
 }
@@ -690,7 +714,6 @@ export const MsgDepositResponse = {
             typeUrl: "/cosmos.gov.v1beta1.MsgDepositResponse",
             value: MsgDepositResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgDepositResponse.typeUrl, MsgDepositResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgDepositResponse.aminoType, MsgDepositResponse.typeUrl);

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

@@ -5,23 +5,27 @@ export const createSubmitProposal = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSubmitProposal.typeUrl,
     encoders: toEncoders(MsgSubmitProposal),
-    converters: toConverters(MsgSubmitProposal)
+    converters: toConverters(MsgSubmitProposal),
+    deps: [MsgSubmitProposal]
 });
 export const createVote = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgVote.typeUrl,
     encoders: toEncoders(MsgVote),
-    converters: toConverters(MsgVote)
+    converters: toConverters(MsgVote),
+    deps: [MsgVote]
 });
 export const createVoteWeighted = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgVoteWeighted.typeUrl,
     encoders: toEncoders(MsgVoteWeighted),
-    converters: toConverters(MsgVoteWeighted)
+    converters: toConverters(MsgVoteWeighted),
+    deps: [MsgVoteWeighted]
 });
 export const createDeposit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgDeposit.typeUrl,
     encoders: toEncoders(MsgDeposit),
-    converters: toConverters(MsgDeposit)
+    converters: toConverters(MsgDeposit),
+    deps: [MsgDeposit]
 });