@xpla/xplajs 1.7.0-beta.8 → 1.7.0

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

@@ -1,2 +1,136 @@
 import { MsgCreateValidator, MsgEditValidator, MsgDelegate, MsgBeginRedelegate, MsgUndelegate, MsgCancelUnbondingDelegation, MsgUpdateParams } from "./tx";
 export const registry = [["/cosmos.staking.v1beta1.MsgCreateValidator", MsgCreateValidator], ["/cosmos.staking.v1beta1.MsgEditValidator", MsgEditValidator], ["/cosmos.staking.v1beta1.MsgDelegate", MsgDelegate], ["/cosmos.staking.v1beta1.MsgBeginRedelegate", MsgBeginRedelegate], ["/cosmos.staking.v1beta1.MsgUndelegate", MsgUndelegate], ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", MsgCancelUnbondingDelegation], ["/cosmos.staking.v1beta1.MsgUpdateParams", MsgUpdateParams]];
+export const MessageComposer = {
+    encoded: {
+        createValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator",
+                value: MsgCreateValidator.encode(value).finish()
+            };
+        },
+        editValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgEditValidator",
+                value: MsgEditValidator.encode(value).finish()
+            };
+        },
+        delegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+                value: MsgDelegate.encode(value).finish()
+            };
+        },
+        beginRedelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+                value: MsgBeginRedelegate.encode(value).finish()
+            };
+        },
+        undelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+                value: MsgUndelegate.encode(value).finish()
+            };
+        },
+        cancelUnbondingDelegation(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation",
+                value: MsgCancelUnbondingDelegation.encode(value).finish()
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUpdateParams",
+                value: MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        createValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator",
+                value
+            };
+        },
+        editValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgEditValidator",
+                value
+            };
+        },
+        delegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+                value
+            };
+        },
+        beginRedelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+                value
+            };
+        },
+        undelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+                value
+            };
+        },
+        cancelUnbondingDelegation(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation",
+                value
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        createValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator",
+                value: MsgCreateValidator.fromPartial(value)
+            };
+        },
+        editValidator(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgEditValidator",
+                value: MsgEditValidator.fromPartial(value)
+            };
+        },
+        delegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+                value: MsgDelegate.fromPartial(value)
+            };
+        },
+        beginRedelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+                value: MsgBeginRedelegate.fromPartial(value)
+            };
+        },
+        undelegate(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+                value: MsgUndelegate.fromPartial(value)
+            };
+        },
+        cancelUnbondingDelegation(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation",
+                value: MsgCancelUnbondingDelegation.fromPartial(value)
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/cosmos.staking.v1beta1.MsgUpdateParams",
+                value: MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

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

@@ -5,41 +5,48 @@ export const createCreateValidator = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateValidator.typeUrl,
     encoders: toEncoders(MsgCreateValidator),
-    converters: toConverters(MsgCreateValidator)
+    converters: toConverters(MsgCreateValidator),
+    deps: [MsgCreateValidator]
 });
 export const createEditValidator = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgEditValidator.typeUrl,
     encoders: toEncoders(MsgEditValidator),
-    converters: toConverters(MsgEditValidator)
+    converters: toConverters(MsgEditValidator),
+    deps: [MsgEditValidator]
 });
 export const createDelegate = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgDelegate.typeUrl,
     encoders: toEncoders(MsgDelegate),
-    converters: toConverters(MsgDelegate)
+    converters: toConverters(MsgDelegate),
+    deps: [MsgDelegate]
 });
 export const createBeginRedelegate = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBeginRedelegate.typeUrl,
     encoders: toEncoders(MsgBeginRedelegate),
-    converters: toConverters(MsgBeginRedelegate)
+    converters: toConverters(MsgBeginRedelegate),
+    deps: [MsgBeginRedelegate]
 });
 export const createUndelegate = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUndelegate.typeUrl,
     encoders: toEncoders(MsgUndelegate),
-    converters: toConverters(MsgUndelegate)
+    converters: toConverters(MsgUndelegate),
+    deps: [MsgUndelegate]
 });
 export const createCancelUnbondingDelegation = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCancelUnbondingDelegation.typeUrl,
     encoders: toEncoders(MsgCancelUnbondingDelegation),
-    converters: toConverters(MsgCancelUnbondingDelegation)
+    converters: toConverters(MsgCancelUnbondingDelegation),
+    deps: [MsgCancelUnbondingDelegation]
 });
 export const createUpdateParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });

package/esm/cosmos/tx/config/v1/config.js

@@ -1,5 +1,4 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseConfig() {
     return {
         skipAnteHandler: false,
@@ -86,7 +85,6 @@ export const Config = {
             typeUrl: "/cosmos.tx.config.v1.Config",
             value: Config.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Config.typeUrl, Config);
-GlobalDecoderRegistry.registerAminoProtoMapping(Config.aminoType, Config.typeUrl);

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

@@ -2,7 +2,6 @@ import { CompactBitArray } from "../../../crypto/multisig/v1beta1/multisig";
 import { Any } from "../../../../google/protobuf/any";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 /**
  * SignMode represents a signing mode with its own security guarantees.
  *
@@ -184,10 +183,11 @@ export const SignatureDescriptors = {
             typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptors",
             value: SignatureDescriptors.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptors.typeUrl, SignatureDescriptors);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptors.aminoType, SignatureDescriptors.typeUrl);
 function createBaseSignatureDescriptor() {
     return {
         publicKey: undefined,
@@ -286,10 +286,11 @@ export const SignatureDescriptor = {
             typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptor",
             value: SignatureDescriptor.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor_Data.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor.typeUrl, SignatureDescriptor);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor.aminoType, SignatureDescriptor.typeUrl);
 function createBaseSignatureDescriptor_Data() {
     return {
         single: undefined,
@@ -376,10 +377,12 @@ export const SignatureDescriptor_Data = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Data",
             value: SignatureDescriptor_Data.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        SignatureDescriptor_Data_Single.registerTypeUrl();
+        SignatureDescriptor_Data_Multi.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data.typeUrl, SignatureDescriptor_Data);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data.aminoType, SignatureDescriptor_Data.typeUrl);
 function createBaseSignatureDescriptor_Data_Single() {
     return {
         mode: 0,
@@ -466,10 +469,9 @@ export const SignatureDescriptor_Data_Single = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Single",
             value: SignatureDescriptor_Data_Single.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data_Single.typeUrl, SignatureDescriptor_Data_Single);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data_Single.aminoType, SignatureDescriptor_Data_Single.typeUrl);
 function createBaseSignatureDescriptor_Data_Multi() {
     return {
         bitarray: undefined,
@@ -559,7 +561,9 @@ export const SignatureDescriptor_Data_Multi = {
             typeUrl: "/cosmos.tx.signing.v1beta1.Multi",
             value: SignatureDescriptor_Data_Multi.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CompactBitArray.registerTypeUrl();
+        SignatureDescriptor_Data.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SignatureDescriptor_Data_Multi.typeUrl, SignatureDescriptor_Data_Multi);
-GlobalDecoderRegistry.registerAminoProtoMapping(SignatureDescriptor_Data_Multi.aminoType, SignatureDescriptor_Data_Multi.typeUrl);

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

@@ -5,7 +5,6 @@ import { BlockID } from "../../../tendermint/types/types";
 import { Block } from "../../../tendermint/types/block";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 /** OrderBy defines the sorting order */
 export var OrderBy;
 (function (OrderBy) {
@@ -249,10 +248,11 @@ export const GetTxsEventRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxsEventRequest",
             value: GetTxsEventRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxsEventRequest.typeUrl, GetTxsEventRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxsEventRequest.aminoType, GetTxsEventRequest.typeUrl);
 function createBaseGetTxsEventResponse() {
     return {
         txs: [],
@@ -369,10 +369,13 @@ export const GetTxsEventResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxsEventResponse",
             value: GetTxsEventResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        TxResponse.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxsEventResponse.typeUrl, GetTxsEventResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxsEventResponse.aminoType, GetTxsEventResponse.typeUrl);
 function createBaseBroadcastTxRequest() {
     return {
         txBytes: new Uint8Array(),
@@ -459,10 +462,9 @@ export const BroadcastTxRequest = {
             typeUrl: "/cosmos.tx.v1beta1.BroadcastTxRequest",
             value: BroadcastTxRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(BroadcastTxRequest.typeUrl, BroadcastTxRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(BroadcastTxRequest.aminoType, BroadcastTxRequest.typeUrl);
 function createBaseBroadcastTxResponse() {
     return {
         txResponse: undefined
@@ -537,10 +539,11 @@ export const BroadcastTxResponse = {
             typeUrl: "/cosmos.tx.v1beta1.BroadcastTxResponse",
             value: BroadcastTxResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        TxResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(BroadcastTxResponse.typeUrl, BroadcastTxResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(BroadcastTxResponse.aminoType, BroadcastTxResponse.typeUrl);
 function createBaseSimulateRequest() {
     return {
         tx: undefined,
@@ -627,10 +630,11 @@ export const SimulateRequest = {
             typeUrl: "/cosmos.tx.v1beta1.SimulateRequest",
             value: SimulateRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SimulateRequest.typeUrl, SimulateRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(SimulateRequest.aminoType, SimulateRequest.typeUrl);
 function createBaseSimulateResponse() {
     return {
         gasInfo: undefined,
@@ -717,10 +721,12 @@ export const SimulateResponse = {
             typeUrl: "/cosmos.tx.v1beta1.SimulateResponse",
             value: SimulateResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GasInfo.registerTypeUrl();
+        Result.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(SimulateResponse.typeUrl, SimulateResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(SimulateResponse.aminoType, SimulateResponse.typeUrl);
 function createBaseGetTxRequest() {
     return {
         hash: ""
@@ -795,10 +801,9 @@ export const GetTxRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxRequest",
             value: GetTxRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(GetTxRequest.typeUrl, GetTxRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxRequest.aminoType, GetTxRequest.typeUrl);
 function createBaseGetTxResponse() {
     return {
         tx: undefined,
@@ -885,10 +890,12 @@ export const GetTxResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetTxResponse",
             value: GetTxResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        TxResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetTxResponse.typeUrl, GetTxResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetTxResponse.aminoType, GetTxResponse.typeUrl);
 function createBaseGetBlockWithTxsRequest() {
     return {
         height: BigInt(0),
@@ -975,10 +982,11 @@ export const GetBlockWithTxsRequest = {
             typeUrl: "/cosmos.tx.v1beta1.GetBlockWithTxsRequest",
             value: GetBlockWithTxsRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        PageRequest.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetBlockWithTxsRequest.typeUrl, GetBlockWithTxsRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetBlockWithTxsRequest.aminoType, GetBlockWithTxsRequest.typeUrl);
 function createBaseGetBlockWithTxsResponse() {
     return {
         txs: [],
@@ -1092,10 +1100,14 @@ export const GetBlockWithTxsResponse = {
             typeUrl: "/cosmos.tx.v1beta1.GetBlockWithTxsResponse",
             value: GetBlockWithTxsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
+        BlockID.registerTypeUrl();
+        Block.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GetBlockWithTxsResponse.typeUrl, GetBlockWithTxsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(GetBlockWithTxsResponse.aminoType, GetBlockWithTxsResponse.typeUrl);
 function createBaseTxDecodeRequest() {
     return {
         txBytes: new Uint8Array()
@@ -1170,10 +1182,9 @@ export const TxDecodeRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeRequest",
             value: TxDecodeRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeRequest.typeUrl, TxDecodeRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeRequest.aminoType, TxDecodeRequest.typeUrl);
 function createBaseTxDecodeResponse() {
     return {
         tx: undefined
@@ -1248,10 +1259,11 @@ export const TxDecodeResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeResponse",
             value: TxDecodeResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(TxDecodeResponse.typeUrl, TxDecodeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeResponse.aminoType, TxDecodeResponse.typeUrl);
 function createBaseTxEncodeRequest() {
     return {
         tx: undefined
@@ -1326,10 +1338,11 @@ export const TxEncodeRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeRequest",
             value: TxEncodeRequest.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Tx.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(TxEncodeRequest.typeUrl, TxEncodeRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeRequest.aminoType, TxEncodeRequest.typeUrl);
 function createBaseTxEncodeResponse() {
     return {
         txBytes: new Uint8Array()
@@ -1404,10 +1417,9 @@ export const TxEncodeResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeResponse",
             value: TxEncodeResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeResponse.typeUrl, TxEncodeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeResponse.aminoType, TxEncodeResponse.typeUrl);
 function createBaseTxEncodeAminoRequest() {
     return {
         aminoJson: ""
@@ -1482,10 +1494,9 @@ export const TxEncodeAminoRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeAminoRequest",
             value: TxEncodeAminoRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeAminoRequest.typeUrl, TxEncodeAminoRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeAminoRequest.aminoType, TxEncodeAminoRequest.typeUrl);
 function createBaseTxEncodeAminoResponse() {
     return {
         aminoBinary: new Uint8Array()
@@ -1560,10 +1571,9 @@ export const TxEncodeAminoResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxEncodeAminoResponse",
             value: TxEncodeAminoResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxEncodeAminoResponse.typeUrl, TxEncodeAminoResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxEncodeAminoResponse.aminoType, TxEncodeAminoResponse.typeUrl);
 function createBaseTxDecodeAminoRequest() {
     return {
         aminoBinary: new Uint8Array()
@@ -1638,10 +1648,9 @@ export const TxDecodeAminoRequest = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeAminoRequest",
             value: TxDecodeAminoRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeAminoRequest.typeUrl, TxDecodeAminoRequest);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeAminoRequest.aminoType, TxDecodeAminoRequest.typeUrl);
 function createBaseTxDecodeAminoResponse() {
     return {
         aminoJson: ""
@@ -1716,7 +1725,6 @@ export const TxDecodeAminoResponse = {
             typeUrl: "/cosmos.tx.v1beta1.TxDecodeAminoResponse",
             value: TxDecodeAminoResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(TxDecodeAminoResponse.typeUrl, TxDecodeAminoResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(TxDecodeAminoResponse.aminoType, TxDecodeAminoResponse.typeUrl);

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

@@ -5,61 +5,70 @@ export const createGetSimulate = (clientResolver) => buildQuery({
     decode: SimulateResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "Simulate",
-    clientResolver
+    clientResolver,
+    deps: [SimulateRequest, SimulateResponse]
 });
 export const createGetGetTx = (clientResolver) => buildQuery({
     encode: GetTxRequest.encode,
     decode: GetTxResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetTx",
-    clientResolver
+    clientResolver,
+    deps: [GetTxRequest, GetTxResponse]
 });
 export const createGetBroadcastTx = (clientResolver) => buildQuery({
     encode: BroadcastTxRequest.encode,
     decode: BroadcastTxResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "BroadcastTx",
-    clientResolver
+    clientResolver,
+    deps: [BroadcastTxRequest, BroadcastTxResponse]
 });
 export const createGetGetTxsEvent = (clientResolver) => buildQuery({
     encode: GetTxsEventRequest.encode,
     decode: GetTxsEventResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetTxsEvent",
-    clientResolver
+    clientResolver,
+    deps: [GetTxsEventRequest, GetTxsEventResponse]
 });
 export const createGetGetBlockWithTxs = (clientResolver) => buildQuery({
     encode: GetBlockWithTxsRequest.encode,
     decode: GetBlockWithTxsResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "GetBlockWithTxs",
-    clientResolver
+    clientResolver,
+    deps: [GetBlockWithTxsRequest, GetBlockWithTxsResponse]
 });
 export const createGetTxDecode = (clientResolver) => buildQuery({
     encode: TxDecodeRequest.encode,
     decode: TxDecodeResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxDecode",
-    clientResolver
+    clientResolver,
+    deps: [TxDecodeRequest, TxDecodeResponse]
 });
 export const createGetTxEncode = (clientResolver) => buildQuery({
     encode: TxEncodeRequest.encode,
     decode: TxEncodeResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxEncode",
-    clientResolver
+    clientResolver,
+    deps: [TxEncodeRequest, TxEncodeResponse]
 });
 export const createGetTxEncodeAmino = (clientResolver) => buildQuery({
     encode: TxEncodeAminoRequest.encode,
     decode: TxEncodeAminoResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxEncodeAmino",
-    clientResolver
+    clientResolver,
+    deps: [TxEncodeAminoRequest, TxEncodeAminoResponse]
 });
 export const createGetTxDecodeAmino = (clientResolver) => buildQuery({
     encode: TxDecodeAminoRequest.encode,
     decode: TxDecodeAminoResponse.decode,
     service: "cosmos.tx.v1beta1.Service",
     method: "TxDecodeAmino",
-    clientResolver
+    clientResolver,
+    deps: [TxDecodeAminoRequest, TxDecodeAminoResponse]
 });