injectivejs 1.6.5 → 1.7.1

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,17 @@
 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 { 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 { SpotMarketParamUpdateProposal, BatchExchangeModificationProposal, SpotMarketLaunchProposal, PerpetualMarketLaunchProposal, BinaryOptionsMarketLaunchProposal, ExpiryFuturesMarketLaunchProposal, DerivativeMarketParamUpdateProposal, MarketForcedSettlementProposal, UpdateDenomDecimalsProposal, BinaryOptionsMarketParamUpdateProposal, TradingRewardCampaignLaunchProposal, TradingRewardCampaignUpdateProposal, TradingRewardPendingPointsUpdateProposal, FeeDiscountProposal, BatchCommunityPoolSpendProposal, AtomicMarketOrderFeeMultiplierScheduleProposal } from "../../../injective/exchange/v1beta1/proposal";
+import { SetConfigProposal, SetBatchConfigProposal } from "../../../injective/ocr/v1beta1/ocr";
+import { GrantBandOraclePrivilegeProposal, RevokeBandOraclePrivilegeProposal, GrantPriceFeederPrivilegeProposal, GrantProviderPrivilegeProposal, RevokeProviderPrivilegeProposal, RevokePriceFeederPrivilegeProposal, AuthorizeBandOracleRequestProposal, UpdateBandOracleRequestProposal, EnableBandIBCProposal, GrantStorkPublisherPrivilegeProposal, RevokeStorkPublisherPrivilegeProposal } from "../../../injective/oracle/v1beta1/proposal";
+import { BlacklistEthereumAddressesProposal, RevokeEthereumBlacklistProposal } from "../../../injective/peggy/v1/proposal";
+import { ContractRegistrationRequestProposal, BatchContractRegistrationRequestProposal, BatchContractDeregistrationProposal, ContractRegistrationRequest, BatchStoreCodeProposal } from "../../../injective/wasmx/v1/proposal";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { isSet } from "../../../helpers";
 import { GlobalDecoderRegistry } from "../../../registry";
+import { isSet } from "../../../helpers";
 function createBaseMsgSubmitProposal() {
     return {
         content: undefined,
@@ -105,10 +113,64 @@ export const MsgSubmitProposal = {
             typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
             value: MsgSubmitProposal.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CommunityPoolSpendProposal.registerTypeUrl();
+        CommunityPoolSpendProposalWithDeposit.registerTypeUrl();
+        TextProposal.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();
+        SpotMarketParamUpdateProposal.registerTypeUrl();
+        BatchExchangeModificationProposal.registerTypeUrl();
+        SpotMarketLaunchProposal.registerTypeUrl();
+        PerpetualMarketLaunchProposal.registerTypeUrl();
+        BinaryOptionsMarketLaunchProposal.registerTypeUrl();
+        ExpiryFuturesMarketLaunchProposal.registerTypeUrl();
+        DerivativeMarketParamUpdateProposal.registerTypeUrl();
+        MarketForcedSettlementProposal.registerTypeUrl();
+        UpdateDenomDecimalsProposal.registerTypeUrl();
+        BinaryOptionsMarketParamUpdateProposal.registerTypeUrl();
+        TradingRewardCampaignLaunchProposal.registerTypeUrl();
+        TradingRewardCampaignUpdateProposal.registerTypeUrl();
+        TradingRewardPendingPointsUpdateProposal.registerTypeUrl();
+        FeeDiscountProposal.registerTypeUrl();
+        BatchCommunityPoolSpendProposal.registerTypeUrl();
+        AtomicMarketOrderFeeMultiplierScheduleProposal.registerTypeUrl();
+        SetConfigProposal.registerTypeUrl();
+        SetBatchConfigProposal.registerTypeUrl();
+        GrantBandOraclePrivilegeProposal.registerTypeUrl();
+        RevokeBandOraclePrivilegeProposal.registerTypeUrl();
+        GrantPriceFeederPrivilegeProposal.registerTypeUrl();
+        GrantProviderPrivilegeProposal.registerTypeUrl();
+        RevokeProviderPrivilegeProposal.registerTypeUrl();
+        RevokePriceFeederPrivilegeProposal.registerTypeUrl();
+        AuthorizeBandOracleRequestProposal.registerTypeUrl();
+        UpdateBandOracleRequestProposal.registerTypeUrl();
+        EnableBandIBCProposal.registerTypeUrl();
+        GrantStorkPublisherPrivilegeProposal.registerTypeUrl();
+        RevokeStorkPublisherPrivilegeProposal.registerTypeUrl();
+        BlacklistEthereumAddressesProposal.registerTypeUrl();
+        RevokeEthereumBlacklistProposal.registerTypeUrl();
+        ContractRegistrationRequestProposal.registerTypeUrl();
+        BatchContractRegistrationRequestProposal.registerTypeUrl();
+        BatchContractDeregistrationProposal.registerTypeUrl();
+        ContractRegistrationRequest.registerTypeUrl();
+        BatchStoreCodeProposal.registerTypeUrl();
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgSubmitProposal.typeUrl, MsgSubmitProposal);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSubmitProposal.aminoType, MsgSubmitProposal.typeUrl);
 function createBaseMsgSubmitProposalResponse() {
     return {
         proposalId: BigInt(0)
@@ -183,10 +245,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 +346,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 +410,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 +514,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 +580,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 +684,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 +750,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.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]
 });