@xpla/xplajs 1.7.0-beta.8 → 1.7.0

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

@@ -1,4 +1,5 @@
 import { Any } from "../../../google/protobuf/any";
+import { BasicAllowance, PeriodicAllowance, AllowedMsgAllowance } from "./feegrant";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgGrantAllowance() {
@@ -99,10 +100,13 @@ export const MsgGrantAllowance = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
             value: MsgGrantAllowance.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        BasicAllowance.registerTypeUrl();
+        PeriodicAllowance.registerTypeUrl();
+        AllowedMsgAllowance.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgGrantAllowance.typeUrl, MsgGrantAllowance);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgGrantAllowance.aminoType, MsgGrantAllowance.typeUrl);
 function createBaseMsgGrantAllowanceResponse() {
     return {};
 }
@@ -164,10 +168,9 @@ export const MsgGrantAllowanceResponse = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowanceResponse",
             value: MsgGrantAllowanceResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgGrantAllowanceResponse.typeUrl, MsgGrantAllowanceResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgGrantAllowanceResponse.aminoType, MsgGrantAllowanceResponse.typeUrl);
 function createBaseMsgRevokeAllowance() {
     return {
         granter: "",
@@ -254,10 +257,9 @@ export const MsgRevokeAllowance = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
             value: MsgRevokeAllowance.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgRevokeAllowance.typeUrl, MsgRevokeAllowance);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRevokeAllowance.aminoType, MsgRevokeAllowance.typeUrl);
 function createBaseMsgRevokeAllowanceResponse() {
     return {};
 }
@@ -319,10 +321,9 @@ export const MsgRevokeAllowanceResponse = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowanceResponse",
             value: MsgRevokeAllowanceResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgRevokeAllowanceResponse.typeUrl, MsgRevokeAllowanceResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRevokeAllowanceResponse.aminoType, MsgRevokeAllowanceResponse.typeUrl);
 function createBaseMsgPruneAllowances() {
     return {
         pruner: ""
@@ -397,10 +398,9 @@ export const MsgPruneAllowances = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowances",
             value: MsgPruneAllowances.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgPruneAllowances.typeUrl, MsgPruneAllowances);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgPruneAllowances.aminoType, MsgPruneAllowances.typeUrl);
 function createBaseMsgPruneAllowancesResponse() {
     return {};
 }
@@ -462,7 +462,6 @@ export const MsgPruneAllowancesResponse = {
             typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowancesResponse",
             value: MsgPruneAllowancesResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgPruneAllowancesResponse.typeUrl, MsgPruneAllowancesResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgPruneAllowancesResponse.aminoType, MsgPruneAllowancesResponse.typeUrl);

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

@@ -1,2 +1,64 @@
 import { MsgGrantAllowance, MsgRevokeAllowance, MsgPruneAllowances } from "./tx";
 export const registry = [["/cosmos.feegrant.v1beta1.MsgGrantAllowance", MsgGrantAllowance], ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", MsgRevokeAllowance], ["/cosmos.feegrant.v1beta1.MsgPruneAllowances", MsgPruneAllowances]];
+export const MessageComposer = {
+    encoded: {
+        grantAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+                value: MsgGrantAllowance.encode(value).finish()
+            };
+        },
+        revokeAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+                value: MsgRevokeAllowance.encode(value).finish()
+            };
+        },
+        pruneAllowances(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowances",
+                value: MsgPruneAllowances.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        grantAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+                value
+            };
+        },
+        revokeAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+                value
+            };
+        },
+        pruneAllowances(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowances",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        grantAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+                value: MsgGrantAllowance.fromPartial(value)
+            };
+        },
+        revokeAllowance(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+                value: MsgRevokeAllowance.fromPartial(value)
+            };
+        },
+        pruneAllowances(value) {
+            return {
+                typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowances",
+                value: MsgPruneAllowances.fromPartial(value)
+            };
+        }
+    }
+};

package/esm/cosmos/feegrant/v1beta1/tx.rpc.func.js

@@ -5,17 +5,20 @@ export const createGrantAllowance = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgGrantAllowance.typeUrl,
     encoders: toEncoders(MsgGrantAllowance),
-    converters: toConverters(MsgGrantAllowance)
+    converters: toConverters(MsgGrantAllowance),
+    deps: [MsgGrantAllowance]
 });
 export const createRevokeAllowance = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgRevokeAllowance.typeUrl,
     encoders: toEncoders(MsgRevokeAllowance),
-    converters: toConverters(MsgRevokeAllowance)
+    converters: toConverters(MsgRevokeAllowance),
+    deps: [MsgRevokeAllowance]
 });
 export const createPruneAllowances = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgPruneAllowances.typeUrl,
     encoders: toEncoders(MsgPruneAllowances),
-    converters: toConverters(MsgPruneAllowances)
+    converters: toConverters(MsgPruneAllowances),
+    deps: [MsgPruneAllowances]
 });

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

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseModule() {
     return {
         maxMetadataLen: BigInt(0),
@@ -86,7 +85,6 @@ export const Module = {
             typeUrl: "/cosmos.gov.module.v1.Module",
             value: Module.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/esm/cosmos/gov/v1/genesis.js

@@ -1,6 +1,5 @@
 import { Deposit, Vote, Proposal, DepositParams, VotingParams, TallyParams, Params } from "./gov";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         startingProposalId: BigInt(0),
@@ -180,7 +179,14 @@ export const GenesisState = {
             typeUrl: "/cosmos.gov.v1.GenesisState",
             value: GenesisState.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Deposit.registerTypeUrl();
+        Vote.registerTypeUrl();
+        Proposal.registerTypeUrl();
+        DepositParams.registerTypeUrl();
+        VotingParams.registerTypeUrl();
+        TallyParams.registerTypeUrl();
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
-GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

package/esm/cosmos/gov/v1/gov.js

@@ -4,7 +4,6 @@ import { Timestamp } from "../../../google/protobuf/timestamp";
 import { Duration } from "../../../google/protobuf/duration";
 import { isSet, toTimestamp, fromTimestamp } from "../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** VoteOption enumerates the valid vote options for a given governance proposal. */
 export var VoteOption;
 (function (VoteOption) {
@@ -225,10 +224,9 @@ export const WeightedVoteOption = {
             typeUrl: "/cosmos.gov.v1.WeightedVoteOption",
             value: WeightedVoteOption.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(WeightedVoteOption.typeUrl, WeightedVoteOption);
-GlobalDecoderRegistry.registerAminoProtoMapping(WeightedVoteOption.aminoType, WeightedVoteOption.typeUrl);
 function createBaseDeposit() {
     return {
         proposalId: BigInt(0),
@@ -330,10 +328,11 @@ export const Deposit = {
             typeUrl: "/cosmos.gov.v1.Deposit",
             value: Deposit.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Deposit.typeUrl, Deposit);
-GlobalDecoderRegistry.registerAminoProtoMapping(Deposit.aminoType, Deposit.typeUrl);
 function createBaseProposal() {
     return {
         id: BigInt(0),
@@ -582,10 +581,12 @@ export const Proposal = {
             typeUrl: "/cosmos.gov.v1.Proposal",
             value: Proposal.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TallyResult.registerTypeUrl();
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Proposal.typeUrl, Proposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(Proposal.aminoType, Proposal.typeUrl);
 function createBaseTallyResult() {
     return {
         yesCount: "",
@@ -696,10 +697,9 @@ export const TallyResult = {
             typeUrl: "/cosmos.gov.v1.TallyResult",
             value: TallyResult.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TallyResult.typeUrl, TallyResult);
-GlobalDecoderRegistry.registerAminoProtoMapping(TallyResult.aminoType, TallyResult.typeUrl);
 function createBaseVote() {
     return {
         proposalId: BigInt(0),
@@ -813,10 +813,11 @@ export const Vote = {
             typeUrl: "/cosmos.gov.v1.Vote",
             value: Vote.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        WeightedVoteOption.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Vote.typeUrl, Vote);
-GlobalDecoderRegistry.registerAminoProtoMapping(Vote.aminoType, Vote.typeUrl);
 function createBaseDepositParams() {
     return {
         minDeposit: [],
@@ -906,10 +907,11 @@ export const DepositParams = {
             typeUrl: "/cosmos.gov.v1.DepositParams",
             value: DepositParams.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(DepositParams.typeUrl, DepositParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(DepositParams.aminoType, DepositParams.typeUrl);
 function createBaseVotingParams() {
     return {
         votingPeriod: undefined
@@ -984,10 +986,9 @@ export const VotingParams = {
             typeUrl: "/cosmos.gov.v1.VotingParams",
             value: VotingParams.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(VotingParams.typeUrl, VotingParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(VotingParams.aminoType, VotingParams.typeUrl);
 function createBaseTallyParams() {
     return {
         quorum: "",
@@ -1086,10 +1087,9 @@ export const TallyParams = {
             typeUrl: "/cosmos.gov.v1.TallyParams",
             value: TallyParams.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TallyParams.typeUrl, TallyParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(TallyParams.aminoType, TallyParams.typeUrl);
 function createBaseParams() {
     return {
         minDeposit: [],
@@ -1350,7 +1350,8 @@ export const Params = {
             typeUrl: "/cosmos.gov.v1.Params",
             value: Params.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

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

@@ -2,7 +2,6 @@ import { Proposal, Vote, VotingParams, DepositParams, TallyParams, Params, Depos
 import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { isSet } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryConstitutionRequest() {
     return {};
 }
@@ -64,10 +63,9 @@ export const QueryConstitutionRequest = {
             typeUrl: "/cosmos.gov.v1.QueryConstitutionRequest",
             value: QueryConstitutionRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryConstitutionRequest.typeUrl, QueryConstitutionRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryConstitutionRequest.aminoType, QueryConstitutionRequest.typeUrl);
 function createBaseQueryConstitutionResponse() {
     return {
         constitution: ""
@@ -142,10 +140,9 @@ export const QueryConstitutionResponse = {
             typeUrl: "/cosmos.gov.v1.QueryConstitutionResponse",
             value: QueryConstitutionResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryConstitutionResponse.typeUrl, QueryConstitutionResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryConstitutionResponse.aminoType, QueryConstitutionResponse.typeUrl);
 function createBaseQueryProposalRequest() {
     return {
         proposalId: BigInt(0)
@@ -220,10 +217,9 @@ export const QueryProposalRequest = {
             typeUrl: "/cosmos.gov.v1.QueryProposalRequest",
             value: QueryProposalRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryProposalRequest.typeUrl, QueryProposalRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalRequest.aminoType, QueryProposalRequest.typeUrl);
 function createBaseQueryProposalResponse() {
     return {
         proposal: undefined
@@ -298,10 +294,11 @@ export const QueryProposalResponse = {
             typeUrl: "/cosmos.gov.v1.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,
@@ -412,10 +409,11 @@ export const QueryProposalsRequest = {
             typeUrl: "/cosmos.gov.v1.QueryProposalsRequest",
             value: QueryProposalsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryProposalsRequest.typeUrl, QueryProposalsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryProposalsRequest.aminoType, QueryProposalsRequest.typeUrl);
 function createBaseQueryProposalsResponse() {
     return {
         proposals: [],
@@ -505,10 +503,12 @@ export const QueryProposalsResponse = {
             typeUrl: "/cosmos.gov.v1.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),
@@ -595,10 +595,9 @@ export const QueryVoteRequest = {
             typeUrl: "/cosmos.gov.v1.QueryVoteRequest",
             value: QueryVoteRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryVoteRequest.typeUrl, QueryVoteRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVoteRequest.aminoType, QueryVoteRequest.typeUrl);
 function createBaseQueryVoteResponse() {
     return {
         vote: undefined
@@ -673,10 +672,11 @@ export const QueryVoteResponse = {
             typeUrl: "/cosmos.gov.v1.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),
@@ -763,10 +763,11 @@ export const QueryVotesRequest = {
             typeUrl: "/cosmos.gov.v1.QueryVotesRequest",
             value: QueryVotesRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryVotesRequest.typeUrl, QueryVotesRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryVotesRequest.aminoType, QueryVotesRequest.typeUrl);
 function createBaseQueryVotesResponse() {
     return {
         votes: [],
@@ -856,10 +857,12 @@ export const QueryVotesResponse = {
             typeUrl: "/cosmos.gov.v1.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: ""
@@ -934,10 +937,9 @@ export const QueryParamsRequest = {
             typeUrl: "/cosmos.gov.v1.QueryParamsRequest",
             value: QueryParamsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsRequest.aminoType, QueryParamsRequest.typeUrl);
 function createBaseQueryParamsResponse() {
     return {
         votingParams: undefined,
@@ -1048,10 +1050,14 @@ export const QueryParamsResponse = {
             typeUrl: "/cosmos.gov.v1.QueryParamsResponse",
             value: QueryParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        VotingParams.registerTypeUrl();
+        DepositParams.registerTypeUrl();
+        TallyParams.registerTypeUrl();
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryParamsResponse.aminoType, QueryParamsResponse.typeUrl);
 function createBaseQueryDepositRequest() {
     return {
         proposalId: BigInt(0),
@@ -1138,10 +1144,9 @@ export const QueryDepositRequest = {
             typeUrl: "/cosmos.gov.v1.QueryDepositRequest",
             value: QueryDepositRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryDepositRequest.typeUrl, QueryDepositRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositRequest.aminoType, QueryDepositRequest.typeUrl);
 function createBaseQueryDepositResponse() {
     return {
         deposit: undefined
@@ -1216,10 +1221,11 @@ export const QueryDepositResponse = {
             typeUrl: "/cosmos.gov.v1.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),
@@ -1306,10 +1312,11 @@ export const QueryDepositsRequest = {
             typeUrl: "/cosmos.gov.v1.QueryDepositsRequest",
             value: QueryDepositsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryDepositsRequest.typeUrl, QueryDepositsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryDepositsRequest.aminoType, QueryDepositsRequest.typeUrl);
 function createBaseQueryDepositsResponse() {
     return {
         deposits: [],
@@ -1399,10 +1406,12 @@ export const QueryDepositsResponse = {
             typeUrl: "/cosmos.gov.v1.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)
@@ -1477,10 +1486,9 @@ export const QueryTallyResultRequest = {
             typeUrl: "/cosmos.gov.v1.QueryTallyResultRequest",
             value: QueryTallyResultRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryTallyResultRequest.typeUrl, QueryTallyResultRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryTallyResultRequest.aminoType, QueryTallyResultRequest.typeUrl);
 function createBaseQueryTallyResultResponse() {
     return {
         tally: undefined
@@ -1555,7 +1563,8 @@ export const QueryTallyResultResponse = {
             typeUrl: "/cosmos.gov.v1.QueryTallyResultResponse",
             value: QueryTallyResultResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TallyResult.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryTallyResultResponse.typeUrl, QueryTallyResultResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(QueryTallyResultResponse.aminoType, QueryTallyResultResponse.typeUrl);

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

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