@sparkdreamnft/sparkdreamjs 0.0.35 → 0.0.37

package/tendermint/bundle.d.ts

@@ -1,1122 +1,1122 @@
-import * as _536 from "./abci/types";
-import * as _537 from "./crypto/keys";
-import * as _538 from "./crypto/proof";
-import * as _539 from "./p2p/types";
-import * as _540 from "./types/block";
-import * as _541 from "./types/evidence";
-import * as _542 from "./types/params";
-import * as _543 from "./types/types";
-import * as _544 from "./types/validator";
-import * as _545 from "./version/types";
+import * as _538 from "./abci/types";
+import * as _539 from "./crypto/keys";
+import * as _540 from "./crypto/proof";
+import * as _541 from "./p2p/types";
+import * as _542 from "./types/block";
+import * as _543 from "./types/evidence";
+import * as _544 from "./types/params";
+import * as _545 from "./types/types";
+import * as _546 from "./types/validator";
+import * as _547 from "./version/types";
 export declare namespace tendermint {
     const abci: {
-        checkTxTypeFromJSON(object: any): _536.CheckTxType;
-        checkTxTypeToJSON(object: _536.CheckTxType): string;
-        responseOfferSnapshot_ResultFromJSON(object: any): _536.ResponseOfferSnapshot_Result;
-        responseOfferSnapshot_ResultToJSON(object: _536.ResponseOfferSnapshot_Result): string;
-        responseApplySnapshotChunk_ResultFromJSON(object: any): _536.ResponseApplySnapshotChunk_Result;
-        responseApplySnapshotChunk_ResultToJSON(object: _536.ResponseApplySnapshotChunk_Result): string;
-        responseProcessProposal_ProposalStatusFromJSON(object: any): _536.ResponseProcessProposal_ProposalStatus;
-        responseProcessProposal_ProposalStatusToJSON(object: _536.ResponseProcessProposal_ProposalStatus): string;
-        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _536.ResponseVerifyVoteExtension_VerifyStatus;
-        responseVerifyVoteExtension_VerifyStatusToJSON(object: _536.ResponseVerifyVoteExtension_VerifyStatus): string;
-        misbehaviorTypeFromJSON(object: any): _536.MisbehaviorType;
-        misbehaviorTypeToJSON(object: _536.MisbehaviorType): string;
-        CheckTxType: typeof _536.CheckTxType;
-        CheckTxTypeAmino: typeof _536.CheckTxType;
-        ResponseOfferSnapshot_Result: typeof _536.ResponseOfferSnapshot_Result;
-        ResponseOfferSnapshot_ResultAmino: typeof _536.ResponseOfferSnapshot_Result;
-        ResponseApplySnapshotChunk_Result: typeof _536.ResponseApplySnapshotChunk_Result;
-        ResponseApplySnapshotChunk_ResultAmino: typeof _536.ResponseApplySnapshotChunk_Result;
-        ResponseProcessProposal_ProposalStatus: typeof _536.ResponseProcessProposal_ProposalStatus;
-        ResponseProcessProposal_ProposalStatusAmino: typeof _536.ResponseProcessProposal_ProposalStatus;
-        ResponseVerifyVoteExtension_VerifyStatus: typeof _536.ResponseVerifyVoteExtension_VerifyStatus;
-        ResponseVerifyVoteExtension_VerifyStatusAmino: typeof _536.ResponseVerifyVoteExtension_VerifyStatus;
-        MisbehaviorType: typeof _536.MisbehaviorType;
-        MisbehaviorTypeAmino: typeof _536.MisbehaviorType;
+        checkTxTypeFromJSON(object: any): _538.CheckTxType;
+        checkTxTypeToJSON(object: _538.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _538.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _538.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _538.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _538.ResponseApplySnapshotChunk_Result): string;
+        responseProcessProposal_ProposalStatusFromJSON(object: any): _538.ResponseProcessProposal_ProposalStatus;
+        responseProcessProposal_ProposalStatusToJSON(object: _538.ResponseProcessProposal_ProposalStatus): string;
+        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _538.ResponseVerifyVoteExtension_VerifyStatus;
+        responseVerifyVoteExtension_VerifyStatusToJSON(object: _538.ResponseVerifyVoteExtension_VerifyStatus): string;
+        misbehaviorTypeFromJSON(object: any): _538.MisbehaviorType;
+        misbehaviorTypeToJSON(object: _538.MisbehaviorType): string;
+        CheckTxType: typeof _538.CheckTxType;
+        CheckTxTypeAmino: typeof _538.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _538.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultAmino: typeof _538.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _538.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultAmino: typeof _538.ResponseApplySnapshotChunk_Result;
+        ResponseProcessProposal_ProposalStatus: typeof _538.ResponseProcessProposal_ProposalStatus;
+        ResponseProcessProposal_ProposalStatusAmino: typeof _538.ResponseProcessProposal_ProposalStatus;
+        ResponseVerifyVoteExtension_VerifyStatus: typeof _538.ResponseVerifyVoteExtension_VerifyStatus;
+        ResponseVerifyVoteExtension_VerifyStatusAmino: typeof _538.ResponseVerifyVoteExtension_VerifyStatus;
+        MisbehaviorType: typeof _538.MisbehaviorType;
+        MisbehaviorTypeAmino: typeof _538.MisbehaviorType;
         Request: {
             typeUrl: string;
-            encode(message: _536.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Request;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Request>): _536.Request;
-            fromAmino(object: _536.RequestAmino): _536.Request;
-            toAmino(message: _536.Request): _536.RequestAmino;
-            fromAminoMsg(object: _536.RequestAminoMsg): _536.Request;
-            fromProtoMsg(message: _536.RequestProtoMsg): _536.Request;
-            toProto(message: _536.Request): Uint8Array;
-            toProtoMsg(message: _536.Request): _536.RequestProtoMsg;
+            encode(message: _538.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Request;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Request>): _538.Request;
+            fromAmino(object: _538.RequestAmino): _538.Request;
+            toAmino(message: _538.Request): _538.RequestAmino;
+            fromAminoMsg(object: _538.RequestAminoMsg): _538.Request;
+            fromProtoMsg(message: _538.RequestProtoMsg): _538.Request;
+            toProto(message: _538.Request): Uint8Array;
+            toProtoMsg(message: _538.Request): _538.RequestProtoMsg;
         };
         RequestEcho: {
             typeUrl: string;
-            encode(message: _536.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestEcho;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestEcho>): _536.RequestEcho;
-            fromAmino(object: _536.RequestEchoAmino): _536.RequestEcho;
-            toAmino(message: _536.RequestEcho): _536.RequestEchoAmino;
-            fromAminoMsg(object: _536.RequestEchoAminoMsg): _536.RequestEcho;
-            fromProtoMsg(message: _536.RequestEchoProtoMsg): _536.RequestEcho;
-            toProto(message: _536.RequestEcho): Uint8Array;
-            toProtoMsg(message: _536.RequestEcho): _536.RequestEchoProtoMsg;
+            encode(message: _538.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestEcho;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestEcho>): _538.RequestEcho;
+            fromAmino(object: _538.RequestEchoAmino): _538.RequestEcho;
+            toAmino(message: _538.RequestEcho): _538.RequestEchoAmino;
+            fromAminoMsg(object: _538.RequestEchoAminoMsg): _538.RequestEcho;
+            fromProtoMsg(message: _538.RequestEchoProtoMsg): _538.RequestEcho;
+            toProto(message: _538.RequestEcho): Uint8Array;
+            toProtoMsg(message: _538.RequestEcho): _538.RequestEchoProtoMsg;
         };
         RequestFlush: {
             typeUrl: string;
-            encode(_: _536.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestFlush;
-            fromPartial(_: import("../helpers").DeepPartial<_536.RequestFlush>): _536.RequestFlush;
-            fromAmino(_: _536.RequestFlushAmino): _536.RequestFlush;
-            toAmino(_: _536.RequestFlush): _536.RequestFlushAmino;
-            fromAminoMsg(object: _536.RequestFlushAminoMsg): _536.RequestFlush;
-            fromProtoMsg(message: _536.RequestFlushProtoMsg): _536.RequestFlush;
-            toProto(message: _536.RequestFlush): Uint8Array;
-            toProtoMsg(message: _536.RequestFlush): _536.RequestFlushProtoMsg;
+            encode(_: _538.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestFlush;
+            fromPartial(_: import("../helpers").DeepPartial<_538.RequestFlush>): _538.RequestFlush;
+            fromAmino(_: _538.RequestFlushAmino): _538.RequestFlush;
+            toAmino(_: _538.RequestFlush): _538.RequestFlushAmino;
+            fromAminoMsg(object: _538.RequestFlushAminoMsg): _538.RequestFlush;
+            fromProtoMsg(message: _538.RequestFlushProtoMsg): _538.RequestFlush;
+            toProto(message: _538.RequestFlush): Uint8Array;
+            toProtoMsg(message: _538.RequestFlush): _538.RequestFlushProtoMsg;
         };
         RequestInfo: {
             typeUrl: string;
-            encode(message: _536.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestInfo>): _536.RequestInfo;
-            fromAmino(object: _536.RequestInfoAmino): _536.RequestInfo;
-            toAmino(message: _536.RequestInfo): _536.RequestInfoAmino;
-            fromAminoMsg(object: _536.RequestInfoAminoMsg): _536.RequestInfo;
-            fromProtoMsg(message: _536.RequestInfoProtoMsg): _536.RequestInfo;
-            toProto(message: _536.RequestInfo): Uint8Array;
-            toProtoMsg(message: _536.RequestInfo): _536.RequestInfoProtoMsg;
+            encode(message: _538.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestInfo>): _538.RequestInfo;
+            fromAmino(object: _538.RequestInfoAmino): _538.RequestInfo;
+            toAmino(message: _538.RequestInfo): _538.RequestInfoAmino;
+            fromAminoMsg(object: _538.RequestInfoAminoMsg): _538.RequestInfo;
+            fromProtoMsg(message: _538.RequestInfoProtoMsg): _538.RequestInfo;
+            toProto(message: _538.RequestInfo): Uint8Array;
+            toProtoMsg(message: _538.RequestInfo): _538.RequestInfoProtoMsg;
         };
         RequestInitChain: {
             typeUrl: string;
-            encode(message: _536.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestInitChain;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestInitChain>): _536.RequestInitChain;
-            fromAmino(object: _536.RequestInitChainAmino): _536.RequestInitChain;
-            toAmino(message: _536.RequestInitChain): _536.RequestInitChainAmino;
-            fromAminoMsg(object: _536.RequestInitChainAminoMsg): _536.RequestInitChain;
-            fromProtoMsg(message: _536.RequestInitChainProtoMsg): _536.RequestInitChain;
-            toProto(message: _536.RequestInitChain): Uint8Array;
-            toProtoMsg(message: _536.RequestInitChain): _536.RequestInitChainProtoMsg;
+            encode(message: _538.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestInitChain;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestInitChain>): _538.RequestInitChain;
+            fromAmino(object: _538.RequestInitChainAmino): _538.RequestInitChain;
+            toAmino(message: _538.RequestInitChain): _538.RequestInitChainAmino;
+            fromAminoMsg(object: _538.RequestInitChainAminoMsg): _538.RequestInitChain;
+            fromProtoMsg(message: _538.RequestInitChainProtoMsg): _538.RequestInitChain;
+            toProto(message: _538.RequestInitChain): Uint8Array;
+            toProtoMsg(message: _538.RequestInitChain): _538.RequestInitChainProtoMsg;
         };
         RequestQuery: {
             typeUrl: string;
-            encode(message: _536.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestQuery;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestQuery>): _536.RequestQuery;
-            fromAmino(object: _536.RequestQueryAmino): _536.RequestQuery;
-            toAmino(message: _536.RequestQuery): _536.RequestQueryAmino;
-            fromAminoMsg(object: _536.RequestQueryAminoMsg): _536.RequestQuery;
-            fromProtoMsg(message: _536.RequestQueryProtoMsg): _536.RequestQuery;
-            toProto(message: _536.RequestQuery): Uint8Array;
-            toProtoMsg(message: _536.RequestQuery): _536.RequestQueryProtoMsg;
+            encode(message: _538.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestQuery;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestQuery>): _538.RequestQuery;
+            fromAmino(object: _538.RequestQueryAmino): _538.RequestQuery;
+            toAmino(message: _538.RequestQuery): _538.RequestQueryAmino;
+            fromAminoMsg(object: _538.RequestQueryAminoMsg): _538.RequestQuery;
+            fromProtoMsg(message: _538.RequestQueryProtoMsg): _538.RequestQuery;
+            toProto(message: _538.RequestQuery): Uint8Array;
+            toProtoMsg(message: _538.RequestQuery): _538.RequestQueryProtoMsg;
         };
         RequestCheckTx: {
             typeUrl: string;
-            encode(message: _536.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestCheckTx;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestCheckTx>): _536.RequestCheckTx;
-            fromAmino(object: _536.RequestCheckTxAmino): _536.RequestCheckTx;
-            toAmino(message: _536.RequestCheckTx): _536.RequestCheckTxAmino;
-            fromAminoMsg(object: _536.RequestCheckTxAminoMsg): _536.RequestCheckTx;
-            fromProtoMsg(message: _536.RequestCheckTxProtoMsg): _536.RequestCheckTx;
-            toProto(message: _536.RequestCheckTx): Uint8Array;
-            toProtoMsg(message: _536.RequestCheckTx): _536.RequestCheckTxProtoMsg;
+            encode(message: _538.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestCheckTx;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestCheckTx>): _538.RequestCheckTx;
+            fromAmino(object: _538.RequestCheckTxAmino): _538.RequestCheckTx;
+            toAmino(message: _538.RequestCheckTx): _538.RequestCheckTxAmino;
+            fromAminoMsg(object: _538.RequestCheckTxAminoMsg): _538.RequestCheckTx;
+            fromProtoMsg(message: _538.RequestCheckTxProtoMsg): _538.RequestCheckTx;
+            toProto(message: _538.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _538.RequestCheckTx): _538.RequestCheckTxProtoMsg;
         };
         RequestCommit: {
             typeUrl: string;
-            encode(_: _536.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestCommit;
-            fromPartial(_: import("../helpers").DeepPartial<_536.RequestCommit>): _536.RequestCommit;
-            fromAmino(_: _536.RequestCommitAmino): _536.RequestCommit;
-            toAmino(_: _536.RequestCommit): _536.RequestCommitAmino;
-            fromAminoMsg(object: _536.RequestCommitAminoMsg): _536.RequestCommit;
-            fromProtoMsg(message: _536.RequestCommitProtoMsg): _536.RequestCommit;
-            toProto(message: _536.RequestCommit): Uint8Array;
-            toProtoMsg(message: _536.RequestCommit): _536.RequestCommitProtoMsg;
+            encode(_: _538.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestCommit;
+            fromPartial(_: import("../helpers").DeepPartial<_538.RequestCommit>): _538.RequestCommit;
+            fromAmino(_: _538.RequestCommitAmino): _538.RequestCommit;
+            toAmino(_: _538.RequestCommit): _538.RequestCommitAmino;
+            fromAminoMsg(object: _538.RequestCommitAminoMsg): _538.RequestCommit;
+            fromProtoMsg(message: _538.RequestCommitProtoMsg): _538.RequestCommit;
+            toProto(message: _538.RequestCommit): Uint8Array;
+            toProtoMsg(message: _538.RequestCommit): _538.RequestCommitProtoMsg;
         };
         RequestListSnapshots: {
             typeUrl: string;
-            encode(_: _536.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestListSnapshots;
-            fromPartial(_: import("../helpers").DeepPartial<_536.RequestListSnapshots>): _536.RequestListSnapshots;
-            fromAmino(_: _536.RequestListSnapshotsAmino): _536.RequestListSnapshots;
-            toAmino(_: _536.RequestListSnapshots): _536.RequestListSnapshotsAmino;
-            fromAminoMsg(object: _536.RequestListSnapshotsAminoMsg): _536.RequestListSnapshots;
-            fromProtoMsg(message: _536.RequestListSnapshotsProtoMsg): _536.RequestListSnapshots;
-            toProto(message: _536.RequestListSnapshots): Uint8Array;
-            toProtoMsg(message: _536.RequestListSnapshots): _536.RequestListSnapshotsProtoMsg;
+            encode(_: _538.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestListSnapshots;
+            fromPartial(_: import("../helpers").DeepPartial<_538.RequestListSnapshots>): _538.RequestListSnapshots;
+            fromAmino(_: _538.RequestListSnapshotsAmino): _538.RequestListSnapshots;
+            toAmino(_: _538.RequestListSnapshots): _538.RequestListSnapshotsAmino;
+            fromAminoMsg(object: _538.RequestListSnapshotsAminoMsg): _538.RequestListSnapshots;
+            fromProtoMsg(message: _538.RequestListSnapshotsProtoMsg): _538.RequestListSnapshots;
+            toProto(message: _538.RequestListSnapshots): Uint8Array;
+            toProtoMsg(message: _538.RequestListSnapshots): _538.RequestListSnapshotsProtoMsg;
         };
         RequestOfferSnapshot: {
             typeUrl: string;
-            encode(message: _536.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestOfferSnapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestOfferSnapshot>): _536.RequestOfferSnapshot;
-            fromAmino(object: _536.RequestOfferSnapshotAmino): _536.RequestOfferSnapshot;
-            toAmino(message: _536.RequestOfferSnapshot): _536.RequestOfferSnapshotAmino;
-            fromAminoMsg(object: _536.RequestOfferSnapshotAminoMsg): _536.RequestOfferSnapshot;
-            fromProtoMsg(message: _536.RequestOfferSnapshotProtoMsg): _536.RequestOfferSnapshot;
-            toProto(message: _536.RequestOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _536.RequestOfferSnapshot): _536.RequestOfferSnapshotProtoMsg;
+            encode(message: _538.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestOfferSnapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestOfferSnapshot>): _538.RequestOfferSnapshot;
+            fromAmino(object: _538.RequestOfferSnapshotAmino): _538.RequestOfferSnapshot;
+            toAmino(message: _538.RequestOfferSnapshot): _538.RequestOfferSnapshotAmino;
+            fromAminoMsg(object: _538.RequestOfferSnapshotAminoMsg): _538.RequestOfferSnapshot;
+            fromProtoMsg(message: _538.RequestOfferSnapshotProtoMsg): _538.RequestOfferSnapshot;
+            toProto(message: _538.RequestOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _538.RequestOfferSnapshot): _538.RequestOfferSnapshotProtoMsg;
         };
         RequestLoadSnapshotChunk: {
             typeUrl: string;
-            encode(message: _536.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestLoadSnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestLoadSnapshotChunk>): _536.RequestLoadSnapshotChunk;
-            fromAmino(object: _536.RequestLoadSnapshotChunkAmino): _536.RequestLoadSnapshotChunk;
-            toAmino(message: _536.RequestLoadSnapshotChunk): _536.RequestLoadSnapshotChunkAmino;
-            fromAminoMsg(object: _536.RequestLoadSnapshotChunkAminoMsg): _536.RequestLoadSnapshotChunk;
-            fromProtoMsg(message: _536.RequestLoadSnapshotChunkProtoMsg): _536.RequestLoadSnapshotChunk;
-            toProto(message: _536.RequestLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _536.RequestLoadSnapshotChunk): _536.RequestLoadSnapshotChunkProtoMsg;
+            encode(message: _538.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestLoadSnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestLoadSnapshotChunk>): _538.RequestLoadSnapshotChunk;
+            fromAmino(object: _538.RequestLoadSnapshotChunkAmino): _538.RequestLoadSnapshotChunk;
+            toAmino(message: _538.RequestLoadSnapshotChunk): _538.RequestLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _538.RequestLoadSnapshotChunkAminoMsg): _538.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: _538.RequestLoadSnapshotChunkProtoMsg): _538.RequestLoadSnapshotChunk;
+            toProto(message: _538.RequestLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _538.RequestLoadSnapshotChunk): _538.RequestLoadSnapshotChunkProtoMsg;
         };
         RequestApplySnapshotChunk: {
             typeUrl: string;
-            encode(message: _536.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestApplySnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestApplySnapshotChunk>): _536.RequestApplySnapshotChunk;
-            fromAmino(object: _536.RequestApplySnapshotChunkAmino): _536.RequestApplySnapshotChunk;
-            toAmino(message: _536.RequestApplySnapshotChunk): _536.RequestApplySnapshotChunkAmino;
-            fromAminoMsg(object: _536.RequestApplySnapshotChunkAminoMsg): _536.RequestApplySnapshotChunk;
-            fromProtoMsg(message: _536.RequestApplySnapshotChunkProtoMsg): _536.RequestApplySnapshotChunk;
-            toProto(message: _536.RequestApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _536.RequestApplySnapshotChunk): _536.RequestApplySnapshotChunkProtoMsg;
+            encode(message: _538.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestApplySnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestApplySnapshotChunk>): _538.RequestApplySnapshotChunk;
+            fromAmino(object: _538.RequestApplySnapshotChunkAmino): _538.RequestApplySnapshotChunk;
+            toAmino(message: _538.RequestApplySnapshotChunk): _538.RequestApplySnapshotChunkAmino;
+            fromAminoMsg(object: _538.RequestApplySnapshotChunkAminoMsg): _538.RequestApplySnapshotChunk;
+            fromProtoMsg(message: _538.RequestApplySnapshotChunkProtoMsg): _538.RequestApplySnapshotChunk;
+            toProto(message: _538.RequestApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _538.RequestApplySnapshotChunk): _538.RequestApplySnapshotChunkProtoMsg;
         };
         RequestPrepareProposal: {
             typeUrl: string;
-            encode(message: _536.RequestPrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestPrepareProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestPrepareProposal>): _536.RequestPrepareProposal;
-            fromAmino(object: _536.RequestPrepareProposalAmino): _536.RequestPrepareProposal;
-            toAmino(message: _536.RequestPrepareProposal): _536.RequestPrepareProposalAmino;
-            fromAminoMsg(object: _536.RequestPrepareProposalAminoMsg): _536.RequestPrepareProposal;
-            fromProtoMsg(message: _536.RequestPrepareProposalProtoMsg): _536.RequestPrepareProposal;
-            toProto(message: _536.RequestPrepareProposal): Uint8Array;
-            toProtoMsg(message: _536.RequestPrepareProposal): _536.RequestPrepareProposalProtoMsg;
+            encode(message: _538.RequestPrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestPrepareProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestPrepareProposal>): _538.RequestPrepareProposal;
+            fromAmino(object: _538.RequestPrepareProposalAmino): _538.RequestPrepareProposal;
+            toAmino(message: _538.RequestPrepareProposal): _538.RequestPrepareProposalAmino;
+            fromAminoMsg(object: _538.RequestPrepareProposalAminoMsg): _538.RequestPrepareProposal;
+            fromProtoMsg(message: _538.RequestPrepareProposalProtoMsg): _538.RequestPrepareProposal;
+            toProto(message: _538.RequestPrepareProposal): Uint8Array;
+            toProtoMsg(message: _538.RequestPrepareProposal): _538.RequestPrepareProposalProtoMsg;
         };
         RequestProcessProposal: {
             typeUrl: string;
-            encode(message: _536.RequestProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestProcessProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestProcessProposal>): _536.RequestProcessProposal;
-            fromAmino(object: _536.RequestProcessProposalAmino): _536.RequestProcessProposal;
-            toAmino(message: _536.RequestProcessProposal): _536.RequestProcessProposalAmino;
-            fromAminoMsg(object: _536.RequestProcessProposalAminoMsg): _536.RequestProcessProposal;
-            fromProtoMsg(message: _536.RequestProcessProposalProtoMsg): _536.RequestProcessProposal;
-            toProto(message: _536.RequestProcessProposal): Uint8Array;
-            toProtoMsg(message: _536.RequestProcessProposal): _536.RequestProcessProposalProtoMsg;
+            encode(message: _538.RequestProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestProcessProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestProcessProposal>): _538.RequestProcessProposal;
+            fromAmino(object: _538.RequestProcessProposalAmino): _538.RequestProcessProposal;
+            toAmino(message: _538.RequestProcessProposal): _538.RequestProcessProposalAmino;
+            fromAminoMsg(object: _538.RequestProcessProposalAminoMsg): _538.RequestProcessProposal;
+            fromProtoMsg(message: _538.RequestProcessProposalProtoMsg): _538.RequestProcessProposal;
+            toProto(message: _538.RequestProcessProposal): Uint8Array;
+            toProtoMsg(message: _538.RequestProcessProposal): _538.RequestProcessProposalProtoMsg;
         };
         RequestExtendVote: {
             typeUrl: string;
-            encode(message: _536.RequestExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestExtendVote;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestExtendVote>): _536.RequestExtendVote;
-            fromAmino(object: _536.RequestExtendVoteAmino): _536.RequestExtendVote;
-            toAmino(message: _536.RequestExtendVote): _536.RequestExtendVoteAmino;
-            fromAminoMsg(object: _536.RequestExtendVoteAminoMsg): _536.RequestExtendVote;
-            fromProtoMsg(message: _536.RequestExtendVoteProtoMsg): _536.RequestExtendVote;
-            toProto(message: _536.RequestExtendVote): Uint8Array;
-            toProtoMsg(message: _536.RequestExtendVote): _536.RequestExtendVoteProtoMsg;
+            encode(message: _538.RequestExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestExtendVote;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestExtendVote>): _538.RequestExtendVote;
+            fromAmino(object: _538.RequestExtendVoteAmino): _538.RequestExtendVote;
+            toAmino(message: _538.RequestExtendVote): _538.RequestExtendVoteAmino;
+            fromAminoMsg(object: _538.RequestExtendVoteAminoMsg): _538.RequestExtendVote;
+            fromProtoMsg(message: _538.RequestExtendVoteProtoMsg): _538.RequestExtendVote;
+            toProto(message: _538.RequestExtendVote): Uint8Array;
+            toProtoMsg(message: _538.RequestExtendVote): _538.RequestExtendVoteProtoMsg;
         };
         RequestVerifyVoteExtension: {
             typeUrl: string;
-            encode(message: _536.RequestVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestVerifyVoteExtension;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestVerifyVoteExtension>): _536.RequestVerifyVoteExtension;
-            fromAmino(object: _536.RequestVerifyVoteExtensionAmino): _536.RequestVerifyVoteExtension;
-            toAmino(message: _536.RequestVerifyVoteExtension): _536.RequestVerifyVoteExtensionAmino;
-            fromAminoMsg(object: _536.RequestVerifyVoteExtensionAminoMsg): _536.RequestVerifyVoteExtension;
-            fromProtoMsg(message: _536.RequestVerifyVoteExtensionProtoMsg): _536.RequestVerifyVoteExtension;
-            toProto(message: _536.RequestVerifyVoteExtension): Uint8Array;
-            toProtoMsg(message: _536.RequestVerifyVoteExtension): _536.RequestVerifyVoteExtensionProtoMsg;
+            encode(message: _538.RequestVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestVerifyVoteExtension;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestVerifyVoteExtension>): _538.RequestVerifyVoteExtension;
+            fromAmino(object: _538.RequestVerifyVoteExtensionAmino): _538.RequestVerifyVoteExtension;
+            toAmino(message: _538.RequestVerifyVoteExtension): _538.RequestVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _538.RequestVerifyVoteExtensionAminoMsg): _538.RequestVerifyVoteExtension;
+            fromProtoMsg(message: _538.RequestVerifyVoteExtensionProtoMsg): _538.RequestVerifyVoteExtension;
+            toProto(message: _538.RequestVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _538.RequestVerifyVoteExtension): _538.RequestVerifyVoteExtensionProtoMsg;
         };
         RequestFinalizeBlock: {
             typeUrl: string;
-            encode(message: _536.RequestFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestFinalizeBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_536.RequestFinalizeBlock>): _536.RequestFinalizeBlock;
-            fromAmino(object: _536.RequestFinalizeBlockAmino): _536.RequestFinalizeBlock;
-            toAmino(message: _536.RequestFinalizeBlock): _536.RequestFinalizeBlockAmino;
-            fromAminoMsg(object: _536.RequestFinalizeBlockAminoMsg): _536.RequestFinalizeBlock;
-            fromProtoMsg(message: _536.RequestFinalizeBlockProtoMsg): _536.RequestFinalizeBlock;
-            toProto(message: _536.RequestFinalizeBlock): Uint8Array;
-            toProtoMsg(message: _536.RequestFinalizeBlock): _536.RequestFinalizeBlockProtoMsg;
+            encode(message: _538.RequestFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.RequestFinalizeBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_538.RequestFinalizeBlock>): _538.RequestFinalizeBlock;
+            fromAmino(object: _538.RequestFinalizeBlockAmino): _538.RequestFinalizeBlock;
+            toAmino(message: _538.RequestFinalizeBlock): _538.RequestFinalizeBlockAmino;
+            fromAminoMsg(object: _538.RequestFinalizeBlockAminoMsg): _538.RequestFinalizeBlock;
+            fromProtoMsg(message: _538.RequestFinalizeBlockProtoMsg): _538.RequestFinalizeBlock;
+            toProto(message: _538.RequestFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _538.RequestFinalizeBlock): _538.RequestFinalizeBlockProtoMsg;
         };
         Response: {
             typeUrl: string;
-            encode(message: _536.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Response;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Response>): _536.Response;
-            fromAmino(object: _536.ResponseAmino): _536.Response;
-            toAmino(message: _536.Response): _536.ResponseAmino;
-            fromAminoMsg(object: _536.ResponseAminoMsg): _536.Response;
-            fromProtoMsg(message: _536.ResponseProtoMsg): _536.Response;
-            toProto(message: _536.Response): Uint8Array;
-            toProtoMsg(message: _536.Response): _536.ResponseProtoMsg;
+            encode(message: _538.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Response;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Response>): _538.Response;
+            fromAmino(object: _538.ResponseAmino): _538.Response;
+            toAmino(message: _538.Response): _538.ResponseAmino;
+            fromAminoMsg(object: _538.ResponseAminoMsg): _538.Response;
+            fromProtoMsg(message: _538.ResponseProtoMsg): _538.Response;
+            toProto(message: _538.Response): Uint8Array;
+            toProtoMsg(message: _538.Response): _538.ResponseProtoMsg;
         };
         ResponseException: {
             typeUrl: string;
-            encode(message: _536.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseException;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseException>): _536.ResponseException;
-            fromAmino(object: _536.ResponseExceptionAmino): _536.ResponseException;
-            toAmino(message: _536.ResponseException): _536.ResponseExceptionAmino;
-            fromAminoMsg(object: _536.ResponseExceptionAminoMsg): _536.ResponseException;
-            fromProtoMsg(message: _536.ResponseExceptionProtoMsg): _536.ResponseException;
-            toProto(message: _536.ResponseException): Uint8Array;
-            toProtoMsg(message: _536.ResponseException): _536.ResponseExceptionProtoMsg;
+            encode(message: _538.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseException;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseException>): _538.ResponseException;
+            fromAmino(object: _538.ResponseExceptionAmino): _538.ResponseException;
+            toAmino(message: _538.ResponseException): _538.ResponseExceptionAmino;
+            fromAminoMsg(object: _538.ResponseExceptionAminoMsg): _538.ResponseException;
+            fromProtoMsg(message: _538.ResponseExceptionProtoMsg): _538.ResponseException;
+            toProto(message: _538.ResponseException): Uint8Array;
+            toProtoMsg(message: _538.ResponseException): _538.ResponseExceptionProtoMsg;
         };
         ResponseEcho: {
             typeUrl: string;
-            encode(message: _536.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseEcho;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseEcho>): _536.ResponseEcho;
-            fromAmino(object: _536.ResponseEchoAmino): _536.ResponseEcho;
-            toAmino(message: _536.ResponseEcho): _536.ResponseEchoAmino;
-            fromAminoMsg(object: _536.ResponseEchoAminoMsg): _536.ResponseEcho;
-            fromProtoMsg(message: _536.ResponseEchoProtoMsg): _536.ResponseEcho;
-            toProto(message: _536.ResponseEcho): Uint8Array;
-            toProtoMsg(message: _536.ResponseEcho): _536.ResponseEchoProtoMsg;
+            encode(message: _538.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseEcho;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseEcho>): _538.ResponseEcho;
+            fromAmino(object: _538.ResponseEchoAmino): _538.ResponseEcho;
+            toAmino(message: _538.ResponseEcho): _538.ResponseEchoAmino;
+            fromAminoMsg(object: _538.ResponseEchoAminoMsg): _538.ResponseEcho;
+            fromProtoMsg(message: _538.ResponseEchoProtoMsg): _538.ResponseEcho;
+            toProto(message: _538.ResponseEcho): Uint8Array;
+            toProtoMsg(message: _538.ResponseEcho): _538.ResponseEchoProtoMsg;
         };
         ResponseFlush: {
             typeUrl: string;
-            encode(_: _536.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseFlush;
-            fromPartial(_: import("../helpers").DeepPartial<_536.ResponseFlush>): _536.ResponseFlush;
-            fromAmino(_: _536.ResponseFlushAmino): _536.ResponseFlush;
-            toAmino(_: _536.ResponseFlush): _536.ResponseFlushAmino;
-            fromAminoMsg(object: _536.ResponseFlushAminoMsg): _536.ResponseFlush;
-            fromProtoMsg(message: _536.ResponseFlushProtoMsg): _536.ResponseFlush;
-            toProto(message: _536.ResponseFlush): Uint8Array;
-            toProtoMsg(message: _536.ResponseFlush): _536.ResponseFlushProtoMsg;
+            encode(_: _538.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseFlush;
+            fromPartial(_: import("../helpers").DeepPartial<_538.ResponseFlush>): _538.ResponseFlush;
+            fromAmino(_: _538.ResponseFlushAmino): _538.ResponseFlush;
+            toAmino(_: _538.ResponseFlush): _538.ResponseFlushAmino;
+            fromAminoMsg(object: _538.ResponseFlushAminoMsg): _538.ResponseFlush;
+            fromProtoMsg(message: _538.ResponseFlushProtoMsg): _538.ResponseFlush;
+            toProto(message: _538.ResponseFlush): Uint8Array;
+            toProtoMsg(message: _538.ResponseFlush): _538.ResponseFlushProtoMsg;
         };
         ResponseInfo: {
             typeUrl: string;
-            encode(message: _536.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseInfo>): _536.ResponseInfo;
-            fromAmino(object: _536.ResponseInfoAmino): _536.ResponseInfo;
-            toAmino(message: _536.ResponseInfo): _536.ResponseInfoAmino;
-            fromAminoMsg(object: _536.ResponseInfoAminoMsg): _536.ResponseInfo;
-            fromProtoMsg(message: _536.ResponseInfoProtoMsg): _536.ResponseInfo;
-            toProto(message: _536.ResponseInfo): Uint8Array;
-            toProtoMsg(message: _536.ResponseInfo): _536.ResponseInfoProtoMsg;
+            encode(message: _538.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseInfo>): _538.ResponseInfo;
+            fromAmino(object: _538.ResponseInfoAmino): _538.ResponseInfo;
+            toAmino(message: _538.ResponseInfo): _538.ResponseInfoAmino;
+            fromAminoMsg(object: _538.ResponseInfoAminoMsg): _538.ResponseInfo;
+            fromProtoMsg(message: _538.ResponseInfoProtoMsg): _538.ResponseInfo;
+            toProto(message: _538.ResponseInfo): Uint8Array;
+            toProtoMsg(message: _538.ResponseInfo): _538.ResponseInfoProtoMsg;
         };
         ResponseInitChain: {
             typeUrl: string;
-            encode(message: _536.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseInitChain;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseInitChain>): _536.ResponseInitChain;
-            fromAmino(object: _536.ResponseInitChainAmino): _536.ResponseInitChain;
-            toAmino(message: _536.ResponseInitChain): _536.ResponseInitChainAmino;
-            fromAminoMsg(object: _536.ResponseInitChainAminoMsg): _536.ResponseInitChain;
-            fromProtoMsg(message: _536.ResponseInitChainProtoMsg): _536.ResponseInitChain;
-            toProto(message: _536.ResponseInitChain): Uint8Array;
-            toProtoMsg(message: _536.ResponseInitChain): _536.ResponseInitChainProtoMsg;
+            encode(message: _538.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseInitChain;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseInitChain>): _538.ResponseInitChain;
+            fromAmino(object: _538.ResponseInitChainAmino): _538.ResponseInitChain;
+            toAmino(message: _538.ResponseInitChain): _538.ResponseInitChainAmino;
+            fromAminoMsg(object: _538.ResponseInitChainAminoMsg): _538.ResponseInitChain;
+            fromProtoMsg(message: _538.ResponseInitChainProtoMsg): _538.ResponseInitChain;
+            toProto(message: _538.ResponseInitChain): Uint8Array;
+            toProtoMsg(message: _538.ResponseInitChain): _538.ResponseInitChainProtoMsg;
         };
         ResponseQuery: {
             typeUrl: string;
-            encode(message: _536.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseQuery;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseQuery>): _536.ResponseQuery;
-            fromAmino(object: _536.ResponseQueryAmino): _536.ResponseQuery;
-            toAmino(message: _536.ResponseQuery): _536.ResponseQueryAmino;
-            fromAminoMsg(object: _536.ResponseQueryAminoMsg): _536.ResponseQuery;
-            fromProtoMsg(message: _536.ResponseQueryProtoMsg): _536.ResponseQuery;
-            toProto(message: _536.ResponseQuery): Uint8Array;
-            toProtoMsg(message: _536.ResponseQuery): _536.ResponseQueryProtoMsg;
+            encode(message: _538.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseQuery;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseQuery>): _538.ResponseQuery;
+            fromAmino(object: _538.ResponseQueryAmino): _538.ResponseQuery;
+            toAmino(message: _538.ResponseQuery): _538.ResponseQueryAmino;
+            fromAminoMsg(object: _538.ResponseQueryAminoMsg): _538.ResponseQuery;
+            fromProtoMsg(message: _538.ResponseQueryProtoMsg): _538.ResponseQuery;
+            toProto(message: _538.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _538.ResponseQuery): _538.ResponseQueryProtoMsg;
         };
         ResponseCheckTx: {
             typeUrl: string;
-            encode(message: _536.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseCheckTx;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseCheckTx>): _536.ResponseCheckTx;
-            fromAmino(object: _536.ResponseCheckTxAmino): _536.ResponseCheckTx;
-            toAmino(message: _536.ResponseCheckTx): _536.ResponseCheckTxAmino;
-            fromAminoMsg(object: _536.ResponseCheckTxAminoMsg): _536.ResponseCheckTx;
-            fromProtoMsg(message: _536.ResponseCheckTxProtoMsg): _536.ResponseCheckTx;
-            toProto(message: _536.ResponseCheckTx): Uint8Array;
-            toProtoMsg(message: _536.ResponseCheckTx): _536.ResponseCheckTxProtoMsg;
+            encode(message: _538.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseCheckTx;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseCheckTx>): _538.ResponseCheckTx;
+            fromAmino(object: _538.ResponseCheckTxAmino): _538.ResponseCheckTx;
+            toAmino(message: _538.ResponseCheckTx): _538.ResponseCheckTxAmino;
+            fromAminoMsg(object: _538.ResponseCheckTxAminoMsg): _538.ResponseCheckTx;
+            fromProtoMsg(message: _538.ResponseCheckTxProtoMsg): _538.ResponseCheckTx;
+            toProto(message: _538.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _538.ResponseCheckTx): _538.ResponseCheckTxProtoMsg;
         };
         ResponseCommit: {
             typeUrl: string;
-            encode(message: _536.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseCommit;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseCommit>): _536.ResponseCommit;
-            fromAmino(object: _536.ResponseCommitAmino): _536.ResponseCommit;
-            toAmino(message: _536.ResponseCommit): _536.ResponseCommitAmino;
-            fromAminoMsg(object: _536.ResponseCommitAminoMsg): _536.ResponseCommit;
-            fromProtoMsg(message: _536.ResponseCommitProtoMsg): _536.ResponseCommit;
-            toProto(message: _536.ResponseCommit): Uint8Array;
-            toProtoMsg(message: _536.ResponseCommit): _536.ResponseCommitProtoMsg;
+            encode(message: _538.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseCommit;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseCommit>): _538.ResponseCommit;
+            fromAmino(object: _538.ResponseCommitAmino): _538.ResponseCommit;
+            toAmino(message: _538.ResponseCommit): _538.ResponseCommitAmino;
+            fromAminoMsg(object: _538.ResponseCommitAminoMsg): _538.ResponseCommit;
+            fromProtoMsg(message: _538.ResponseCommitProtoMsg): _538.ResponseCommit;
+            toProto(message: _538.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _538.ResponseCommit): _538.ResponseCommitProtoMsg;
         };
         ResponseListSnapshots: {
             typeUrl: string;
-            encode(message: _536.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseListSnapshots;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseListSnapshots>): _536.ResponseListSnapshots;
-            fromAmino(object: _536.ResponseListSnapshotsAmino): _536.ResponseListSnapshots;
-            toAmino(message: _536.ResponseListSnapshots): _536.ResponseListSnapshotsAmino;
-            fromAminoMsg(object: _536.ResponseListSnapshotsAminoMsg): _536.ResponseListSnapshots;
-            fromProtoMsg(message: _536.ResponseListSnapshotsProtoMsg): _536.ResponseListSnapshots;
-            toProto(message: _536.ResponseListSnapshots): Uint8Array;
-            toProtoMsg(message: _536.ResponseListSnapshots): _536.ResponseListSnapshotsProtoMsg;
+            encode(message: _538.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseListSnapshots;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseListSnapshots>): _538.ResponseListSnapshots;
+            fromAmino(object: _538.ResponseListSnapshotsAmino): _538.ResponseListSnapshots;
+            toAmino(message: _538.ResponseListSnapshots): _538.ResponseListSnapshotsAmino;
+            fromAminoMsg(object: _538.ResponseListSnapshotsAminoMsg): _538.ResponseListSnapshots;
+            fromProtoMsg(message: _538.ResponseListSnapshotsProtoMsg): _538.ResponseListSnapshots;
+            toProto(message: _538.ResponseListSnapshots): Uint8Array;
+            toProtoMsg(message: _538.ResponseListSnapshots): _538.ResponseListSnapshotsProtoMsg;
         };
         ResponseOfferSnapshot: {
             typeUrl: string;
-            encode(message: _536.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseOfferSnapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseOfferSnapshot>): _536.ResponseOfferSnapshot;
-            fromAmino(object: _536.ResponseOfferSnapshotAmino): _536.ResponseOfferSnapshot;
-            toAmino(message: _536.ResponseOfferSnapshot): _536.ResponseOfferSnapshotAmino;
-            fromAminoMsg(object: _536.ResponseOfferSnapshotAminoMsg): _536.ResponseOfferSnapshot;
-            fromProtoMsg(message: _536.ResponseOfferSnapshotProtoMsg): _536.ResponseOfferSnapshot;
-            toProto(message: _536.ResponseOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _536.ResponseOfferSnapshot): _536.ResponseOfferSnapshotProtoMsg;
+            encode(message: _538.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseOfferSnapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseOfferSnapshot>): _538.ResponseOfferSnapshot;
+            fromAmino(object: _538.ResponseOfferSnapshotAmino): _538.ResponseOfferSnapshot;
+            toAmino(message: _538.ResponseOfferSnapshot): _538.ResponseOfferSnapshotAmino;
+            fromAminoMsg(object: _538.ResponseOfferSnapshotAminoMsg): _538.ResponseOfferSnapshot;
+            fromProtoMsg(message: _538.ResponseOfferSnapshotProtoMsg): _538.ResponseOfferSnapshot;
+            toProto(message: _538.ResponseOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _538.ResponseOfferSnapshot): _538.ResponseOfferSnapshotProtoMsg;
         };
         ResponseLoadSnapshotChunk: {
             typeUrl: string;
-            encode(message: _536.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseLoadSnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseLoadSnapshotChunk>): _536.ResponseLoadSnapshotChunk;
-            fromAmino(object: _536.ResponseLoadSnapshotChunkAmino): _536.ResponseLoadSnapshotChunk;
-            toAmino(message: _536.ResponseLoadSnapshotChunk): _536.ResponseLoadSnapshotChunkAmino;
-            fromAminoMsg(object: _536.ResponseLoadSnapshotChunkAminoMsg): _536.ResponseLoadSnapshotChunk;
-            fromProtoMsg(message: _536.ResponseLoadSnapshotChunkProtoMsg): _536.ResponseLoadSnapshotChunk;
-            toProto(message: _536.ResponseLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _536.ResponseLoadSnapshotChunk): _536.ResponseLoadSnapshotChunkProtoMsg;
+            encode(message: _538.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseLoadSnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseLoadSnapshotChunk>): _538.ResponseLoadSnapshotChunk;
+            fromAmino(object: _538.ResponseLoadSnapshotChunkAmino): _538.ResponseLoadSnapshotChunk;
+            toAmino(message: _538.ResponseLoadSnapshotChunk): _538.ResponseLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _538.ResponseLoadSnapshotChunkAminoMsg): _538.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: _538.ResponseLoadSnapshotChunkProtoMsg): _538.ResponseLoadSnapshotChunk;
+            toProto(message: _538.ResponseLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _538.ResponseLoadSnapshotChunk): _538.ResponseLoadSnapshotChunkProtoMsg;
         };
         ResponseApplySnapshotChunk: {
             typeUrl: string;
-            encode(message: _536.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseApplySnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseApplySnapshotChunk>): _536.ResponseApplySnapshotChunk;
-            fromAmino(object: _536.ResponseApplySnapshotChunkAmino): _536.ResponseApplySnapshotChunk;
-            toAmino(message: _536.ResponseApplySnapshotChunk): _536.ResponseApplySnapshotChunkAmino;
-            fromAminoMsg(object: _536.ResponseApplySnapshotChunkAminoMsg): _536.ResponseApplySnapshotChunk;
-            fromProtoMsg(message: _536.ResponseApplySnapshotChunkProtoMsg): _536.ResponseApplySnapshotChunk;
-            toProto(message: _536.ResponseApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _536.ResponseApplySnapshotChunk): _536.ResponseApplySnapshotChunkProtoMsg;
+            encode(message: _538.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseApplySnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseApplySnapshotChunk>): _538.ResponseApplySnapshotChunk;
+            fromAmino(object: _538.ResponseApplySnapshotChunkAmino): _538.ResponseApplySnapshotChunk;
+            toAmino(message: _538.ResponseApplySnapshotChunk): _538.ResponseApplySnapshotChunkAmino;
+            fromAminoMsg(object: _538.ResponseApplySnapshotChunkAminoMsg): _538.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: _538.ResponseApplySnapshotChunkProtoMsg): _538.ResponseApplySnapshotChunk;
+            toProto(message: _538.ResponseApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _538.ResponseApplySnapshotChunk): _538.ResponseApplySnapshotChunkProtoMsg;
         };
         ResponsePrepareProposal: {
             typeUrl: string;
-            encode(message: _536.ResponsePrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponsePrepareProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponsePrepareProposal>): _536.ResponsePrepareProposal;
-            fromAmino(object: _536.ResponsePrepareProposalAmino): _536.ResponsePrepareProposal;
-            toAmino(message: _536.ResponsePrepareProposal): _536.ResponsePrepareProposalAmino;
-            fromAminoMsg(object: _536.ResponsePrepareProposalAminoMsg): _536.ResponsePrepareProposal;
-            fromProtoMsg(message: _536.ResponsePrepareProposalProtoMsg): _536.ResponsePrepareProposal;
-            toProto(message: _536.ResponsePrepareProposal): Uint8Array;
-            toProtoMsg(message: _536.ResponsePrepareProposal): _536.ResponsePrepareProposalProtoMsg;
+            encode(message: _538.ResponsePrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponsePrepareProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponsePrepareProposal>): _538.ResponsePrepareProposal;
+            fromAmino(object: _538.ResponsePrepareProposalAmino): _538.ResponsePrepareProposal;
+            toAmino(message: _538.ResponsePrepareProposal): _538.ResponsePrepareProposalAmino;
+            fromAminoMsg(object: _538.ResponsePrepareProposalAminoMsg): _538.ResponsePrepareProposal;
+            fromProtoMsg(message: _538.ResponsePrepareProposalProtoMsg): _538.ResponsePrepareProposal;
+            toProto(message: _538.ResponsePrepareProposal): Uint8Array;
+            toProtoMsg(message: _538.ResponsePrepareProposal): _538.ResponsePrepareProposalProtoMsg;
         };
         ResponseProcessProposal: {
             typeUrl: string;
-            encode(message: _536.ResponseProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseProcessProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseProcessProposal>): _536.ResponseProcessProposal;
-            fromAmino(object: _536.ResponseProcessProposalAmino): _536.ResponseProcessProposal;
-            toAmino(message: _536.ResponseProcessProposal): _536.ResponseProcessProposalAmino;
-            fromAminoMsg(object: _536.ResponseProcessProposalAminoMsg): _536.ResponseProcessProposal;
-            fromProtoMsg(message: _536.ResponseProcessProposalProtoMsg): _536.ResponseProcessProposal;
-            toProto(message: _536.ResponseProcessProposal): Uint8Array;
-            toProtoMsg(message: _536.ResponseProcessProposal): _536.ResponseProcessProposalProtoMsg;
+            encode(message: _538.ResponseProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseProcessProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseProcessProposal>): _538.ResponseProcessProposal;
+            fromAmino(object: _538.ResponseProcessProposalAmino): _538.ResponseProcessProposal;
+            toAmino(message: _538.ResponseProcessProposal): _538.ResponseProcessProposalAmino;
+            fromAminoMsg(object: _538.ResponseProcessProposalAminoMsg): _538.ResponseProcessProposal;
+            fromProtoMsg(message: _538.ResponseProcessProposalProtoMsg): _538.ResponseProcessProposal;
+            toProto(message: _538.ResponseProcessProposal): Uint8Array;
+            toProtoMsg(message: _538.ResponseProcessProposal): _538.ResponseProcessProposalProtoMsg;
         };
         ResponseExtendVote: {
             typeUrl: string;
-            encode(message: _536.ResponseExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseExtendVote;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseExtendVote>): _536.ResponseExtendVote;
-            fromAmino(object: _536.ResponseExtendVoteAmino): _536.ResponseExtendVote;
-            toAmino(message: _536.ResponseExtendVote): _536.ResponseExtendVoteAmino;
-            fromAminoMsg(object: _536.ResponseExtendVoteAminoMsg): _536.ResponseExtendVote;
-            fromProtoMsg(message: _536.ResponseExtendVoteProtoMsg): _536.ResponseExtendVote;
-            toProto(message: _536.ResponseExtendVote): Uint8Array;
-            toProtoMsg(message: _536.ResponseExtendVote): _536.ResponseExtendVoteProtoMsg;
+            encode(message: _538.ResponseExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseExtendVote;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseExtendVote>): _538.ResponseExtendVote;
+            fromAmino(object: _538.ResponseExtendVoteAmino): _538.ResponseExtendVote;
+            toAmino(message: _538.ResponseExtendVote): _538.ResponseExtendVoteAmino;
+            fromAminoMsg(object: _538.ResponseExtendVoteAminoMsg): _538.ResponseExtendVote;
+            fromProtoMsg(message: _538.ResponseExtendVoteProtoMsg): _538.ResponseExtendVote;
+            toProto(message: _538.ResponseExtendVote): Uint8Array;
+            toProtoMsg(message: _538.ResponseExtendVote): _538.ResponseExtendVoteProtoMsg;
         };
         ResponseVerifyVoteExtension: {
             typeUrl: string;
-            encode(message: _536.ResponseVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseVerifyVoteExtension;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseVerifyVoteExtension>): _536.ResponseVerifyVoteExtension;
-            fromAmino(object: _536.ResponseVerifyVoteExtensionAmino): _536.ResponseVerifyVoteExtension;
-            toAmino(message: _536.ResponseVerifyVoteExtension): _536.ResponseVerifyVoteExtensionAmino;
-            fromAminoMsg(object: _536.ResponseVerifyVoteExtensionAminoMsg): _536.ResponseVerifyVoteExtension;
-            fromProtoMsg(message: _536.ResponseVerifyVoteExtensionProtoMsg): _536.ResponseVerifyVoteExtension;
-            toProto(message: _536.ResponseVerifyVoteExtension): Uint8Array;
-            toProtoMsg(message: _536.ResponseVerifyVoteExtension): _536.ResponseVerifyVoteExtensionProtoMsg;
+            encode(message: _538.ResponseVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseVerifyVoteExtension;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseVerifyVoteExtension>): _538.ResponseVerifyVoteExtension;
+            fromAmino(object: _538.ResponseVerifyVoteExtensionAmino): _538.ResponseVerifyVoteExtension;
+            toAmino(message: _538.ResponseVerifyVoteExtension): _538.ResponseVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _538.ResponseVerifyVoteExtensionAminoMsg): _538.ResponseVerifyVoteExtension;
+            fromProtoMsg(message: _538.ResponseVerifyVoteExtensionProtoMsg): _538.ResponseVerifyVoteExtension;
+            toProto(message: _538.ResponseVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _538.ResponseVerifyVoteExtension): _538.ResponseVerifyVoteExtensionProtoMsg;
         };
         ResponseFinalizeBlock: {
             typeUrl: string;
-            encode(message: _536.ResponseFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseFinalizeBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseFinalizeBlock>): _536.ResponseFinalizeBlock;
-            fromAmino(object: _536.ResponseFinalizeBlockAmino): _536.ResponseFinalizeBlock;
-            toAmino(message: _536.ResponseFinalizeBlock): _536.ResponseFinalizeBlockAmino;
-            fromAminoMsg(object: _536.ResponseFinalizeBlockAminoMsg): _536.ResponseFinalizeBlock;
-            fromProtoMsg(message: _536.ResponseFinalizeBlockProtoMsg): _536.ResponseFinalizeBlock;
-            toProto(message: _536.ResponseFinalizeBlock): Uint8Array;
-            toProtoMsg(message: _536.ResponseFinalizeBlock): _536.ResponseFinalizeBlockProtoMsg;
+            encode(message: _538.ResponseFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ResponseFinalizeBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ResponseFinalizeBlock>): _538.ResponseFinalizeBlock;
+            fromAmino(object: _538.ResponseFinalizeBlockAmino): _538.ResponseFinalizeBlock;
+            toAmino(message: _538.ResponseFinalizeBlock): _538.ResponseFinalizeBlockAmino;
+            fromAminoMsg(object: _538.ResponseFinalizeBlockAminoMsg): _538.ResponseFinalizeBlock;
+            fromProtoMsg(message: _538.ResponseFinalizeBlockProtoMsg): _538.ResponseFinalizeBlock;
+            toProto(message: _538.ResponseFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _538.ResponseFinalizeBlock): _538.ResponseFinalizeBlockProtoMsg;
         };
         CommitInfo: {
             typeUrl: string;
-            encode(message: _536.CommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.CommitInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.CommitInfo>): _536.CommitInfo;
-            fromAmino(object: _536.CommitInfoAmino): _536.CommitInfo;
-            toAmino(message: _536.CommitInfo): _536.CommitInfoAmino;
-            fromAminoMsg(object: _536.CommitInfoAminoMsg): _536.CommitInfo;
-            fromProtoMsg(message: _536.CommitInfoProtoMsg): _536.CommitInfo;
-            toProto(message: _536.CommitInfo): Uint8Array;
-            toProtoMsg(message: _536.CommitInfo): _536.CommitInfoProtoMsg;
+            encode(message: _538.CommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.CommitInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.CommitInfo>): _538.CommitInfo;
+            fromAmino(object: _538.CommitInfoAmino): _538.CommitInfo;
+            toAmino(message: _538.CommitInfo): _538.CommitInfoAmino;
+            fromAminoMsg(object: _538.CommitInfoAminoMsg): _538.CommitInfo;
+            fromProtoMsg(message: _538.CommitInfoProtoMsg): _538.CommitInfo;
+            toProto(message: _538.CommitInfo): Uint8Array;
+            toProtoMsg(message: _538.CommitInfo): _538.CommitInfoProtoMsg;
         };
         ExtendedCommitInfo: {
             typeUrl: string;
-            encode(message: _536.ExtendedCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExtendedCommitInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ExtendedCommitInfo>): _536.ExtendedCommitInfo;
-            fromAmino(object: _536.ExtendedCommitInfoAmino): _536.ExtendedCommitInfo;
-            toAmino(message: _536.ExtendedCommitInfo): _536.ExtendedCommitInfoAmino;
-            fromAminoMsg(object: _536.ExtendedCommitInfoAminoMsg): _536.ExtendedCommitInfo;
-            fromProtoMsg(message: _536.ExtendedCommitInfoProtoMsg): _536.ExtendedCommitInfo;
-            toProto(message: _536.ExtendedCommitInfo): Uint8Array;
-            toProtoMsg(message: _536.ExtendedCommitInfo): _536.ExtendedCommitInfoProtoMsg;
+            encode(message: _538.ExtendedCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ExtendedCommitInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ExtendedCommitInfo>): _538.ExtendedCommitInfo;
+            fromAmino(object: _538.ExtendedCommitInfoAmino): _538.ExtendedCommitInfo;
+            toAmino(message: _538.ExtendedCommitInfo): _538.ExtendedCommitInfoAmino;
+            fromAminoMsg(object: _538.ExtendedCommitInfoAminoMsg): _538.ExtendedCommitInfo;
+            fromProtoMsg(message: _538.ExtendedCommitInfoProtoMsg): _538.ExtendedCommitInfo;
+            toProto(message: _538.ExtendedCommitInfo): Uint8Array;
+            toProtoMsg(message: _538.ExtendedCommitInfo): _538.ExtendedCommitInfoProtoMsg;
         };
         Event: {
             typeUrl: string;
-            encode(message: _536.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Event;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Event>): _536.Event;
-            fromAmino(object: _536.EventAmino): _536.Event;
-            toAmino(message: _536.Event): _536.EventAmino;
-            fromAminoMsg(object: _536.EventAminoMsg): _536.Event;
-            fromProtoMsg(message: _536.EventProtoMsg): _536.Event;
-            toProto(message: _536.Event): Uint8Array;
-            toProtoMsg(message: _536.Event): _536.EventProtoMsg;
+            encode(message: _538.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Event;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Event>): _538.Event;
+            fromAmino(object: _538.EventAmino): _538.Event;
+            toAmino(message: _538.Event): _538.EventAmino;
+            fromAminoMsg(object: _538.EventAminoMsg): _538.Event;
+            fromProtoMsg(message: _538.EventProtoMsg): _538.Event;
+            toProto(message: _538.Event): Uint8Array;
+            toProtoMsg(message: _538.Event): _538.EventProtoMsg;
         };
         EventAttribute: {
             typeUrl: string;
-            encode(message: _536.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.EventAttribute;
-            fromPartial(object: import("../helpers").DeepPartial<_536.EventAttribute>): _536.EventAttribute;
-            fromAmino(object: _536.EventAttributeAmino): _536.EventAttribute;
-            toAmino(message: _536.EventAttribute): _536.EventAttributeAmino;
-            fromAminoMsg(object: _536.EventAttributeAminoMsg): _536.EventAttribute;
-            fromProtoMsg(message: _536.EventAttributeProtoMsg): _536.EventAttribute;
-            toProto(message: _536.EventAttribute): Uint8Array;
-            toProtoMsg(message: _536.EventAttribute): _536.EventAttributeProtoMsg;
+            encode(message: _538.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.EventAttribute;
+            fromPartial(object: import("../helpers").DeepPartial<_538.EventAttribute>): _538.EventAttribute;
+            fromAmino(object: _538.EventAttributeAmino): _538.EventAttribute;
+            toAmino(message: _538.EventAttribute): _538.EventAttributeAmino;
+            fromAminoMsg(object: _538.EventAttributeAminoMsg): _538.EventAttribute;
+            fromProtoMsg(message: _538.EventAttributeProtoMsg): _538.EventAttribute;
+            toProto(message: _538.EventAttribute): Uint8Array;
+            toProtoMsg(message: _538.EventAttribute): _538.EventAttributeProtoMsg;
         };
         ExecTxResult: {
             typeUrl: string;
-            encode(message: _536.ExecTxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExecTxResult;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ExecTxResult>): _536.ExecTxResult;
-            fromAmino(object: _536.ExecTxResultAmino): _536.ExecTxResult;
-            toAmino(message: _536.ExecTxResult): _536.ExecTxResultAmino;
-            fromAminoMsg(object: _536.ExecTxResultAminoMsg): _536.ExecTxResult;
-            fromProtoMsg(message: _536.ExecTxResultProtoMsg): _536.ExecTxResult;
-            toProto(message: _536.ExecTxResult): Uint8Array;
-            toProtoMsg(message: _536.ExecTxResult): _536.ExecTxResultProtoMsg;
+            encode(message: _538.ExecTxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ExecTxResult;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ExecTxResult>): _538.ExecTxResult;
+            fromAmino(object: _538.ExecTxResultAmino): _538.ExecTxResult;
+            toAmino(message: _538.ExecTxResult): _538.ExecTxResultAmino;
+            fromAminoMsg(object: _538.ExecTxResultAminoMsg): _538.ExecTxResult;
+            fromProtoMsg(message: _538.ExecTxResultProtoMsg): _538.ExecTxResult;
+            toProto(message: _538.ExecTxResult): Uint8Array;
+            toProtoMsg(message: _538.ExecTxResult): _538.ExecTxResultProtoMsg;
         };
         TxResult: {
             typeUrl: string;
-            encode(message: _536.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.TxResult;
-            fromPartial(object: import("../helpers").DeepPartial<_536.TxResult>): _536.TxResult;
-            fromAmino(object: _536.TxResultAmino): _536.TxResult;
-            toAmino(message: _536.TxResult): _536.TxResultAmino;
-            fromAminoMsg(object: _536.TxResultAminoMsg): _536.TxResult;
-            fromProtoMsg(message: _536.TxResultProtoMsg): _536.TxResult;
-            toProto(message: _536.TxResult): Uint8Array;
-            toProtoMsg(message: _536.TxResult): _536.TxResultProtoMsg;
+            encode(message: _538.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.TxResult;
+            fromPartial(object: import("../helpers").DeepPartial<_538.TxResult>): _538.TxResult;
+            fromAmino(object: _538.TxResultAmino): _538.TxResult;
+            toAmino(message: _538.TxResult): _538.TxResultAmino;
+            fromAminoMsg(object: _538.TxResultAminoMsg): _538.TxResult;
+            fromProtoMsg(message: _538.TxResultProtoMsg): _538.TxResult;
+            toProto(message: _538.TxResult): Uint8Array;
+            toProtoMsg(message: _538.TxResult): _538.TxResultProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _536.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Validator;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Validator>): _536.Validator;
-            fromAmino(object: _536.ValidatorAmino): _536.Validator;
-            toAmino(message: _536.Validator): _536.ValidatorAmino;
-            fromAminoMsg(object: _536.ValidatorAminoMsg): _536.Validator;
-            fromProtoMsg(message: _536.ValidatorProtoMsg): _536.Validator;
-            toProto(message: _536.Validator): Uint8Array;
-            toProtoMsg(message: _536.Validator): _536.ValidatorProtoMsg;
+            encode(message: _538.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Validator;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Validator>): _538.Validator;
+            fromAmino(object: _538.ValidatorAmino): _538.Validator;
+            toAmino(message: _538.Validator): _538.ValidatorAmino;
+            fromAminoMsg(object: _538.ValidatorAminoMsg): _538.Validator;
+            fromProtoMsg(message: _538.ValidatorProtoMsg): _538.Validator;
+            toProto(message: _538.Validator): Uint8Array;
+            toProtoMsg(message: _538.Validator): _538.ValidatorProtoMsg;
         };
         ValidatorUpdate: {
             typeUrl: string;
-            encode(message: _536.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ValidatorUpdate;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ValidatorUpdate>): _536.ValidatorUpdate;
-            fromAmino(object: _536.ValidatorUpdateAmino): _536.ValidatorUpdate;
-            toAmino(message: _536.ValidatorUpdate): _536.ValidatorUpdateAmino;
-            fromAminoMsg(object: _536.ValidatorUpdateAminoMsg): _536.ValidatorUpdate;
-            fromProtoMsg(message: _536.ValidatorUpdateProtoMsg): _536.ValidatorUpdate;
-            toProto(message: _536.ValidatorUpdate): Uint8Array;
-            toProtoMsg(message: _536.ValidatorUpdate): _536.ValidatorUpdateProtoMsg;
+            encode(message: _538.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ValidatorUpdate;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ValidatorUpdate>): _538.ValidatorUpdate;
+            fromAmino(object: _538.ValidatorUpdateAmino): _538.ValidatorUpdate;
+            toAmino(message: _538.ValidatorUpdate): _538.ValidatorUpdateAmino;
+            fromAminoMsg(object: _538.ValidatorUpdateAminoMsg): _538.ValidatorUpdate;
+            fromProtoMsg(message: _538.ValidatorUpdateProtoMsg): _538.ValidatorUpdate;
+            toProto(message: _538.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _538.ValidatorUpdate): _538.ValidatorUpdateProtoMsg;
         };
         VoteInfo: {
             typeUrl: string;
-            encode(message: _536.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.VoteInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.VoteInfo>): _536.VoteInfo;
-            fromAmino(object: _536.VoteInfoAmino): _536.VoteInfo;
-            toAmino(message: _536.VoteInfo): _536.VoteInfoAmino;
-            fromAminoMsg(object: _536.VoteInfoAminoMsg): _536.VoteInfo;
-            fromProtoMsg(message: _536.VoteInfoProtoMsg): _536.VoteInfo;
-            toProto(message: _536.VoteInfo): Uint8Array;
-            toProtoMsg(message: _536.VoteInfo): _536.VoteInfoProtoMsg;
+            encode(message: _538.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.VoteInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.VoteInfo>): _538.VoteInfo;
+            fromAmino(object: _538.VoteInfoAmino): _538.VoteInfo;
+            toAmino(message: _538.VoteInfo): _538.VoteInfoAmino;
+            fromAminoMsg(object: _538.VoteInfoAminoMsg): _538.VoteInfo;
+            fromProtoMsg(message: _538.VoteInfoProtoMsg): _538.VoteInfo;
+            toProto(message: _538.VoteInfo): Uint8Array;
+            toProtoMsg(message: _538.VoteInfo): _538.VoteInfoProtoMsg;
         };
         ExtendedVoteInfo: {
             typeUrl: string;
-            encode(message: _536.ExtendedVoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExtendedVoteInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_536.ExtendedVoteInfo>): _536.ExtendedVoteInfo;
-            fromAmino(object: _536.ExtendedVoteInfoAmino): _536.ExtendedVoteInfo;
-            toAmino(message: _536.ExtendedVoteInfo): _536.ExtendedVoteInfoAmino;
-            fromAminoMsg(object: _536.ExtendedVoteInfoAminoMsg): _536.ExtendedVoteInfo;
-            fromProtoMsg(message: _536.ExtendedVoteInfoProtoMsg): _536.ExtendedVoteInfo;
-            toProto(message: _536.ExtendedVoteInfo): Uint8Array;
-            toProtoMsg(message: _536.ExtendedVoteInfo): _536.ExtendedVoteInfoProtoMsg;
+            encode(message: _538.ExtendedVoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ExtendedVoteInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ExtendedVoteInfo>): _538.ExtendedVoteInfo;
+            fromAmino(object: _538.ExtendedVoteInfoAmino): _538.ExtendedVoteInfo;
+            toAmino(message: _538.ExtendedVoteInfo): _538.ExtendedVoteInfoAmino;
+            fromAminoMsg(object: _538.ExtendedVoteInfoAminoMsg): _538.ExtendedVoteInfo;
+            fromProtoMsg(message: _538.ExtendedVoteInfoProtoMsg): _538.ExtendedVoteInfo;
+            toProto(message: _538.ExtendedVoteInfo): Uint8Array;
+            toProtoMsg(message: _538.ExtendedVoteInfo): _538.ExtendedVoteInfoProtoMsg;
         };
         Misbehavior: {
             typeUrl: string;
-            encode(message: _536.Misbehavior, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Misbehavior;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Misbehavior>): _536.Misbehavior;
-            fromAmino(object: _536.MisbehaviorAmino): _536.Misbehavior;
-            toAmino(message: _536.Misbehavior): _536.MisbehaviorAmino;
-            fromAminoMsg(object: _536.MisbehaviorAminoMsg): _536.Misbehavior;
-            fromProtoMsg(message: _536.MisbehaviorProtoMsg): _536.Misbehavior;
-            toProto(message: _536.Misbehavior): Uint8Array;
-            toProtoMsg(message: _536.Misbehavior): _536.MisbehaviorProtoMsg;
+            encode(message: _538.Misbehavior, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Misbehavior;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Misbehavior>): _538.Misbehavior;
+            fromAmino(object: _538.MisbehaviorAmino): _538.Misbehavior;
+            toAmino(message: _538.Misbehavior): _538.MisbehaviorAmino;
+            fromAminoMsg(object: _538.MisbehaviorAminoMsg): _538.Misbehavior;
+            fromProtoMsg(message: _538.MisbehaviorProtoMsg): _538.Misbehavior;
+            toProto(message: _538.Misbehavior): Uint8Array;
+            toProtoMsg(message: _538.Misbehavior): _538.MisbehaviorProtoMsg;
         };
         Snapshot: {
             typeUrl: string;
-            encode(message: _536.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Snapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_536.Snapshot>): _536.Snapshot;
-            fromAmino(object: _536.SnapshotAmino): _536.Snapshot;
-            toAmino(message: _536.Snapshot): _536.SnapshotAmino;
-            fromAminoMsg(object: _536.SnapshotAminoMsg): _536.Snapshot;
-            fromProtoMsg(message: _536.SnapshotProtoMsg): _536.Snapshot;
-            toProto(message: _536.Snapshot): Uint8Array;
-            toProtoMsg(message: _536.Snapshot): _536.SnapshotProtoMsg;
+            encode(message: _538.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Snapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Snapshot>): _538.Snapshot;
+            fromAmino(object: _538.SnapshotAmino): _538.Snapshot;
+            toAmino(message: _538.Snapshot): _538.SnapshotAmino;
+            fromAminoMsg(object: _538.SnapshotAminoMsg): _538.Snapshot;
+            fromProtoMsg(message: _538.SnapshotProtoMsg): _538.Snapshot;
+            toProto(message: _538.Snapshot): Uint8Array;
+            toProtoMsg(message: _538.Snapshot): _538.SnapshotProtoMsg;
         };
     };
     const crypto: {
         Proof: {
             typeUrl: string;
-            encode(message: _538.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Proof;
-            fromPartial(object: import("../helpers").DeepPartial<_538.Proof>): _538.Proof;
-            fromAmino(object: _538.ProofAmino): _538.Proof;
-            toAmino(message: _538.Proof): _538.ProofAmino;
-            fromAminoMsg(object: _538.ProofAminoMsg): _538.Proof;
-            fromProtoMsg(message: _538.ProofProtoMsg): _538.Proof;
-            toProto(message: _538.Proof): Uint8Array;
-            toProtoMsg(message: _538.Proof): _538.ProofProtoMsg;
+            encode(message: _540.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.Proof;
+            fromPartial(object: import("../helpers").DeepPartial<_540.Proof>): _540.Proof;
+            fromAmino(object: _540.ProofAmino): _540.Proof;
+            toAmino(message: _540.Proof): _540.ProofAmino;
+            fromAminoMsg(object: _540.ProofAminoMsg): _540.Proof;
+            fromProtoMsg(message: _540.ProofProtoMsg): _540.Proof;
+            toProto(message: _540.Proof): Uint8Array;
+            toProtoMsg(message: _540.Proof): _540.ProofProtoMsg;
         };
         ValueOp: {
             typeUrl: string;
-            encode(message: _538.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ValueOp;
-            fromPartial(object: import("../helpers").DeepPartial<_538.ValueOp>): _538.ValueOp;
-            fromAmino(object: _538.ValueOpAmino): _538.ValueOp;
-            toAmino(message: _538.ValueOp): _538.ValueOpAmino;
-            fromAminoMsg(object: _538.ValueOpAminoMsg): _538.ValueOp;
-            fromProtoMsg(message: _538.ValueOpProtoMsg): _538.ValueOp;
-            toProto(message: _538.ValueOp): Uint8Array;
-            toProtoMsg(message: _538.ValueOp): _538.ValueOpProtoMsg;
+            encode(message: _540.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.ValueOp;
+            fromPartial(object: import("../helpers").DeepPartial<_540.ValueOp>): _540.ValueOp;
+            fromAmino(object: _540.ValueOpAmino): _540.ValueOp;
+            toAmino(message: _540.ValueOp): _540.ValueOpAmino;
+            fromAminoMsg(object: _540.ValueOpAminoMsg): _540.ValueOp;
+            fromProtoMsg(message: _540.ValueOpProtoMsg): _540.ValueOp;
+            toProto(message: _540.ValueOp): Uint8Array;
+            toProtoMsg(message: _540.ValueOp): _540.ValueOpProtoMsg;
         };
         DominoOp: {
             typeUrl: string;
-            encode(message: _538.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.DominoOp;
-            fromPartial(object: import("../helpers").DeepPartial<_538.DominoOp>): _538.DominoOp;
-            fromAmino(object: _538.DominoOpAmino): _538.DominoOp;
-            toAmino(message: _538.DominoOp): _538.DominoOpAmino;
-            fromAminoMsg(object: _538.DominoOpAminoMsg): _538.DominoOp;
-            fromProtoMsg(message: _538.DominoOpProtoMsg): _538.DominoOp;
-            toProto(message: _538.DominoOp): Uint8Array;
-            toProtoMsg(message: _538.DominoOp): _538.DominoOpProtoMsg;
+            encode(message: _540.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.DominoOp;
+            fromPartial(object: import("../helpers").DeepPartial<_540.DominoOp>): _540.DominoOp;
+            fromAmino(object: _540.DominoOpAmino): _540.DominoOp;
+            toAmino(message: _540.DominoOp): _540.DominoOpAmino;
+            fromAminoMsg(object: _540.DominoOpAminoMsg): _540.DominoOp;
+            fromProtoMsg(message: _540.DominoOpProtoMsg): _540.DominoOp;
+            toProto(message: _540.DominoOp): Uint8Array;
+            toProtoMsg(message: _540.DominoOp): _540.DominoOpProtoMsg;
         };
         ProofOp: {
             typeUrl: string;
-            encode(message: _538.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ProofOp;
-            fromPartial(object: import("../helpers").DeepPartial<_538.ProofOp>): _538.ProofOp;
-            fromAmino(object: _538.ProofOpAmino): _538.ProofOp;
-            toAmino(message: _538.ProofOp): _538.ProofOpAmino;
-            fromAminoMsg(object: _538.ProofOpAminoMsg): _538.ProofOp;
-            fromProtoMsg(message: _538.ProofOpProtoMsg): _538.ProofOp;
-            toProto(message: _538.ProofOp): Uint8Array;
-            toProtoMsg(message: _538.ProofOp): _538.ProofOpProtoMsg;
+            encode(message: _540.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.ProofOp;
+            fromPartial(object: import("../helpers").DeepPartial<_540.ProofOp>): _540.ProofOp;
+            fromAmino(object: _540.ProofOpAmino): _540.ProofOp;
+            toAmino(message: _540.ProofOp): _540.ProofOpAmino;
+            fromAminoMsg(object: _540.ProofOpAminoMsg): _540.ProofOp;
+            fromProtoMsg(message: _540.ProofOpProtoMsg): _540.ProofOp;
+            toProto(message: _540.ProofOp): Uint8Array;
+            toProtoMsg(message: _540.ProofOp): _540.ProofOpProtoMsg;
         };
         ProofOps: {
             typeUrl: string;
-            encode(message: _538.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ProofOps;
-            fromPartial(object: import("../helpers").DeepPartial<_538.ProofOps>): _538.ProofOps;
-            fromAmino(object: _538.ProofOpsAmino): _538.ProofOps;
-            toAmino(message: _538.ProofOps): _538.ProofOpsAmino;
-            fromAminoMsg(object: _538.ProofOpsAminoMsg): _538.ProofOps;
-            fromProtoMsg(message: _538.ProofOpsProtoMsg): _538.ProofOps;
-            toProto(message: _538.ProofOps): Uint8Array;
-            toProtoMsg(message: _538.ProofOps): _538.ProofOpsProtoMsg;
+            encode(message: _540.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.ProofOps;
+            fromPartial(object: import("../helpers").DeepPartial<_540.ProofOps>): _540.ProofOps;
+            fromAmino(object: _540.ProofOpsAmino): _540.ProofOps;
+            toAmino(message: _540.ProofOps): _540.ProofOpsAmino;
+            fromAminoMsg(object: _540.ProofOpsAminoMsg): _540.ProofOps;
+            fromProtoMsg(message: _540.ProofOpsProtoMsg): _540.ProofOps;
+            toProto(message: _540.ProofOps): Uint8Array;
+            toProtoMsg(message: _540.ProofOps): _540.ProofOpsProtoMsg;
         };
         PublicKey: {
             typeUrl: string;
-            encode(message: _537.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _537.PublicKey;
-            fromPartial(object: import("../helpers").DeepPartial<_537.PublicKey>): _537.PublicKey;
-            fromAmino(object: _537.PublicKeyAmino): _537.PublicKey;
-            toAmino(message: _537.PublicKey): _537.PublicKeyAmino;
-            fromAminoMsg(object: _537.PublicKeyAminoMsg): _537.PublicKey;
-            fromProtoMsg(message: _537.PublicKeyProtoMsg): _537.PublicKey;
-            toProto(message: _537.PublicKey): Uint8Array;
-            toProtoMsg(message: _537.PublicKey): _537.PublicKeyProtoMsg;
+            encode(message: _539.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.PublicKey;
+            fromPartial(object: import("../helpers").DeepPartial<_539.PublicKey>): _539.PublicKey;
+            fromAmino(object: _539.PublicKeyAmino): _539.PublicKey;
+            toAmino(message: _539.PublicKey): _539.PublicKeyAmino;
+            fromAminoMsg(object: _539.PublicKeyAminoMsg): _539.PublicKey;
+            fromProtoMsg(message: _539.PublicKeyProtoMsg): _539.PublicKey;
+            toProto(message: _539.PublicKey): Uint8Array;
+            toProtoMsg(message: _539.PublicKey): _539.PublicKeyProtoMsg;
         };
     };
     const p2p: {
         NetAddress: {
             typeUrl: string;
-            encode(message: _539.NetAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.NetAddress;
-            fromPartial(object: import("../helpers").DeepPartial<_539.NetAddress>): _539.NetAddress;
-            fromAmino(object: _539.NetAddressAmino): _539.NetAddress;
-            toAmino(message: _539.NetAddress): _539.NetAddressAmino;
-            fromAminoMsg(object: _539.NetAddressAminoMsg): _539.NetAddress;
-            fromProtoMsg(message: _539.NetAddressProtoMsg): _539.NetAddress;
-            toProto(message: _539.NetAddress): Uint8Array;
-            toProtoMsg(message: _539.NetAddress): _539.NetAddressProtoMsg;
+            encode(message: _541.NetAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.NetAddress;
+            fromPartial(object: import("../helpers").DeepPartial<_541.NetAddress>): _541.NetAddress;
+            fromAmino(object: _541.NetAddressAmino): _541.NetAddress;
+            toAmino(message: _541.NetAddress): _541.NetAddressAmino;
+            fromAminoMsg(object: _541.NetAddressAminoMsg): _541.NetAddress;
+            fromProtoMsg(message: _541.NetAddressProtoMsg): _541.NetAddress;
+            toProto(message: _541.NetAddress): Uint8Array;
+            toProtoMsg(message: _541.NetAddress): _541.NetAddressProtoMsg;
         };
         ProtocolVersion: {
             typeUrl: string;
-            encode(message: _539.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.ProtocolVersion;
-            fromPartial(object: import("../helpers").DeepPartial<_539.ProtocolVersion>): _539.ProtocolVersion;
-            fromAmino(object: _539.ProtocolVersionAmino): _539.ProtocolVersion;
-            toAmino(message: _539.ProtocolVersion): _539.ProtocolVersionAmino;
-            fromAminoMsg(object: _539.ProtocolVersionAminoMsg): _539.ProtocolVersion;
-            fromProtoMsg(message: _539.ProtocolVersionProtoMsg): _539.ProtocolVersion;
-            toProto(message: _539.ProtocolVersion): Uint8Array;
-            toProtoMsg(message: _539.ProtocolVersion): _539.ProtocolVersionProtoMsg;
+            encode(message: _541.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.ProtocolVersion;
+            fromPartial(object: import("../helpers").DeepPartial<_541.ProtocolVersion>): _541.ProtocolVersion;
+            fromAmino(object: _541.ProtocolVersionAmino): _541.ProtocolVersion;
+            toAmino(message: _541.ProtocolVersion): _541.ProtocolVersionAmino;
+            fromAminoMsg(object: _541.ProtocolVersionAminoMsg): _541.ProtocolVersion;
+            fromProtoMsg(message: _541.ProtocolVersionProtoMsg): _541.ProtocolVersion;
+            toProto(message: _541.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _541.ProtocolVersion): _541.ProtocolVersionProtoMsg;
         };
         DefaultNodeInfo: {
             typeUrl: string;
-            encode(message: _539.DefaultNodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.DefaultNodeInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_539.DefaultNodeInfo>): _539.DefaultNodeInfo;
-            fromAmino(object: _539.DefaultNodeInfoAmino): _539.DefaultNodeInfo;
-            toAmino(message: _539.DefaultNodeInfo): _539.DefaultNodeInfoAmino;
-            fromAminoMsg(object: _539.DefaultNodeInfoAminoMsg): _539.DefaultNodeInfo;
-            fromProtoMsg(message: _539.DefaultNodeInfoProtoMsg): _539.DefaultNodeInfo;
-            toProto(message: _539.DefaultNodeInfo): Uint8Array;
-            toProtoMsg(message: _539.DefaultNodeInfo): _539.DefaultNodeInfoProtoMsg;
+            encode(message: _541.DefaultNodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.DefaultNodeInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_541.DefaultNodeInfo>): _541.DefaultNodeInfo;
+            fromAmino(object: _541.DefaultNodeInfoAmino): _541.DefaultNodeInfo;
+            toAmino(message: _541.DefaultNodeInfo): _541.DefaultNodeInfoAmino;
+            fromAminoMsg(object: _541.DefaultNodeInfoAminoMsg): _541.DefaultNodeInfo;
+            fromProtoMsg(message: _541.DefaultNodeInfoProtoMsg): _541.DefaultNodeInfo;
+            toProto(message: _541.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _541.DefaultNodeInfo): _541.DefaultNodeInfoProtoMsg;
         };
         DefaultNodeInfoOther: {
             typeUrl: string;
-            encode(message: _539.DefaultNodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.DefaultNodeInfoOther;
-            fromPartial(object: import("../helpers").DeepPartial<_539.DefaultNodeInfoOther>): _539.DefaultNodeInfoOther;
-            fromAmino(object: _539.DefaultNodeInfoOtherAmino): _539.DefaultNodeInfoOther;
-            toAmino(message: _539.DefaultNodeInfoOther): _539.DefaultNodeInfoOtherAmino;
-            fromAminoMsg(object: _539.DefaultNodeInfoOtherAminoMsg): _539.DefaultNodeInfoOther;
-            fromProtoMsg(message: _539.DefaultNodeInfoOtherProtoMsg): _539.DefaultNodeInfoOther;
-            toProto(message: _539.DefaultNodeInfoOther): Uint8Array;
-            toProtoMsg(message: _539.DefaultNodeInfoOther): _539.DefaultNodeInfoOtherProtoMsg;
+            encode(message: _541.DefaultNodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.DefaultNodeInfoOther;
+            fromPartial(object: import("../helpers").DeepPartial<_541.DefaultNodeInfoOther>): _541.DefaultNodeInfoOther;
+            fromAmino(object: _541.DefaultNodeInfoOtherAmino): _541.DefaultNodeInfoOther;
+            toAmino(message: _541.DefaultNodeInfoOther): _541.DefaultNodeInfoOtherAmino;
+            fromAminoMsg(object: _541.DefaultNodeInfoOtherAminoMsg): _541.DefaultNodeInfoOther;
+            fromProtoMsg(message: _541.DefaultNodeInfoOtherProtoMsg): _541.DefaultNodeInfoOther;
+            toProto(message: _541.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _541.DefaultNodeInfoOther): _541.DefaultNodeInfoOtherProtoMsg;
         };
     };
     const types: {
-        blockIDFlagFromJSON(object: any): _544.BlockIDFlag;
-        blockIDFlagToJSON(object: _544.BlockIDFlag): string;
-        BlockIDFlag: typeof _544.BlockIDFlag;
-        BlockIDFlagAmino: typeof _544.BlockIDFlag;
+        blockIDFlagFromJSON(object: any): _546.BlockIDFlag;
+        blockIDFlagToJSON(object: _546.BlockIDFlag): string;
+        BlockIDFlag: typeof _546.BlockIDFlag;
+        BlockIDFlagAmino: typeof _546.BlockIDFlag;
         ValidatorSet: {
             typeUrl: string;
-            encode(message: _544.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.ValidatorSet;
-            fromPartial(object: import("../helpers").DeepPartial<_544.ValidatorSet>): _544.ValidatorSet;
-            fromAmino(object: _544.ValidatorSetAmino): _544.ValidatorSet;
-            toAmino(message: _544.ValidatorSet): _544.ValidatorSetAmino;
-            fromAminoMsg(object: _544.ValidatorSetAminoMsg): _544.ValidatorSet;
-            fromProtoMsg(message: _544.ValidatorSetProtoMsg): _544.ValidatorSet;
-            toProto(message: _544.ValidatorSet): Uint8Array;
-            toProtoMsg(message: _544.ValidatorSet): _544.ValidatorSetProtoMsg;
+            encode(message: _546.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _546.ValidatorSet;
+            fromPartial(object: import("../helpers").DeepPartial<_546.ValidatorSet>): _546.ValidatorSet;
+            fromAmino(object: _546.ValidatorSetAmino): _546.ValidatorSet;
+            toAmino(message: _546.ValidatorSet): _546.ValidatorSetAmino;
+            fromAminoMsg(object: _546.ValidatorSetAminoMsg): _546.ValidatorSet;
+            fromProtoMsg(message: _546.ValidatorSetProtoMsg): _546.ValidatorSet;
+            toProto(message: _546.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _546.ValidatorSet): _546.ValidatorSetProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _544.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.Validator;
-            fromPartial(object: import("../helpers").DeepPartial<_544.Validator>): _544.Validator;
-            fromAmino(object: _544.ValidatorAmino): _544.Validator;
-            toAmino(message: _544.Validator): _544.ValidatorAmino;
-            fromAminoMsg(object: _544.ValidatorAminoMsg): _544.Validator;
-            fromProtoMsg(message: _544.ValidatorProtoMsg): _544.Validator;
-            toProto(message: _544.Validator): Uint8Array;
-            toProtoMsg(message: _544.Validator): _544.ValidatorProtoMsg;
+            encode(message: _546.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _546.Validator;
+            fromPartial(object: import("../helpers").DeepPartial<_546.Validator>): _546.Validator;
+            fromAmino(object: _546.ValidatorAmino): _546.Validator;
+            toAmino(message: _546.Validator): _546.ValidatorAmino;
+            fromAminoMsg(object: _546.ValidatorAminoMsg): _546.Validator;
+            fromProtoMsg(message: _546.ValidatorProtoMsg): _546.Validator;
+            toProto(message: _546.Validator): Uint8Array;
+            toProtoMsg(message: _546.Validator): _546.ValidatorProtoMsg;
         };
         SimpleValidator: {
             typeUrl: string;
-            encode(message: _544.SimpleValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.SimpleValidator;
-            fromPartial(object: import("../helpers").DeepPartial<_544.SimpleValidator>): _544.SimpleValidator;
-            fromAmino(object: _544.SimpleValidatorAmino): _544.SimpleValidator;
-            toAmino(message: _544.SimpleValidator): _544.SimpleValidatorAmino;
-            fromAminoMsg(object: _544.SimpleValidatorAminoMsg): _544.SimpleValidator;
-            fromProtoMsg(message: _544.SimpleValidatorProtoMsg): _544.SimpleValidator;
-            toProto(message: _544.SimpleValidator): Uint8Array;
-            toProtoMsg(message: _544.SimpleValidator): _544.SimpleValidatorProtoMsg;
-        };
-        signedMsgTypeFromJSON(object: any): _543.SignedMsgType;
-        signedMsgTypeToJSON(object: _543.SignedMsgType): string;
-        SignedMsgType: typeof _543.SignedMsgType;
-        SignedMsgTypeAmino: typeof _543.SignedMsgType;
+            encode(message: _546.SimpleValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _546.SimpleValidator;
+            fromPartial(object: import("../helpers").DeepPartial<_546.SimpleValidator>): _546.SimpleValidator;
+            fromAmino(object: _546.SimpleValidatorAmino): _546.SimpleValidator;
+            toAmino(message: _546.SimpleValidator): _546.SimpleValidatorAmino;
+            fromAminoMsg(object: _546.SimpleValidatorAminoMsg): _546.SimpleValidator;
+            fromProtoMsg(message: _546.SimpleValidatorProtoMsg): _546.SimpleValidator;
+            toProto(message: _546.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _546.SimpleValidator): _546.SimpleValidatorProtoMsg;
+        };
+        signedMsgTypeFromJSON(object: any): _545.SignedMsgType;
+        signedMsgTypeToJSON(object: _545.SignedMsgType): string;
+        SignedMsgType: typeof _545.SignedMsgType;
+        SignedMsgTypeAmino: typeof _545.SignedMsgType;
         PartSetHeader: {
             typeUrl: string;
-            encode(message: _543.PartSetHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.PartSetHeader;
-            fromPartial(object: import("../helpers").DeepPartial<_543.PartSetHeader>): _543.PartSetHeader;
-            fromAmino(object: _543.PartSetHeaderAmino): _543.PartSetHeader;
-            toAmino(message: _543.PartSetHeader): _543.PartSetHeaderAmino;
-            fromAminoMsg(object: _543.PartSetHeaderAminoMsg): _543.PartSetHeader;
-            fromProtoMsg(message: _543.PartSetHeaderProtoMsg): _543.PartSetHeader;
-            toProto(message: _543.PartSetHeader): Uint8Array;
-            toProtoMsg(message: _543.PartSetHeader): _543.PartSetHeaderProtoMsg;
+            encode(message: _545.PartSetHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.PartSetHeader;
+            fromPartial(object: import("../helpers").DeepPartial<_545.PartSetHeader>): _545.PartSetHeader;
+            fromAmino(object: _545.PartSetHeaderAmino): _545.PartSetHeader;
+            toAmino(message: _545.PartSetHeader): _545.PartSetHeaderAmino;
+            fromAminoMsg(object: _545.PartSetHeaderAminoMsg): _545.PartSetHeader;
+            fromProtoMsg(message: _545.PartSetHeaderProtoMsg): _545.PartSetHeader;
+            toProto(message: _545.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _545.PartSetHeader): _545.PartSetHeaderProtoMsg;
         };
         Part: {
             typeUrl: string;
-            encode(message: _543.Part, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Part;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Part>): _543.Part;
-            fromAmino(object: _543.PartAmino): _543.Part;
-            toAmino(message: _543.Part): _543.PartAmino;
-            fromAminoMsg(object: _543.PartAminoMsg): _543.Part;
-            fromProtoMsg(message: _543.PartProtoMsg): _543.Part;
-            toProto(message: _543.Part): Uint8Array;
-            toProtoMsg(message: _543.Part): _543.PartProtoMsg;
+            encode(message: _545.Part, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Part;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Part>): _545.Part;
+            fromAmino(object: _545.PartAmino): _545.Part;
+            toAmino(message: _545.Part): _545.PartAmino;
+            fromAminoMsg(object: _545.PartAminoMsg): _545.Part;
+            fromProtoMsg(message: _545.PartProtoMsg): _545.Part;
+            toProto(message: _545.Part): Uint8Array;
+            toProtoMsg(message: _545.Part): _545.PartProtoMsg;
         };
         BlockID: {
             typeUrl: string;
-            encode(message: _543.BlockID, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.BlockID;
-            fromPartial(object: import("../helpers").DeepPartial<_543.BlockID>): _543.BlockID;
-            fromAmino(object: _543.BlockIDAmino): _543.BlockID;
-            toAmino(message: _543.BlockID): _543.BlockIDAmino;
-            fromAminoMsg(object: _543.BlockIDAminoMsg): _543.BlockID;
-            fromProtoMsg(message: _543.BlockIDProtoMsg): _543.BlockID;
-            toProto(message: _543.BlockID): Uint8Array;
-            toProtoMsg(message: _543.BlockID): _543.BlockIDProtoMsg;
+            encode(message: _545.BlockID, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.BlockID;
+            fromPartial(object: import("../helpers").DeepPartial<_545.BlockID>): _545.BlockID;
+            fromAmino(object: _545.BlockIDAmino): _545.BlockID;
+            toAmino(message: _545.BlockID): _545.BlockIDAmino;
+            fromAminoMsg(object: _545.BlockIDAminoMsg): _545.BlockID;
+            fromProtoMsg(message: _545.BlockIDProtoMsg): _545.BlockID;
+            toProto(message: _545.BlockID): Uint8Array;
+            toProtoMsg(message: _545.BlockID): _545.BlockIDProtoMsg;
         };
         Header: {
             typeUrl: string;
-            encode(message: _543.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Header;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Header>): _543.Header;
-            fromAmino(object: _543.HeaderAmino): _543.Header;
-            toAmino(message: _543.Header): _543.HeaderAmino;
-            fromAminoMsg(object: _543.HeaderAminoMsg): _543.Header;
-            fromProtoMsg(message: _543.HeaderProtoMsg): _543.Header;
-            toProto(message: _543.Header): Uint8Array;
-            toProtoMsg(message: _543.Header): _543.HeaderProtoMsg;
+            encode(message: _545.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Header;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Header>): _545.Header;
+            fromAmino(object: _545.HeaderAmino): _545.Header;
+            toAmino(message: _545.Header): _545.HeaderAmino;
+            fromAminoMsg(object: _545.HeaderAminoMsg): _545.Header;
+            fromProtoMsg(message: _545.HeaderProtoMsg): _545.Header;
+            toProto(message: _545.Header): Uint8Array;
+            toProtoMsg(message: _545.Header): _545.HeaderProtoMsg;
         };
         Data: {
             typeUrl: string;
-            encode(message: _543.Data, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Data;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Data>): _543.Data;
-            fromAmino(object: _543.DataAmino): _543.Data;
-            toAmino(message: _543.Data): _543.DataAmino;
-            fromAminoMsg(object: _543.DataAminoMsg): _543.Data;
-            fromProtoMsg(message: _543.DataProtoMsg): _543.Data;
-            toProto(message: _543.Data): Uint8Array;
-            toProtoMsg(message: _543.Data): _543.DataProtoMsg;
+            encode(message: _545.Data, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Data;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Data>): _545.Data;
+            fromAmino(object: _545.DataAmino): _545.Data;
+            toAmino(message: _545.Data): _545.DataAmino;
+            fromAminoMsg(object: _545.DataAminoMsg): _545.Data;
+            fromProtoMsg(message: _545.DataProtoMsg): _545.Data;
+            toProto(message: _545.Data): Uint8Array;
+            toProtoMsg(message: _545.Data): _545.DataProtoMsg;
         };
         Vote: {
             typeUrl: string;
-            encode(message: _543.Vote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Vote;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Vote>): _543.Vote;
-            fromAmino(object: _543.VoteAmino): _543.Vote;
-            toAmino(message: _543.Vote): _543.VoteAmino;
-            fromAminoMsg(object: _543.VoteAminoMsg): _543.Vote;
-            fromProtoMsg(message: _543.VoteProtoMsg): _543.Vote;
-            toProto(message: _543.Vote): Uint8Array;
-            toProtoMsg(message: _543.Vote): _543.VoteProtoMsg;
+            encode(message: _545.Vote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Vote;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Vote>): _545.Vote;
+            fromAmino(object: _545.VoteAmino): _545.Vote;
+            toAmino(message: _545.Vote): _545.VoteAmino;
+            fromAminoMsg(object: _545.VoteAminoMsg): _545.Vote;
+            fromProtoMsg(message: _545.VoteProtoMsg): _545.Vote;
+            toProto(message: _545.Vote): Uint8Array;
+            toProtoMsg(message: _545.Vote): _545.VoteProtoMsg;
         };
         Commit: {
             typeUrl: string;
-            encode(message: _543.Commit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Commit;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Commit>): _543.Commit;
-            fromAmino(object: _543.CommitAmino): _543.Commit;
-            toAmino(message: _543.Commit): _543.CommitAmino;
-            fromAminoMsg(object: _543.CommitAminoMsg): _543.Commit;
-            fromProtoMsg(message: _543.CommitProtoMsg): _543.Commit;
-            toProto(message: _543.Commit): Uint8Array;
-            toProtoMsg(message: _543.Commit): _543.CommitProtoMsg;
+            encode(message: _545.Commit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Commit;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Commit>): _545.Commit;
+            fromAmino(object: _545.CommitAmino): _545.Commit;
+            toAmino(message: _545.Commit): _545.CommitAmino;
+            fromAminoMsg(object: _545.CommitAminoMsg): _545.Commit;
+            fromProtoMsg(message: _545.CommitProtoMsg): _545.Commit;
+            toProto(message: _545.Commit): Uint8Array;
+            toProtoMsg(message: _545.Commit): _545.CommitProtoMsg;
         };
         CommitSig: {
             typeUrl: string;
-            encode(message: _543.CommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.CommitSig;
-            fromPartial(object: import("../helpers").DeepPartial<_543.CommitSig>): _543.CommitSig;
-            fromAmino(object: _543.CommitSigAmino): _543.CommitSig;
-            toAmino(message: _543.CommitSig): _543.CommitSigAmino;
-            fromAminoMsg(object: _543.CommitSigAminoMsg): _543.CommitSig;
-            fromProtoMsg(message: _543.CommitSigProtoMsg): _543.CommitSig;
-            toProto(message: _543.CommitSig): Uint8Array;
-            toProtoMsg(message: _543.CommitSig): _543.CommitSigProtoMsg;
+            encode(message: _545.CommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.CommitSig;
+            fromPartial(object: import("../helpers").DeepPartial<_545.CommitSig>): _545.CommitSig;
+            fromAmino(object: _545.CommitSigAmino): _545.CommitSig;
+            toAmino(message: _545.CommitSig): _545.CommitSigAmino;
+            fromAminoMsg(object: _545.CommitSigAminoMsg): _545.CommitSig;
+            fromProtoMsg(message: _545.CommitSigProtoMsg): _545.CommitSig;
+            toProto(message: _545.CommitSig): Uint8Array;
+            toProtoMsg(message: _545.CommitSig): _545.CommitSigProtoMsg;
         };
         ExtendedCommit: {
             typeUrl: string;
-            encode(message: _543.ExtendedCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.ExtendedCommit;
-            fromPartial(object: import("../helpers").DeepPartial<_543.ExtendedCommit>): _543.ExtendedCommit;
-            fromAmino(object: _543.ExtendedCommitAmino): _543.ExtendedCommit;
-            toAmino(message: _543.ExtendedCommit): _543.ExtendedCommitAmino;
-            fromAminoMsg(object: _543.ExtendedCommitAminoMsg): _543.ExtendedCommit;
-            fromProtoMsg(message: _543.ExtendedCommitProtoMsg): _543.ExtendedCommit;
-            toProto(message: _543.ExtendedCommit): Uint8Array;
-            toProtoMsg(message: _543.ExtendedCommit): _543.ExtendedCommitProtoMsg;
+            encode(message: _545.ExtendedCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.ExtendedCommit;
+            fromPartial(object: import("../helpers").DeepPartial<_545.ExtendedCommit>): _545.ExtendedCommit;
+            fromAmino(object: _545.ExtendedCommitAmino): _545.ExtendedCommit;
+            toAmino(message: _545.ExtendedCommit): _545.ExtendedCommitAmino;
+            fromAminoMsg(object: _545.ExtendedCommitAminoMsg): _545.ExtendedCommit;
+            fromProtoMsg(message: _545.ExtendedCommitProtoMsg): _545.ExtendedCommit;
+            toProto(message: _545.ExtendedCommit): Uint8Array;
+            toProtoMsg(message: _545.ExtendedCommit): _545.ExtendedCommitProtoMsg;
         };
         ExtendedCommitSig: {
             typeUrl: string;
-            encode(message: _543.ExtendedCommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.ExtendedCommitSig;
-            fromPartial(object: import("../helpers").DeepPartial<_543.ExtendedCommitSig>): _543.ExtendedCommitSig;
-            fromAmino(object: _543.ExtendedCommitSigAmino): _543.ExtendedCommitSig;
-            toAmino(message: _543.ExtendedCommitSig): _543.ExtendedCommitSigAmino;
-            fromAminoMsg(object: _543.ExtendedCommitSigAminoMsg): _543.ExtendedCommitSig;
-            fromProtoMsg(message: _543.ExtendedCommitSigProtoMsg): _543.ExtendedCommitSig;
-            toProto(message: _543.ExtendedCommitSig): Uint8Array;
-            toProtoMsg(message: _543.ExtendedCommitSig): _543.ExtendedCommitSigProtoMsg;
+            encode(message: _545.ExtendedCommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.ExtendedCommitSig;
+            fromPartial(object: import("../helpers").DeepPartial<_545.ExtendedCommitSig>): _545.ExtendedCommitSig;
+            fromAmino(object: _545.ExtendedCommitSigAmino): _545.ExtendedCommitSig;
+            toAmino(message: _545.ExtendedCommitSig): _545.ExtendedCommitSigAmino;
+            fromAminoMsg(object: _545.ExtendedCommitSigAminoMsg): _545.ExtendedCommitSig;
+            fromProtoMsg(message: _545.ExtendedCommitSigProtoMsg): _545.ExtendedCommitSig;
+            toProto(message: _545.ExtendedCommitSig): Uint8Array;
+            toProtoMsg(message: _545.ExtendedCommitSig): _545.ExtendedCommitSigProtoMsg;
         };
         Proposal: {
             typeUrl: string;
-            encode(message: _543.Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Proposal;
-            fromPartial(object: import("../helpers").DeepPartial<_543.Proposal>): _543.Proposal;
-            fromAmino(object: _543.ProposalAmino): _543.Proposal;
-            toAmino(message: _543.Proposal): _543.ProposalAmino;
-            fromAminoMsg(object: _543.ProposalAminoMsg): _543.Proposal;
-            fromProtoMsg(message: _543.ProposalProtoMsg): _543.Proposal;
-            toProto(message: _543.Proposal): Uint8Array;
-            toProtoMsg(message: _543.Proposal): _543.ProposalProtoMsg;
+            encode(message: _545.Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Proposal;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Proposal>): _545.Proposal;
+            fromAmino(object: _545.ProposalAmino): _545.Proposal;
+            toAmino(message: _545.Proposal): _545.ProposalAmino;
+            fromAminoMsg(object: _545.ProposalAminoMsg): _545.Proposal;
+            fromProtoMsg(message: _545.ProposalProtoMsg): _545.Proposal;
+            toProto(message: _545.Proposal): Uint8Array;
+            toProtoMsg(message: _545.Proposal): _545.ProposalProtoMsg;
         };
         SignedHeader: {
             typeUrl: string;
-            encode(message: _543.SignedHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.SignedHeader;
-            fromPartial(object: import("../helpers").DeepPartial<_543.SignedHeader>): _543.SignedHeader;
-            fromAmino(object: _543.SignedHeaderAmino): _543.SignedHeader;
-            toAmino(message: _543.SignedHeader): _543.SignedHeaderAmino;
-            fromAminoMsg(object: _543.SignedHeaderAminoMsg): _543.SignedHeader;
-            fromProtoMsg(message: _543.SignedHeaderProtoMsg): _543.SignedHeader;
-            toProto(message: _543.SignedHeader): Uint8Array;
-            toProtoMsg(message: _543.SignedHeader): _543.SignedHeaderProtoMsg;
+            encode(message: _545.SignedHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.SignedHeader;
+            fromPartial(object: import("../helpers").DeepPartial<_545.SignedHeader>): _545.SignedHeader;
+            fromAmino(object: _545.SignedHeaderAmino): _545.SignedHeader;
+            toAmino(message: _545.SignedHeader): _545.SignedHeaderAmino;
+            fromAminoMsg(object: _545.SignedHeaderAminoMsg): _545.SignedHeader;
+            fromProtoMsg(message: _545.SignedHeaderProtoMsg): _545.SignedHeader;
+            toProto(message: _545.SignedHeader): Uint8Array;
+            toProtoMsg(message: _545.SignedHeader): _545.SignedHeaderProtoMsg;
         };
         LightBlock: {
             typeUrl: string;
-            encode(message: _543.LightBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.LightBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_543.LightBlock>): _543.LightBlock;
-            fromAmino(object: _543.LightBlockAmino): _543.LightBlock;
-            toAmino(message: _543.LightBlock): _543.LightBlockAmino;
-            fromAminoMsg(object: _543.LightBlockAminoMsg): _543.LightBlock;
-            fromProtoMsg(message: _543.LightBlockProtoMsg): _543.LightBlock;
-            toProto(message: _543.LightBlock): Uint8Array;
-            toProtoMsg(message: _543.LightBlock): _543.LightBlockProtoMsg;
+            encode(message: _545.LightBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.LightBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_545.LightBlock>): _545.LightBlock;
+            fromAmino(object: _545.LightBlockAmino): _545.LightBlock;
+            toAmino(message: _545.LightBlock): _545.LightBlockAmino;
+            fromAminoMsg(object: _545.LightBlockAminoMsg): _545.LightBlock;
+            fromProtoMsg(message: _545.LightBlockProtoMsg): _545.LightBlock;
+            toProto(message: _545.LightBlock): Uint8Array;
+            toProtoMsg(message: _545.LightBlock): _545.LightBlockProtoMsg;
         };
         BlockMeta: {
             typeUrl: string;
-            encode(message: _543.BlockMeta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.BlockMeta;
-            fromPartial(object: import("../helpers").DeepPartial<_543.BlockMeta>): _543.BlockMeta;
-            fromAmino(object: _543.BlockMetaAmino): _543.BlockMeta;
-            toAmino(message: _543.BlockMeta): _543.BlockMetaAmino;
-            fromAminoMsg(object: _543.BlockMetaAminoMsg): _543.BlockMeta;
-            fromProtoMsg(message: _543.BlockMetaProtoMsg): _543.BlockMeta;
-            toProto(message: _543.BlockMeta): Uint8Array;
-            toProtoMsg(message: _543.BlockMeta): _543.BlockMetaProtoMsg;
+            encode(message: _545.BlockMeta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.BlockMeta;
+            fromPartial(object: import("../helpers").DeepPartial<_545.BlockMeta>): _545.BlockMeta;
+            fromAmino(object: _545.BlockMetaAmino): _545.BlockMeta;
+            toAmino(message: _545.BlockMeta): _545.BlockMetaAmino;
+            fromAminoMsg(object: _545.BlockMetaAminoMsg): _545.BlockMeta;
+            fromProtoMsg(message: _545.BlockMetaProtoMsg): _545.BlockMeta;
+            toProto(message: _545.BlockMeta): Uint8Array;
+            toProtoMsg(message: _545.BlockMeta): _545.BlockMetaProtoMsg;
         };
         TxProof: {
             typeUrl: string;
-            encode(message: _543.TxProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.TxProof;
-            fromPartial(object: import("../helpers").DeepPartial<_543.TxProof>): _543.TxProof;
-            fromAmino(object: _543.TxProofAmino): _543.TxProof;
-            toAmino(message: _543.TxProof): _543.TxProofAmino;
-            fromAminoMsg(object: _543.TxProofAminoMsg): _543.TxProof;
-            fromProtoMsg(message: _543.TxProofProtoMsg): _543.TxProof;
-            toProto(message: _543.TxProof): Uint8Array;
-            toProtoMsg(message: _543.TxProof): _543.TxProofProtoMsg;
+            encode(message: _545.TxProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.TxProof;
+            fromPartial(object: import("../helpers").DeepPartial<_545.TxProof>): _545.TxProof;
+            fromAmino(object: _545.TxProofAmino): _545.TxProof;
+            toAmino(message: _545.TxProof): _545.TxProofAmino;
+            fromAminoMsg(object: _545.TxProofAminoMsg): _545.TxProof;
+            fromProtoMsg(message: _545.TxProofProtoMsg): _545.TxProof;
+            toProto(message: _545.TxProof): Uint8Array;
+            toProtoMsg(message: _545.TxProof): _545.TxProofProtoMsg;
         };
         ConsensusParams: {
             typeUrl: string;
-            encode(message: _542.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ConsensusParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.ConsensusParams>): _542.ConsensusParams;
-            fromAmino(object: _542.ConsensusParamsAmino): _542.ConsensusParams;
-            toAmino(message: _542.ConsensusParams): _542.ConsensusParamsAmino;
-            fromAminoMsg(object: _542.ConsensusParamsAminoMsg): _542.ConsensusParams;
-            fromProtoMsg(message: _542.ConsensusParamsProtoMsg): _542.ConsensusParams;
-            toProto(message: _542.ConsensusParams): Uint8Array;
-            toProtoMsg(message: _542.ConsensusParams): _542.ConsensusParamsProtoMsg;
+            encode(message: _544.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.ConsensusParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.ConsensusParams>): _544.ConsensusParams;
+            fromAmino(object: _544.ConsensusParamsAmino): _544.ConsensusParams;
+            toAmino(message: _544.ConsensusParams): _544.ConsensusParamsAmino;
+            fromAminoMsg(object: _544.ConsensusParamsAminoMsg): _544.ConsensusParams;
+            fromProtoMsg(message: _544.ConsensusParamsProtoMsg): _544.ConsensusParams;
+            toProto(message: _544.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _544.ConsensusParams): _544.ConsensusParamsProtoMsg;
         };
         BlockParams: {
             typeUrl: string;
-            encode(message: _542.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.BlockParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.BlockParams>): _542.BlockParams;
-            fromAmino(object: _542.BlockParamsAmino): _542.BlockParams;
-            toAmino(message: _542.BlockParams): _542.BlockParamsAmino;
-            fromAminoMsg(object: _542.BlockParamsAminoMsg): _542.BlockParams;
-            fromProtoMsg(message: _542.BlockParamsProtoMsg): _542.BlockParams;
-            toProto(message: _542.BlockParams): Uint8Array;
-            toProtoMsg(message: _542.BlockParams): _542.BlockParamsProtoMsg;
+            encode(message: _544.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.BlockParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.BlockParams>): _544.BlockParams;
+            fromAmino(object: _544.BlockParamsAmino): _544.BlockParams;
+            toAmino(message: _544.BlockParams): _544.BlockParamsAmino;
+            fromAminoMsg(object: _544.BlockParamsAminoMsg): _544.BlockParams;
+            fromProtoMsg(message: _544.BlockParamsProtoMsg): _544.BlockParams;
+            toProto(message: _544.BlockParams): Uint8Array;
+            toProtoMsg(message: _544.BlockParams): _544.BlockParamsProtoMsg;
         };
         EvidenceParams: {
             typeUrl: string;
-            encode(message: _542.EvidenceParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.EvidenceParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.EvidenceParams>): _542.EvidenceParams;
-            fromAmino(object: _542.EvidenceParamsAmino): _542.EvidenceParams;
-            toAmino(message: _542.EvidenceParams): _542.EvidenceParamsAmino;
-            fromAminoMsg(object: _542.EvidenceParamsAminoMsg): _542.EvidenceParams;
-            fromProtoMsg(message: _542.EvidenceParamsProtoMsg): _542.EvidenceParams;
-            toProto(message: _542.EvidenceParams): Uint8Array;
-            toProtoMsg(message: _542.EvidenceParams): _542.EvidenceParamsProtoMsg;
+            encode(message: _544.EvidenceParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.EvidenceParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.EvidenceParams>): _544.EvidenceParams;
+            fromAmino(object: _544.EvidenceParamsAmino): _544.EvidenceParams;
+            toAmino(message: _544.EvidenceParams): _544.EvidenceParamsAmino;
+            fromAminoMsg(object: _544.EvidenceParamsAminoMsg): _544.EvidenceParams;
+            fromProtoMsg(message: _544.EvidenceParamsProtoMsg): _544.EvidenceParams;
+            toProto(message: _544.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _544.EvidenceParams): _544.EvidenceParamsProtoMsg;
         };
         ValidatorParams: {
             typeUrl: string;
-            encode(message: _542.ValidatorParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ValidatorParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.ValidatorParams>): _542.ValidatorParams;
-            fromAmino(object: _542.ValidatorParamsAmino): _542.ValidatorParams;
-            toAmino(message: _542.ValidatorParams): _542.ValidatorParamsAmino;
-            fromAminoMsg(object: _542.ValidatorParamsAminoMsg): _542.ValidatorParams;
-            fromProtoMsg(message: _542.ValidatorParamsProtoMsg): _542.ValidatorParams;
-            toProto(message: _542.ValidatorParams): Uint8Array;
-            toProtoMsg(message: _542.ValidatorParams): _542.ValidatorParamsProtoMsg;
+            encode(message: _544.ValidatorParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.ValidatorParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.ValidatorParams>): _544.ValidatorParams;
+            fromAmino(object: _544.ValidatorParamsAmino): _544.ValidatorParams;
+            toAmino(message: _544.ValidatorParams): _544.ValidatorParamsAmino;
+            fromAminoMsg(object: _544.ValidatorParamsAminoMsg): _544.ValidatorParams;
+            fromProtoMsg(message: _544.ValidatorParamsProtoMsg): _544.ValidatorParams;
+            toProto(message: _544.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _544.ValidatorParams): _544.ValidatorParamsProtoMsg;
         };
         VersionParams: {
             typeUrl: string;
-            encode(message: _542.VersionParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.VersionParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.VersionParams>): _542.VersionParams;
-            fromAmino(object: _542.VersionParamsAmino): _542.VersionParams;
-            toAmino(message: _542.VersionParams): _542.VersionParamsAmino;
-            fromAminoMsg(object: _542.VersionParamsAminoMsg): _542.VersionParams;
-            fromProtoMsg(message: _542.VersionParamsProtoMsg): _542.VersionParams;
-            toProto(message: _542.VersionParams): Uint8Array;
-            toProtoMsg(message: _542.VersionParams): _542.VersionParamsProtoMsg;
+            encode(message: _544.VersionParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.VersionParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.VersionParams>): _544.VersionParams;
+            fromAmino(object: _544.VersionParamsAmino): _544.VersionParams;
+            toAmino(message: _544.VersionParams): _544.VersionParamsAmino;
+            fromAminoMsg(object: _544.VersionParamsAminoMsg): _544.VersionParams;
+            fromProtoMsg(message: _544.VersionParamsProtoMsg): _544.VersionParams;
+            toProto(message: _544.VersionParams): Uint8Array;
+            toProtoMsg(message: _544.VersionParams): _544.VersionParamsProtoMsg;
         };
         HashedParams: {
             typeUrl: string;
-            encode(message: _542.HashedParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.HashedParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.HashedParams>): _542.HashedParams;
-            fromAmino(object: _542.HashedParamsAmino): _542.HashedParams;
-            toAmino(message: _542.HashedParams): _542.HashedParamsAmino;
-            fromAminoMsg(object: _542.HashedParamsAminoMsg): _542.HashedParams;
-            fromProtoMsg(message: _542.HashedParamsProtoMsg): _542.HashedParams;
-            toProto(message: _542.HashedParams): Uint8Array;
-            toProtoMsg(message: _542.HashedParams): _542.HashedParamsProtoMsg;
+            encode(message: _544.HashedParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.HashedParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.HashedParams>): _544.HashedParams;
+            fromAmino(object: _544.HashedParamsAmino): _544.HashedParams;
+            toAmino(message: _544.HashedParams): _544.HashedParamsAmino;
+            fromAminoMsg(object: _544.HashedParamsAminoMsg): _544.HashedParams;
+            fromProtoMsg(message: _544.HashedParamsProtoMsg): _544.HashedParams;
+            toProto(message: _544.HashedParams): Uint8Array;
+            toProtoMsg(message: _544.HashedParams): _544.HashedParamsProtoMsg;
         };
         ABCIParams: {
             typeUrl: string;
-            encode(message: _542.ABCIParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ABCIParams;
-            fromPartial(object: import("../helpers").DeepPartial<_542.ABCIParams>): _542.ABCIParams;
-            fromAmino(object: _542.ABCIParamsAmino): _542.ABCIParams;
-            toAmino(message: _542.ABCIParams): _542.ABCIParamsAmino;
-            fromAminoMsg(object: _542.ABCIParamsAminoMsg): _542.ABCIParams;
-            fromProtoMsg(message: _542.ABCIParamsProtoMsg): _542.ABCIParams;
-            toProto(message: _542.ABCIParams): Uint8Array;
-            toProtoMsg(message: _542.ABCIParams): _542.ABCIParamsProtoMsg;
+            encode(message: _544.ABCIParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.ABCIParams;
+            fromPartial(object: import("../helpers").DeepPartial<_544.ABCIParams>): _544.ABCIParams;
+            fromAmino(object: _544.ABCIParamsAmino): _544.ABCIParams;
+            toAmino(message: _544.ABCIParams): _544.ABCIParamsAmino;
+            fromAminoMsg(object: _544.ABCIParamsAminoMsg): _544.ABCIParams;
+            fromProtoMsg(message: _544.ABCIParamsProtoMsg): _544.ABCIParams;
+            toProto(message: _544.ABCIParams): Uint8Array;
+            toProtoMsg(message: _544.ABCIParams): _544.ABCIParamsProtoMsg;
         };
         Evidence: {
             typeUrl: string;
-            encode(message: _541.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.Evidence;
-            fromPartial(object: import("../helpers").DeepPartial<_541.Evidence>): _541.Evidence;
-            fromAmino(object: _541.EvidenceAmino): _541.Evidence;
-            toAmino(message: _541.Evidence): _541.EvidenceAmino;
-            fromAminoMsg(object: _541.EvidenceAminoMsg): _541.Evidence;
-            fromProtoMsg(message: _541.EvidenceProtoMsg): _541.Evidence;
-            toProto(message: _541.Evidence): Uint8Array;
-            toProtoMsg(message: _541.Evidence): _541.EvidenceProtoMsg;
+            encode(message: _543.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Evidence;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Evidence>): _543.Evidence;
+            fromAmino(object: _543.EvidenceAmino): _543.Evidence;
+            toAmino(message: _543.Evidence): _543.EvidenceAmino;
+            fromAminoMsg(object: _543.EvidenceAminoMsg): _543.Evidence;
+            fromProtoMsg(message: _543.EvidenceProtoMsg): _543.Evidence;
+            toProto(message: _543.Evidence): Uint8Array;
+            toProtoMsg(message: _543.Evidence): _543.EvidenceProtoMsg;
         };
         DuplicateVoteEvidence: {
             typeUrl: string;
-            encode(message: _541.DuplicateVoteEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.DuplicateVoteEvidence;
-            fromPartial(object: import("../helpers").DeepPartial<_541.DuplicateVoteEvidence>): _541.DuplicateVoteEvidence;
-            fromAmino(object: _541.DuplicateVoteEvidenceAmino): _541.DuplicateVoteEvidence;
-            toAmino(message: _541.DuplicateVoteEvidence): _541.DuplicateVoteEvidenceAmino;
-            fromAminoMsg(object: _541.DuplicateVoteEvidenceAminoMsg): _541.DuplicateVoteEvidence;
-            fromProtoMsg(message: _541.DuplicateVoteEvidenceProtoMsg): _541.DuplicateVoteEvidence;
-            toProto(message: _541.DuplicateVoteEvidence): Uint8Array;
-            toProtoMsg(message: _541.DuplicateVoteEvidence): _541.DuplicateVoteEvidenceProtoMsg;
+            encode(message: _543.DuplicateVoteEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.DuplicateVoteEvidence;
+            fromPartial(object: import("../helpers").DeepPartial<_543.DuplicateVoteEvidence>): _543.DuplicateVoteEvidence;
+            fromAmino(object: _543.DuplicateVoteEvidenceAmino): _543.DuplicateVoteEvidence;
+            toAmino(message: _543.DuplicateVoteEvidence): _543.DuplicateVoteEvidenceAmino;
+            fromAminoMsg(object: _543.DuplicateVoteEvidenceAminoMsg): _543.DuplicateVoteEvidence;
+            fromProtoMsg(message: _543.DuplicateVoteEvidenceProtoMsg): _543.DuplicateVoteEvidence;
+            toProto(message: _543.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _543.DuplicateVoteEvidence): _543.DuplicateVoteEvidenceProtoMsg;
         };
         LightClientAttackEvidence: {
             typeUrl: string;
-            encode(message: _541.LightClientAttackEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.LightClientAttackEvidence;
-            fromPartial(object: import("../helpers").DeepPartial<_541.LightClientAttackEvidence>): _541.LightClientAttackEvidence;
-            fromAmino(object: _541.LightClientAttackEvidenceAmino): _541.LightClientAttackEvidence;
-            toAmino(message: _541.LightClientAttackEvidence): _541.LightClientAttackEvidenceAmino;
-            fromAminoMsg(object: _541.LightClientAttackEvidenceAminoMsg): _541.LightClientAttackEvidence;
-            fromProtoMsg(message: _541.LightClientAttackEvidenceProtoMsg): _541.LightClientAttackEvidence;
-            toProto(message: _541.LightClientAttackEvidence): Uint8Array;
-            toProtoMsg(message: _541.LightClientAttackEvidence): _541.LightClientAttackEvidenceProtoMsg;
+            encode(message: _543.LightClientAttackEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.LightClientAttackEvidence;
+            fromPartial(object: import("../helpers").DeepPartial<_543.LightClientAttackEvidence>): _543.LightClientAttackEvidence;
+            fromAmino(object: _543.LightClientAttackEvidenceAmino): _543.LightClientAttackEvidence;
+            toAmino(message: _543.LightClientAttackEvidence): _543.LightClientAttackEvidenceAmino;
+            fromAminoMsg(object: _543.LightClientAttackEvidenceAminoMsg): _543.LightClientAttackEvidence;
+            fromProtoMsg(message: _543.LightClientAttackEvidenceProtoMsg): _543.LightClientAttackEvidence;
+            toProto(message: _543.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _543.LightClientAttackEvidence): _543.LightClientAttackEvidenceProtoMsg;
         };
         EvidenceList: {
             typeUrl: string;
-            encode(message: _541.EvidenceList, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.EvidenceList;
-            fromPartial(object: import("../helpers").DeepPartial<_541.EvidenceList>): _541.EvidenceList;
-            fromAmino(object: _541.EvidenceListAmino): _541.EvidenceList;
-            toAmino(message: _541.EvidenceList): _541.EvidenceListAmino;
-            fromAminoMsg(object: _541.EvidenceListAminoMsg): _541.EvidenceList;
-            fromProtoMsg(message: _541.EvidenceListProtoMsg): _541.EvidenceList;
-            toProto(message: _541.EvidenceList): Uint8Array;
-            toProtoMsg(message: _541.EvidenceList): _541.EvidenceListProtoMsg;
+            encode(message: _543.EvidenceList, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.EvidenceList;
+            fromPartial(object: import("../helpers").DeepPartial<_543.EvidenceList>): _543.EvidenceList;
+            fromAmino(object: _543.EvidenceListAmino): _543.EvidenceList;
+            toAmino(message: _543.EvidenceList): _543.EvidenceListAmino;
+            fromAminoMsg(object: _543.EvidenceListAminoMsg): _543.EvidenceList;
+            fromProtoMsg(message: _543.EvidenceListProtoMsg): _543.EvidenceList;
+            toProto(message: _543.EvidenceList): Uint8Array;
+            toProtoMsg(message: _543.EvidenceList): _543.EvidenceListProtoMsg;
         };
         Block: {
             typeUrl: string;
-            encode(message: _540.Block, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.Block;
-            fromPartial(object: import("../helpers").DeepPartial<_540.Block>): _540.Block;
-            fromAmino(object: _540.BlockAmino): _540.Block;
-            toAmino(message: _540.Block): _540.BlockAmino;
-            fromAminoMsg(object: _540.BlockAminoMsg): _540.Block;
-            fromProtoMsg(message: _540.BlockProtoMsg): _540.Block;
-            toProto(message: _540.Block): Uint8Array;
-            toProtoMsg(message: _540.Block): _540.BlockProtoMsg;
+            encode(message: _542.Block, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.Block;
+            fromPartial(object: import("../helpers").DeepPartial<_542.Block>): _542.Block;
+            fromAmino(object: _542.BlockAmino): _542.Block;
+            toAmino(message: _542.Block): _542.BlockAmino;
+            fromAminoMsg(object: _542.BlockAminoMsg): _542.Block;
+            fromProtoMsg(message: _542.BlockProtoMsg): _542.Block;
+            toProto(message: _542.Block): Uint8Array;
+            toProtoMsg(message: _542.Block): _542.BlockProtoMsg;
         };
     };
     const version: {
         App: {
             typeUrl: string;
-            encode(message: _545.App, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.App;
-            fromPartial(object: import("../helpers").DeepPartial<_545.App>): _545.App;
-            fromAmino(object: _545.AppAmino): _545.App;
-            toAmino(message: _545.App): _545.AppAmino;
-            fromAminoMsg(object: _545.AppAminoMsg): _545.App;
-            fromProtoMsg(message: _545.AppProtoMsg): _545.App;
-            toProto(message: _545.App): Uint8Array;
-            toProtoMsg(message: _545.App): _545.AppProtoMsg;
+            encode(message: _547.App, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _547.App;
+            fromPartial(object: import("../helpers").DeepPartial<_547.App>): _547.App;
+            fromAmino(object: _547.AppAmino): _547.App;
+            toAmino(message: _547.App): _547.AppAmino;
+            fromAminoMsg(object: _547.AppAminoMsg): _547.App;
+            fromProtoMsg(message: _547.AppProtoMsg): _547.App;
+            toProto(message: _547.App): Uint8Array;
+            toProtoMsg(message: _547.App): _547.AppProtoMsg;
         };
         Consensus: {
             typeUrl: string;
-            encode(message: _545.Consensus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Consensus;
-            fromPartial(object: import("../helpers").DeepPartial<_545.Consensus>): _545.Consensus;
-            fromAmino(object: _545.ConsensusAmino): _545.Consensus;
-            toAmino(message: _545.Consensus): _545.ConsensusAmino;
-            fromAminoMsg(object: _545.ConsensusAminoMsg): _545.Consensus;
-            fromProtoMsg(message: _545.ConsensusProtoMsg): _545.Consensus;
-            toProto(message: _545.Consensus): Uint8Array;
-            toProtoMsg(message: _545.Consensus): _545.ConsensusProtoMsg;
+            encode(message: _547.Consensus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _547.Consensus;
+            fromPartial(object: import("../helpers").DeepPartial<_547.Consensus>): _547.Consensus;
+            fromAmino(object: _547.ConsensusAmino): _547.Consensus;
+            toAmino(message: _547.Consensus): _547.ConsensusAmino;
+            fromAminoMsg(object: _547.ConsensusAminoMsg): _547.Consensus;
+            fromProtoMsg(message: _547.ConsensusProtoMsg): _547.Consensus;
+            toProto(message: _547.Consensus): Uint8Array;
+            toProtoMsg(message: _547.Consensus): _547.ConsensusProtoMsg;
         };
     };
 }