@sparkdreamnft/sparkdreamjs 0.0.47 → 0.0.49

package/tendermint/bundle.d.ts

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