@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.19

package/tendermint/bundle.d.ts

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