@agoric/cosmic-proto 0.4.1-dev-286302a.0 → 0.4.1-dev-24f7f32.0

package/dist/codegen/tendermint/bundle.d.ts

@@ -1,583 +1,583 @@
-import * as _119 from './abci/types.js';
-import * as _120 from './crypto/keys.js';
-import * as _121 from './crypto/proof.js';
-import * as _122 from './libs/bits/types.js';
-import * as _123 from './p2p/types.js';
-import * as _124 from './types/block.js';
-import * as _125 from './types/evidence.js';
-import * as _126 from './types/params.js';
-import * as _127 from './types/types.js';
-import * as _128 from './types/validator.js';
-import * as _129 from './version/types.js';
+import * as _124 from './abci/types.js';
+import * as _125 from './crypto/keys.js';
+import * as _126 from './crypto/proof.js';
+import * as _127 from './libs/bits/types.js';
+import * as _128 from './p2p/types.js';
+import * as _129 from './types/block.js';
+import * as _130 from './types/evidence.js';
+import * as _131 from './types/params.js';
+import * as _132 from './types/types.js';
+import * as _133 from './types/validator.js';
+import * as _134 from './version/types.js';
 export declare namespace tendermint {
     const abci: {
-        checkTxTypeFromJSON(object: any): _119.CheckTxType;
+        checkTxTypeFromJSON(object: any): _124.CheckTxType;
         checkTxTypeToJSON(object: CheckTxType): string;
-        responseOfferSnapshot_ResultFromJSON(object: any): _119.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultFromJSON(object: any): _124.ResponseOfferSnapshot_Result;
         responseOfferSnapshot_ResultToJSON(object: ResponseOfferSnapshot_Result): string;
-        responseApplySnapshotChunk_ResultFromJSON(object: any): _119.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _124.ResponseApplySnapshotChunk_Result;
         responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySnapshotChunk_Result): string;
-        evidenceTypeFromJSON(object: any): _119.EvidenceType;
+        evidenceTypeFromJSON(object: any): _124.EvidenceType;
         evidenceTypeToJSON(object: EvidenceType): string;
-        CheckTxType: typeof _119.CheckTxType;
-        CheckTxTypeSDKType: typeof _119.CheckTxType;
-        ResponseOfferSnapshot_Result: typeof _119.ResponseOfferSnapshot_Result;
-        ResponseOfferSnapshot_ResultSDKType: typeof _119.ResponseOfferSnapshot_Result;
-        ResponseApplySnapshotChunk_Result: typeof _119.ResponseApplySnapshotChunk_Result;
-        ResponseApplySnapshotChunk_ResultSDKType: typeof _119.ResponseApplySnapshotChunk_Result;
-        EvidenceType: typeof _119.EvidenceType;
-        EvidenceTypeSDKType: typeof _119.EvidenceType;
+        CheckTxType: typeof _124.CheckTxType;
+        CheckTxTypeSDKType: typeof _124.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _124.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultSDKType: typeof _124.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _124.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultSDKType: typeof _124.ResponseApplySnapshotChunk_Result;
+        EvidenceType: typeof _124.EvidenceType;
+        EvidenceTypeSDKType: typeof _124.EvidenceType;
         Request: {
             typeUrl: string;
             encode(message: Request, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Request;
-            fromJSON(object: any): _119.Request;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Request;
+            fromJSON(object: any): _124.Request;
             toJSON(message: Request): unknown;
-            fromPartial(object: Partial<Request>): _119.Request;
-            fromProtoMsg(message: RequestProtoMsg): _119.Request;
+            fromPartial(object: Partial<Request>): _124.Request;
+            fromProtoMsg(message: RequestProtoMsg): _124.Request;
             toProto(message: Request): Uint8Array;
-            toProtoMsg(message: Request): _119.RequestProtoMsg;
+            toProtoMsg(message: Request): _124.RequestProtoMsg;
         };
         RequestEcho: {
             typeUrl: string;
             encode(message: RequestEcho, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestEcho;
-            fromJSON(object: any): _119.RequestEcho;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestEcho;
+            fromJSON(object: any): _124.RequestEcho;
             toJSON(message: RequestEcho): unknown;
-            fromPartial(object: Partial<RequestEcho>): _119.RequestEcho;
-            fromProtoMsg(message: RequestEchoProtoMsg): _119.RequestEcho;
+            fromPartial(object: Partial<RequestEcho>): _124.RequestEcho;
+            fromProtoMsg(message: RequestEchoProtoMsg): _124.RequestEcho;
             toProto(message: RequestEcho): Uint8Array;
-            toProtoMsg(message: RequestEcho): _119.RequestEchoProtoMsg;
+            toProtoMsg(message: RequestEcho): _124.RequestEchoProtoMsg;
         };
         RequestFlush: {
             typeUrl: string;
             encode(_: RequestFlush, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestFlush;
-            fromJSON(_: any): _119.RequestFlush;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestFlush;
+            fromJSON(_: any): _124.RequestFlush;
             toJSON(_: RequestFlush): unknown;
-            fromPartial(_: Partial<RequestFlush>): _119.RequestFlush;
-            fromProtoMsg(message: RequestFlushProtoMsg): _119.RequestFlush;
+            fromPartial(_: Partial<RequestFlush>): _124.RequestFlush;
+            fromProtoMsg(message: RequestFlushProtoMsg): _124.RequestFlush;
             toProto(message: RequestFlush): Uint8Array;
-            toProtoMsg(message: RequestFlush): _119.RequestFlushProtoMsg;
+            toProtoMsg(message: RequestFlush): _124.RequestFlushProtoMsg;
         };
         RequestInfo: {
             typeUrl: string;
             encode(message: RequestInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestInfo;
-            fromJSON(object: any): _119.RequestInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestInfo;
+            fromJSON(object: any): _124.RequestInfo;
             toJSON(message: RequestInfo): unknown;
-            fromPartial(object: Partial<RequestInfo>): _119.RequestInfo;
-            fromProtoMsg(message: RequestInfoProtoMsg): _119.RequestInfo;
+            fromPartial(object: Partial<RequestInfo>): _124.RequestInfo;
+            fromProtoMsg(message: RequestInfoProtoMsg): _124.RequestInfo;
             toProto(message: RequestInfo): Uint8Array;
-            toProtoMsg(message: RequestInfo): _119.RequestInfoProtoMsg;
+            toProtoMsg(message: RequestInfo): _124.RequestInfoProtoMsg;
         };
         RequestSetOption: {
             typeUrl: string;
             encode(message: RequestSetOption, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestSetOption;
-            fromJSON(object: any): _119.RequestSetOption;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestSetOption;
+            fromJSON(object: any): _124.RequestSetOption;
             toJSON(message: RequestSetOption): unknown;
-            fromPartial(object: Partial<RequestSetOption>): _119.RequestSetOption;
-            fromProtoMsg(message: RequestSetOptionProtoMsg): _119.RequestSetOption;
+            fromPartial(object: Partial<RequestSetOption>): _124.RequestSetOption;
+            fromProtoMsg(message: RequestSetOptionProtoMsg): _124.RequestSetOption;
             toProto(message: RequestSetOption): Uint8Array;
-            toProtoMsg(message: RequestSetOption): _119.RequestSetOptionProtoMsg;
+            toProtoMsg(message: RequestSetOption): _124.RequestSetOptionProtoMsg;
         };
         RequestInitChain: {
             typeUrl: string;
             encode(message: RequestInitChain, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestInitChain;
-            fromJSON(object: any): _119.RequestInitChain;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestInitChain;
+            fromJSON(object: any): _124.RequestInitChain;
             toJSON(message: RequestInitChain): unknown;
-            fromPartial(object: Partial<RequestInitChain>): _119.RequestInitChain;
-            fromProtoMsg(message: RequestInitChainProtoMsg): _119.RequestInitChain;
+            fromPartial(object: Partial<RequestInitChain>): _124.RequestInitChain;
+            fromProtoMsg(message: RequestInitChainProtoMsg): _124.RequestInitChain;
             toProto(message: RequestInitChain): Uint8Array;
-            toProtoMsg(message: RequestInitChain): _119.RequestInitChainProtoMsg;
+            toProtoMsg(message: RequestInitChain): _124.RequestInitChainProtoMsg;
         };
         RequestQuery: {
             typeUrl: string;
             encode(message: RequestQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestQuery;
-            fromJSON(object: any): _119.RequestQuery;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestQuery;
+            fromJSON(object: any): _124.RequestQuery;
             toJSON(message: RequestQuery): unknown;
-            fromPartial(object: Partial<RequestQuery>): _119.RequestQuery;
-            fromProtoMsg(message: RequestQueryProtoMsg): _119.RequestQuery;
+            fromPartial(object: Partial<RequestQuery>): _124.RequestQuery;
+            fromProtoMsg(message: RequestQueryProtoMsg): _124.RequestQuery;
             toProto(message: RequestQuery): Uint8Array;
-            toProtoMsg(message: RequestQuery): _119.RequestQueryProtoMsg;
+            toProtoMsg(message: RequestQuery): _124.RequestQueryProtoMsg;
         };
         RequestBeginBlock: {
             typeUrl: string;
             encode(message: RequestBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestBeginBlock;
-            fromJSON(object: any): _119.RequestBeginBlock;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestBeginBlock;
+            fromJSON(object: any): _124.RequestBeginBlock;
             toJSON(message: RequestBeginBlock): unknown;
-            fromPartial(object: Partial<RequestBeginBlock>): _119.RequestBeginBlock;
-            fromProtoMsg(message: RequestBeginBlockProtoMsg): _119.RequestBeginBlock;
+            fromPartial(object: Partial<RequestBeginBlock>): _124.RequestBeginBlock;
+            fromProtoMsg(message: RequestBeginBlockProtoMsg): _124.RequestBeginBlock;
             toProto(message: RequestBeginBlock): Uint8Array;
-            toProtoMsg(message: RequestBeginBlock): _119.RequestBeginBlockProtoMsg;
+            toProtoMsg(message: RequestBeginBlock): _124.RequestBeginBlockProtoMsg;
         };
         RequestCheckTx: {
             typeUrl: string;
             encode(message: RequestCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestCheckTx;
-            fromJSON(object: any): _119.RequestCheckTx;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestCheckTx;
+            fromJSON(object: any): _124.RequestCheckTx;
             toJSON(message: RequestCheckTx): unknown;
-            fromPartial(object: Partial<RequestCheckTx>): _119.RequestCheckTx;
-            fromProtoMsg(message: RequestCheckTxProtoMsg): _119.RequestCheckTx;
+            fromPartial(object: Partial<RequestCheckTx>): _124.RequestCheckTx;
+            fromProtoMsg(message: RequestCheckTxProtoMsg): _124.RequestCheckTx;
             toProto(message: RequestCheckTx): Uint8Array;
-            toProtoMsg(message: RequestCheckTx): _119.RequestCheckTxProtoMsg;
+            toProtoMsg(message: RequestCheckTx): _124.RequestCheckTxProtoMsg;
         };
         RequestDeliverTx: {
             typeUrl: string;
             encode(message: RequestDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestDeliverTx;
-            fromJSON(object: any): _119.RequestDeliverTx;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestDeliverTx;
+            fromJSON(object: any): _124.RequestDeliverTx;
             toJSON(message: RequestDeliverTx): unknown;
-            fromPartial(object: Partial<RequestDeliverTx>): _119.RequestDeliverTx;
-            fromProtoMsg(message: RequestDeliverTxProtoMsg): _119.RequestDeliverTx;
+            fromPartial(object: Partial<RequestDeliverTx>): _124.RequestDeliverTx;
+            fromProtoMsg(message: RequestDeliverTxProtoMsg): _124.RequestDeliverTx;
             toProto(message: RequestDeliverTx): Uint8Array;
-            toProtoMsg(message: RequestDeliverTx): _119.RequestDeliverTxProtoMsg;
+            toProtoMsg(message: RequestDeliverTx): _124.RequestDeliverTxProtoMsg;
         };
         RequestEndBlock: {
             typeUrl: string;
             encode(message: RequestEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestEndBlock;
-            fromJSON(object: any): _119.RequestEndBlock;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestEndBlock;
+            fromJSON(object: any): _124.RequestEndBlock;
             toJSON(message: RequestEndBlock): unknown;
-            fromPartial(object: Partial<RequestEndBlock>): _119.RequestEndBlock;
-            fromProtoMsg(message: RequestEndBlockProtoMsg): _119.RequestEndBlock;
+            fromPartial(object: Partial<RequestEndBlock>): _124.RequestEndBlock;
+            fromProtoMsg(message: RequestEndBlockProtoMsg): _124.RequestEndBlock;
             toProto(message: RequestEndBlock): Uint8Array;
-            toProtoMsg(message: RequestEndBlock): _119.RequestEndBlockProtoMsg;
+            toProtoMsg(message: RequestEndBlock): _124.RequestEndBlockProtoMsg;
         };
         RequestCommit: {
             typeUrl: string;
             encode(_: RequestCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestCommit;
-            fromJSON(_: any): _119.RequestCommit;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestCommit;
+            fromJSON(_: any): _124.RequestCommit;
             toJSON(_: RequestCommit): unknown;
-            fromPartial(_: Partial<RequestCommit>): _119.RequestCommit;
-            fromProtoMsg(message: RequestCommitProtoMsg): _119.RequestCommit;
+            fromPartial(_: Partial<RequestCommit>): _124.RequestCommit;
+            fromProtoMsg(message: RequestCommitProtoMsg): _124.RequestCommit;
             toProto(message: RequestCommit): Uint8Array;
-            toProtoMsg(message: RequestCommit): _119.RequestCommitProtoMsg;
+            toProtoMsg(message: RequestCommit): _124.RequestCommitProtoMsg;
         };
         RequestListSnapshots: {
             typeUrl: string;
             encode(_: RequestListSnapshots, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestListSnapshots;
-            fromJSON(_: any): _119.RequestListSnapshots;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestListSnapshots;
+            fromJSON(_: any): _124.RequestListSnapshots;
             toJSON(_: RequestListSnapshots): unknown;
-            fromPartial(_: Partial<RequestListSnapshots>): _119.RequestListSnapshots;
-            fromProtoMsg(message: RequestListSnapshotsProtoMsg): _119.RequestListSnapshots;
+            fromPartial(_: Partial<RequestListSnapshots>): _124.RequestListSnapshots;
+            fromProtoMsg(message: RequestListSnapshotsProtoMsg): _124.RequestListSnapshots;
             toProto(message: RequestListSnapshots): Uint8Array;
-            toProtoMsg(message: RequestListSnapshots): _119.RequestListSnapshotsProtoMsg;
+            toProtoMsg(message: RequestListSnapshots): _124.RequestListSnapshotsProtoMsg;
         };
         RequestOfferSnapshot: {
             typeUrl: string;
             encode(message: RequestOfferSnapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestOfferSnapshot;
-            fromJSON(object: any): _119.RequestOfferSnapshot;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestOfferSnapshot;
+            fromJSON(object: any): _124.RequestOfferSnapshot;
             toJSON(message: RequestOfferSnapshot): unknown;
-            fromPartial(object: Partial<RequestOfferSnapshot>): _119.RequestOfferSnapshot;
-            fromProtoMsg(message: RequestOfferSnapshotProtoMsg): _119.RequestOfferSnapshot;
+            fromPartial(object: Partial<RequestOfferSnapshot>): _124.RequestOfferSnapshot;
+            fromProtoMsg(message: RequestOfferSnapshotProtoMsg): _124.RequestOfferSnapshot;
             toProto(message: RequestOfferSnapshot): Uint8Array;
-            toProtoMsg(message: RequestOfferSnapshot): _119.RequestOfferSnapshotProtoMsg;
+            toProtoMsg(message: RequestOfferSnapshot): _124.RequestOfferSnapshotProtoMsg;
         };
         RequestLoadSnapshotChunk: {
             typeUrl: string;
             encode(message: RequestLoadSnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestLoadSnapshotChunk;
-            fromJSON(object: any): _119.RequestLoadSnapshotChunk;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestLoadSnapshotChunk;
+            fromJSON(object: any): _124.RequestLoadSnapshotChunk;
             toJSON(message: RequestLoadSnapshotChunk): unknown;
-            fromPartial(object: Partial<RequestLoadSnapshotChunk>): _119.RequestLoadSnapshotChunk;
-            fromProtoMsg(message: RequestLoadSnapshotChunkProtoMsg): _119.RequestLoadSnapshotChunk;
+            fromPartial(object: Partial<RequestLoadSnapshotChunk>): _124.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: RequestLoadSnapshotChunkProtoMsg): _124.RequestLoadSnapshotChunk;
             toProto(message: RequestLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: RequestLoadSnapshotChunk): _119.RequestLoadSnapshotChunkProtoMsg;
+            toProtoMsg(message: RequestLoadSnapshotChunk): _124.RequestLoadSnapshotChunkProtoMsg;
         };
         RequestApplySnapshotChunk: {
             typeUrl: string;
             encode(message: RequestApplySnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.RequestApplySnapshotChunk;
-            fromJSON(object: any): _119.RequestApplySnapshotChunk;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.RequestApplySnapshotChunk;
+            fromJSON(object: any): _124.RequestApplySnapshotChunk;
             toJSON(message: RequestApplySnapshotChunk): unknown;
-            fromPartial(object: Partial<RequestApplySnapshotChunk>): _119.RequestApplySnapshotChunk;
-            fromProtoMsg(message: RequestApplySnapshotChunkProtoMsg): _119.RequestApplySnapshotChunk;
+            fromPartial(object: Partial<RequestApplySnapshotChunk>): _124.RequestApplySnapshotChunk;
+            fromProtoMsg(message: RequestApplySnapshotChunkProtoMsg): _124.RequestApplySnapshotChunk;
             toProto(message: RequestApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: RequestApplySnapshotChunk): _119.RequestApplySnapshotChunkProtoMsg;
+            toProtoMsg(message: RequestApplySnapshotChunk): _124.RequestApplySnapshotChunkProtoMsg;
         };
         Response: {
             typeUrl: string;
             encode(message: Response, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Response;
-            fromJSON(object: any): _119.Response;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Response;
+            fromJSON(object: any): _124.Response;
             toJSON(message: Response): unknown;
-            fromPartial(object: Partial<Response>): _119.Response;
-            fromProtoMsg(message: ResponseProtoMsg): _119.Response;
+            fromPartial(object: Partial<Response>): _124.Response;
+            fromProtoMsg(message: ResponseProtoMsg): _124.Response;
             toProto(message: Response): Uint8Array;
-            toProtoMsg(message: Response): _119.ResponseProtoMsg;
+            toProtoMsg(message: Response): _124.ResponseProtoMsg;
         };
         ResponseException: {
             typeUrl: string;
             encode(message: ResponseException, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseException;
-            fromJSON(object: any): _119.ResponseException;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseException;
+            fromJSON(object: any): _124.ResponseException;
             toJSON(message: ResponseException): unknown;
-            fromPartial(object: Partial<ResponseException>): _119.ResponseException;
-            fromProtoMsg(message: ResponseExceptionProtoMsg): _119.ResponseException;
+            fromPartial(object: Partial<ResponseException>): _124.ResponseException;
+            fromProtoMsg(message: ResponseExceptionProtoMsg): _124.ResponseException;
             toProto(message: ResponseException): Uint8Array;
-            toProtoMsg(message: ResponseException): _119.ResponseExceptionProtoMsg;
+            toProtoMsg(message: ResponseException): _124.ResponseExceptionProtoMsg;
         };
         ResponseEcho: {
             typeUrl: string;
             encode(message: ResponseEcho, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseEcho;
-            fromJSON(object: any): _119.ResponseEcho;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseEcho;
+            fromJSON(object: any): _124.ResponseEcho;
             toJSON(message: ResponseEcho): unknown;
-            fromPartial(object: Partial<ResponseEcho>): _119.ResponseEcho;
-            fromProtoMsg(message: ResponseEchoProtoMsg): _119.ResponseEcho;
+            fromPartial(object: Partial<ResponseEcho>): _124.ResponseEcho;
+            fromProtoMsg(message: ResponseEchoProtoMsg): _124.ResponseEcho;
             toProto(message: ResponseEcho): Uint8Array;
-            toProtoMsg(message: ResponseEcho): _119.ResponseEchoProtoMsg;
+            toProtoMsg(message: ResponseEcho): _124.ResponseEchoProtoMsg;
         };
         ResponseFlush: {
             typeUrl: string;
             encode(_: ResponseFlush, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseFlush;
-            fromJSON(_: any): _119.ResponseFlush;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseFlush;
+            fromJSON(_: any): _124.ResponseFlush;
             toJSON(_: ResponseFlush): unknown;
-            fromPartial(_: Partial<ResponseFlush>): _119.ResponseFlush;
-            fromProtoMsg(message: ResponseFlushProtoMsg): _119.ResponseFlush;
+            fromPartial(_: Partial<ResponseFlush>): _124.ResponseFlush;
+            fromProtoMsg(message: ResponseFlushProtoMsg): _124.ResponseFlush;
             toProto(message: ResponseFlush): Uint8Array;
-            toProtoMsg(message: ResponseFlush): _119.ResponseFlushProtoMsg;
+            toProtoMsg(message: ResponseFlush): _124.ResponseFlushProtoMsg;
         };
         ResponseInfo: {
             typeUrl: string;
             encode(message: ResponseInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseInfo;
-            fromJSON(object: any): _119.ResponseInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseInfo;
+            fromJSON(object: any): _124.ResponseInfo;
             toJSON(message: ResponseInfo): unknown;
-            fromPartial(object: Partial<ResponseInfo>): _119.ResponseInfo;
-            fromProtoMsg(message: ResponseInfoProtoMsg): _119.ResponseInfo;
+            fromPartial(object: Partial<ResponseInfo>): _124.ResponseInfo;
+            fromProtoMsg(message: ResponseInfoProtoMsg): _124.ResponseInfo;
             toProto(message: ResponseInfo): Uint8Array;
-            toProtoMsg(message: ResponseInfo): _119.ResponseInfoProtoMsg;
+            toProtoMsg(message: ResponseInfo): _124.ResponseInfoProtoMsg;
         };
         ResponseSetOption: {
             typeUrl: string;
             encode(message: ResponseSetOption, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseSetOption;
-            fromJSON(object: any): _119.ResponseSetOption;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseSetOption;
+            fromJSON(object: any): _124.ResponseSetOption;
             toJSON(message: ResponseSetOption): unknown;
-            fromPartial(object: Partial<ResponseSetOption>): _119.ResponseSetOption;
-            fromProtoMsg(message: ResponseSetOptionProtoMsg): _119.ResponseSetOption;
+            fromPartial(object: Partial<ResponseSetOption>): _124.ResponseSetOption;
+            fromProtoMsg(message: ResponseSetOptionProtoMsg): _124.ResponseSetOption;
             toProto(message: ResponseSetOption): Uint8Array;
-            toProtoMsg(message: ResponseSetOption): _119.ResponseSetOptionProtoMsg;
+            toProtoMsg(message: ResponseSetOption): _124.ResponseSetOptionProtoMsg;
         };
         ResponseInitChain: {
             typeUrl: string;
             encode(message: ResponseInitChain, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseInitChain;
-            fromJSON(object: any): _119.ResponseInitChain;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseInitChain;
+            fromJSON(object: any): _124.ResponseInitChain;
             toJSON(message: ResponseInitChain): unknown;
-            fromPartial(object: Partial<ResponseInitChain>): _119.ResponseInitChain;
-            fromProtoMsg(message: ResponseInitChainProtoMsg): _119.ResponseInitChain;
+            fromPartial(object: Partial<ResponseInitChain>): _124.ResponseInitChain;
+            fromProtoMsg(message: ResponseInitChainProtoMsg): _124.ResponseInitChain;
             toProto(message: ResponseInitChain): Uint8Array;
-            toProtoMsg(message: ResponseInitChain): _119.ResponseInitChainProtoMsg;
+            toProtoMsg(message: ResponseInitChain): _124.ResponseInitChainProtoMsg;
         };
         ResponseQuery: {
             typeUrl: string;
             encode(message: ResponseQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseQuery;
-            fromJSON(object: any): _119.ResponseQuery;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseQuery;
+            fromJSON(object: any): _124.ResponseQuery;
             toJSON(message: ResponseQuery): unknown;
-            fromPartial(object: Partial<ResponseQuery>): _119.ResponseQuery;
-            fromProtoMsg(message: ResponseQueryProtoMsg): _119.ResponseQuery;
+            fromPartial(object: Partial<ResponseQuery>): _124.ResponseQuery;
+            fromProtoMsg(message: ResponseQueryProtoMsg): _124.ResponseQuery;
             toProto(message: ResponseQuery): Uint8Array;
-            toProtoMsg(message: ResponseQuery): _119.ResponseQueryProtoMsg;
+            toProtoMsg(message: ResponseQuery): _124.ResponseQueryProtoMsg;
         };
         ResponseBeginBlock: {
             typeUrl: string;
             encode(message: ResponseBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseBeginBlock;
-            fromJSON(object: any): _119.ResponseBeginBlock;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseBeginBlock;
+            fromJSON(object: any): _124.ResponseBeginBlock;
             toJSON(message: ResponseBeginBlock): unknown;
-            fromPartial(object: Partial<ResponseBeginBlock>): _119.ResponseBeginBlock;
-            fromProtoMsg(message: ResponseBeginBlockProtoMsg): _119.ResponseBeginBlock;
+            fromPartial(object: Partial<ResponseBeginBlock>): _124.ResponseBeginBlock;
+            fromProtoMsg(message: ResponseBeginBlockProtoMsg): _124.ResponseBeginBlock;
             toProto(message: ResponseBeginBlock): Uint8Array;
-            toProtoMsg(message: ResponseBeginBlock): _119.ResponseBeginBlockProtoMsg;
+            toProtoMsg(message: ResponseBeginBlock): _124.ResponseBeginBlockProtoMsg;
         };
         ResponseCheckTx: {
             typeUrl: string;
             encode(message: ResponseCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseCheckTx;
-            fromJSON(object: any): _119.ResponseCheckTx;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseCheckTx;
+            fromJSON(object: any): _124.ResponseCheckTx;
             toJSON(message: ResponseCheckTx): unknown;
-            fromPartial(object: Partial<ResponseCheckTx>): _119.ResponseCheckTx;
-            fromProtoMsg(message: ResponseCheckTxProtoMsg): _119.ResponseCheckTx;
+            fromPartial(object: Partial<ResponseCheckTx>): _124.ResponseCheckTx;
+            fromProtoMsg(message: ResponseCheckTxProtoMsg): _124.ResponseCheckTx;
             toProto(message: ResponseCheckTx): Uint8Array;
-            toProtoMsg(message: ResponseCheckTx): _119.ResponseCheckTxProtoMsg;
+            toProtoMsg(message: ResponseCheckTx): _124.ResponseCheckTxProtoMsg;
         };
         ResponseDeliverTx: {
             typeUrl: string;
             encode(message: ResponseDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseDeliverTx;
-            fromJSON(object: any): _119.ResponseDeliverTx;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseDeliverTx;
+            fromJSON(object: any): _124.ResponseDeliverTx;
             toJSON(message: ResponseDeliverTx): unknown;
-            fromPartial(object: Partial<ResponseDeliverTx>): _119.ResponseDeliverTx;
-            fromProtoMsg(message: ResponseDeliverTxProtoMsg): _119.ResponseDeliverTx;
+            fromPartial(object: Partial<ResponseDeliverTx>): _124.ResponseDeliverTx;
+            fromProtoMsg(message: ResponseDeliverTxProtoMsg): _124.ResponseDeliverTx;
             toProto(message: ResponseDeliverTx): Uint8Array;
-            toProtoMsg(message: ResponseDeliverTx): _119.ResponseDeliverTxProtoMsg;
+            toProtoMsg(message: ResponseDeliverTx): _124.ResponseDeliverTxProtoMsg;
         };
         ResponseEndBlock: {
             typeUrl: string;
             encode(message: ResponseEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseEndBlock;
-            fromJSON(object: any): _119.ResponseEndBlock;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseEndBlock;
+            fromJSON(object: any): _124.ResponseEndBlock;
             toJSON(message: ResponseEndBlock): unknown;
-            fromPartial(object: Partial<ResponseEndBlock>): _119.ResponseEndBlock;
-            fromProtoMsg(message: ResponseEndBlockProtoMsg): _119.ResponseEndBlock;
+            fromPartial(object: Partial<ResponseEndBlock>): _124.ResponseEndBlock;
+            fromProtoMsg(message: ResponseEndBlockProtoMsg): _124.ResponseEndBlock;
             toProto(message: ResponseEndBlock): Uint8Array;
-            toProtoMsg(message: ResponseEndBlock): _119.ResponseEndBlockProtoMsg;
+            toProtoMsg(message: ResponseEndBlock): _124.ResponseEndBlockProtoMsg;
         };
         ResponseCommit: {
             typeUrl: string;
             encode(message: ResponseCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseCommit;
-            fromJSON(object: any): _119.ResponseCommit;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseCommit;
+            fromJSON(object: any): _124.ResponseCommit;
             toJSON(message: ResponseCommit): unknown;
-            fromPartial(object: Partial<ResponseCommit>): _119.ResponseCommit;
-            fromProtoMsg(message: ResponseCommitProtoMsg): _119.ResponseCommit;
+            fromPartial(object: Partial<ResponseCommit>): _124.ResponseCommit;
+            fromProtoMsg(message: ResponseCommitProtoMsg): _124.ResponseCommit;
             toProto(message: ResponseCommit): Uint8Array;
-            toProtoMsg(message: ResponseCommit): _119.ResponseCommitProtoMsg;
+            toProtoMsg(message: ResponseCommit): _124.ResponseCommitProtoMsg;
         };
         ResponseListSnapshots: {
             typeUrl: string;
             encode(message: ResponseListSnapshots, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseListSnapshots;
-            fromJSON(object: any): _119.ResponseListSnapshots;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseListSnapshots;
+            fromJSON(object: any): _124.ResponseListSnapshots;
             toJSON(message: ResponseListSnapshots): unknown;
-            fromPartial(object: Partial<ResponseListSnapshots>): _119.ResponseListSnapshots;
-            fromProtoMsg(message: ResponseListSnapshotsProtoMsg): _119.ResponseListSnapshots;
+            fromPartial(object: Partial<ResponseListSnapshots>): _124.ResponseListSnapshots;
+            fromProtoMsg(message: ResponseListSnapshotsProtoMsg): _124.ResponseListSnapshots;
             toProto(message: ResponseListSnapshots): Uint8Array;
-            toProtoMsg(message: ResponseListSnapshots): _119.ResponseListSnapshotsProtoMsg;
+            toProtoMsg(message: ResponseListSnapshots): _124.ResponseListSnapshotsProtoMsg;
         };
         ResponseOfferSnapshot: {
             typeUrl: string;
             encode(message: ResponseOfferSnapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseOfferSnapshot;
-            fromJSON(object: any): _119.ResponseOfferSnapshot;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseOfferSnapshot;
+            fromJSON(object: any): _124.ResponseOfferSnapshot;
             toJSON(message: ResponseOfferSnapshot): unknown;
-            fromPartial(object: Partial<ResponseOfferSnapshot>): _119.ResponseOfferSnapshot;
-            fromProtoMsg(message: ResponseOfferSnapshotProtoMsg): _119.ResponseOfferSnapshot;
+            fromPartial(object: Partial<ResponseOfferSnapshot>): _124.ResponseOfferSnapshot;
+            fromProtoMsg(message: ResponseOfferSnapshotProtoMsg): _124.ResponseOfferSnapshot;
             toProto(message: ResponseOfferSnapshot): Uint8Array;
-            toProtoMsg(message: ResponseOfferSnapshot): _119.ResponseOfferSnapshotProtoMsg;
+            toProtoMsg(message: ResponseOfferSnapshot): _124.ResponseOfferSnapshotProtoMsg;
         };
         ResponseLoadSnapshotChunk: {
             typeUrl: string;
             encode(message: ResponseLoadSnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseLoadSnapshotChunk;
-            fromJSON(object: any): _119.ResponseLoadSnapshotChunk;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseLoadSnapshotChunk;
+            fromJSON(object: any): _124.ResponseLoadSnapshotChunk;
             toJSON(message: ResponseLoadSnapshotChunk): unknown;
-            fromPartial(object: Partial<ResponseLoadSnapshotChunk>): _119.ResponseLoadSnapshotChunk;
-            fromProtoMsg(message: ResponseLoadSnapshotChunkProtoMsg): _119.ResponseLoadSnapshotChunk;
+            fromPartial(object: Partial<ResponseLoadSnapshotChunk>): _124.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: ResponseLoadSnapshotChunkProtoMsg): _124.ResponseLoadSnapshotChunk;
             toProto(message: ResponseLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: ResponseLoadSnapshotChunk): _119.ResponseLoadSnapshotChunkProtoMsg;
+            toProtoMsg(message: ResponseLoadSnapshotChunk): _124.ResponseLoadSnapshotChunkProtoMsg;
         };
         ResponseApplySnapshotChunk: {
             typeUrl: string;
             encode(message: ResponseApplySnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ResponseApplySnapshotChunk;
-            fromJSON(object: any): _119.ResponseApplySnapshotChunk;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ResponseApplySnapshotChunk;
+            fromJSON(object: any): _124.ResponseApplySnapshotChunk;
             toJSON(message: ResponseApplySnapshotChunk): unknown;
-            fromPartial(object: Partial<ResponseApplySnapshotChunk>): _119.ResponseApplySnapshotChunk;
-            fromProtoMsg(message: ResponseApplySnapshotChunkProtoMsg): _119.ResponseApplySnapshotChunk;
+            fromPartial(object: Partial<ResponseApplySnapshotChunk>): _124.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: ResponseApplySnapshotChunkProtoMsg): _124.ResponseApplySnapshotChunk;
             toProto(message: ResponseApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: ResponseApplySnapshotChunk): _119.ResponseApplySnapshotChunkProtoMsg;
+            toProtoMsg(message: ResponseApplySnapshotChunk): _124.ResponseApplySnapshotChunkProtoMsg;
         };
         ConsensusParams: {
             typeUrl: string;
             encode(message: ConsensusParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ConsensusParams;
-            fromJSON(object: any): _119.ConsensusParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ConsensusParams;
+            fromJSON(object: any): _124.ConsensusParams;
             toJSON(message: ConsensusParams): unknown;
-            fromPartial(object: Partial<ConsensusParams>): _119.ConsensusParams;
-            fromProtoMsg(message: ConsensusParamsProtoMsg): _119.ConsensusParams;
+            fromPartial(object: Partial<ConsensusParams>): _124.ConsensusParams;
+            fromProtoMsg(message: ConsensusParamsProtoMsg): _124.ConsensusParams;
             toProto(message: ConsensusParams): Uint8Array;
-            toProtoMsg(message: ConsensusParams): _119.ConsensusParamsProtoMsg;
+            toProtoMsg(message: ConsensusParams): _124.ConsensusParamsProtoMsg;
         };
         BlockParams: {
             typeUrl: string;
             encode(message: BlockParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.BlockParams;
-            fromJSON(object: any): _119.BlockParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.BlockParams;
+            fromJSON(object: any): _124.BlockParams;
             toJSON(message: BlockParams): unknown;
-            fromPartial(object: Partial<BlockParams>): _119.BlockParams;
-            fromProtoMsg(message: BlockParamsProtoMsg): _119.BlockParams;
+            fromPartial(object: Partial<BlockParams>): _124.BlockParams;
+            fromProtoMsg(message: BlockParamsProtoMsg): _124.BlockParams;
             toProto(message: BlockParams): Uint8Array;
-            toProtoMsg(message: BlockParams): _119.BlockParamsProtoMsg;
+            toProtoMsg(message: BlockParams): _124.BlockParamsProtoMsg;
         };
         LastCommitInfo: {
             typeUrl: string;
             encode(message: LastCommitInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.LastCommitInfo;
-            fromJSON(object: any): _119.LastCommitInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.LastCommitInfo;
+            fromJSON(object: any): _124.LastCommitInfo;
             toJSON(message: LastCommitInfo): unknown;
-            fromPartial(object: Partial<LastCommitInfo>): _119.LastCommitInfo;
-            fromProtoMsg(message: LastCommitInfoProtoMsg): _119.LastCommitInfo;
+            fromPartial(object: Partial<LastCommitInfo>): _124.LastCommitInfo;
+            fromProtoMsg(message: LastCommitInfoProtoMsg): _124.LastCommitInfo;
             toProto(message: LastCommitInfo): Uint8Array;
-            toProtoMsg(message: LastCommitInfo): _119.LastCommitInfoProtoMsg;
+            toProtoMsg(message: LastCommitInfo): _124.LastCommitInfoProtoMsg;
         };
         Event: {
             typeUrl: string;
             encode(message: Event, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Event;
-            fromJSON(object: any): _119.Event;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Event;
+            fromJSON(object: any): _124.Event;
             toJSON(message: Event): unknown;
-            fromPartial(object: Partial<Event>): _119.Event;
-            fromProtoMsg(message: EventProtoMsg): _119.Event;
+            fromPartial(object: Partial<Event>): _124.Event;
+            fromProtoMsg(message: EventProtoMsg): _124.Event;
             toProto(message: Event): Uint8Array;
-            toProtoMsg(message: Event): _119.EventProtoMsg;
+            toProtoMsg(message: Event): _124.EventProtoMsg;
         };
         EventAttribute: {
             typeUrl: string;
             encode(message: EventAttribute, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.EventAttribute;
-            fromJSON(object: any): _119.EventAttribute;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.EventAttribute;
+            fromJSON(object: any): _124.EventAttribute;
             toJSON(message: EventAttribute): unknown;
-            fromPartial(object: Partial<EventAttribute>): _119.EventAttribute;
-            fromProtoMsg(message: EventAttributeProtoMsg): _119.EventAttribute;
+            fromPartial(object: Partial<EventAttribute>): _124.EventAttribute;
+            fromProtoMsg(message: EventAttributeProtoMsg): _124.EventAttribute;
             toProto(message: EventAttribute): Uint8Array;
-            toProtoMsg(message: EventAttribute): _119.EventAttributeProtoMsg;
+            toProtoMsg(message: EventAttribute): _124.EventAttributeProtoMsg;
         };
         TxResult: {
             typeUrl: string;
             encode(message: TxResult, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.TxResult;
-            fromJSON(object: any): _119.TxResult;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.TxResult;
+            fromJSON(object: any): _124.TxResult;
             toJSON(message: TxResult): unknown;
-            fromPartial(object: Partial<TxResult>): _119.TxResult;
-            fromProtoMsg(message: TxResultProtoMsg): _119.TxResult;
+            fromPartial(object: Partial<TxResult>): _124.TxResult;
+            fromProtoMsg(message: TxResultProtoMsg): _124.TxResult;
             toProto(message: TxResult): Uint8Array;
-            toProtoMsg(message: TxResult): _119.TxResultProtoMsg;
+            toProtoMsg(message: TxResult): _124.TxResultProtoMsg;
         };
         Validator: {
             typeUrl: string;
             encode(message: Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Validator;
-            fromJSON(object: any): _119.Validator;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Validator;
+            fromJSON(object: any): _124.Validator;
             toJSON(message: Validator): unknown;
-            fromPartial(object: Partial<Validator>): _119.Validator;
-            fromProtoMsg(message: ValidatorProtoMsg): _119.Validator;
+            fromPartial(object: Partial<Validator>): _124.Validator;
+            fromProtoMsg(message: ValidatorProtoMsg): _124.Validator;
             toProto(message: Validator): Uint8Array;
-            toProtoMsg(message: Validator): _119.ValidatorProtoMsg;
+            toProtoMsg(message: Validator): _124.ValidatorProtoMsg;
         };
         ValidatorUpdate: {
             typeUrl: string;
             encode(message: ValidatorUpdate, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.ValidatorUpdate;
-            fromJSON(object: any): _119.ValidatorUpdate;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.ValidatorUpdate;
+            fromJSON(object: any): _124.ValidatorUpdate;
             toJSON(message: ValidatorUpdate): unknown;
-            fromPartial(object: Partial<ValidatorUpdate>): _119.ValidatorUpdate;
-            fromProtoMsg(message: ValidatorUpdateProtoMsg): _119.ValidatorUpdate;
+            fromPartial(object: Partial<ValidatorUpdate>): _124.ValidatorUpdate;
+            fromProtoMsg(message: ValidatorUpdateProtoMsg): _124.ValidatorUpdate;
             toProto(message: ValidatorUpdate): Uint8Array;
-            toProtoMsg(message: ValidatorUpdate): _119.ValidatorUpdateProtoMsg;
+            toProtoMsg(message: ValidatorUpdate): _124.ValidatorUpdateProtoMsg;
         };
         VoteInfo: {
             typeUrl: string;
             encode(message: VoteInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.VoteInfo;
-            fromJSON(object: any): _119.VoteInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.VoteInfo;
+            fromJSON(object: any): _124.VoteInfo;
             toJSON(message: VoteInfo): unknown;
-            fromPartial(object: Partial<VoteInfo>): _119.VoteInfo;
-            fromProtoMsg(message: VoteInfoProtoMsg): _119.VoteInfo;
+            fromPartial(object: Partial<VoteInfo>): _124.VoteInfo;
+            fromProtoMsg(message: VoteInfoProtoMsg): _124.VoteInfo;
             toProto(message: VoteInfo): Uint8Array;
-            toProtoMsg(message: VoteInfo): _119.VoteInfoProtoMsg;
+            toProtoMsg(message: VoteInfo): _124.VoteInfoProtoMsg;
         };
         Evidence: {
             typeUrl: string;
             encode(message: Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Evidence;
-            fromJSON(object: any): _119.Evidence;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Evidence;
+            fromJSON(object: any): _124.Evidence;
             toJSON(message: Evidence): unknown;
-            fromPartial(object: Partial<Evidence>): _119.Evidence;
-            fromProtoMsg(message: EvidenceProtoMsg): _119.Evidence;
+            fromPartial(object: Partial<Evidence>): _124.Evidence;
+            fromProtoMsg(message: EvidenceProtoMsg): _124.Evidence;
             toProto(message: Evidence): Uint8Array;
-            toProtoMsg(message: Evidence): _119.EvidenceProtoMsg;
+            toProtoMsg(message: Evidence): _124.EvidenceProtoMsg;
         };
         Snapshot: {
             typeUrl: string;
             encode(message: Snapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _119.Snapshot;
-            fromJSON(object: any): _119.Snapshot;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Snapshot;
+            fromJSON(object: any): _124.Snapshot;
             toJSON(message: Snapshot): unknown;
-            fromPartial(object: Partial<Snapshot>): _119.Snapshot;
-            fromProtoMsg(message: SnapshotProtoMsg): _119.Snapshot;
+            fromPartial(object: Partial<Snapshot>): _124.Snapshot;
+            fromProtoMsg(message: SnapshotProtoMsg): _124.Snapshot;
             toProto(message: Snapshot): Uint8Array;
-            toProtoMsg(message: Snapshot): _119.SnapshotProtoMsg;
+            toProtoMsg(message: Snapshot): _124.SnapshotProtoMsg;
         };
     };
     const crypto: {
         Proof: {
             typeUrl: string;
             encode(message: Proof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _121.Proof;
-            fromJSON(object: any): _121.Proof;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.Proof;
+            fromJSON(object: any): _126.Proof;
             toJSON(message: Proof): unknown;
-            fromPartial(object: Partial<Proof>): _121.Proof;
-            fromProtoMsg(message: ProofProtoMsg): _121.Proof;
+            fromPartial(object: Partial<Proof>): _126.Proof;
+            fromProtoMsg(message: ProofProtoMsg): _126.Proof;
             toProto(message: Proof): Uint8Array;
-            toProtoMsg(message: Proof): _121.ProofProtoMsg;
+            toProtoMsg(message: Proof): _126.ProofProtoMsg;
         };
         ValueOp: {
             typeUrl: string;
             encode(message: ValueOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _121.ValueOp;
-            fromJSON(object: any): _121.ValueOp;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.ValueOp;
+            fromJSON(object: any): _126.ValueOp;
             toJSON(message: ValueOp): unknown;
-            fromPartial(object: Partial<ValueOp>): _121.ValueOp;
-            fromProtoMsg(message: ValueOpProtoMsg): _121.ValueOp;
+            fromPartial(object: Partial<ValueOp>): _126.ValueOp;
+            fromProtoMsg(message: ValueOpProtoMsg): _126.ValueOp;
             toProto(message: ValueOp): Uint8Array;
-            toProtoMsg(message: ValueOp): _121.ValueOpProtoMsg;
+            toProtoMsg(message: ValueOp): _126.ValueOpProtoMsg;
         };
         DominoOp: {
             typeUrl: string;
             encode(message: DominoOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _121.DominoOp;
-            fromJSON(object: any): _121.DominoOp;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.DominoOp;
+            fromJSON(object: any): _126.DominoOp;
             toJSON(message: DominoOp): unknown;
-            fromPartial(object: Partial<DominoOp>): _121.DominoOp;
-            fromProtoMsg(message: DominoOpProtoMsg): _121.DominoOp;
+            fromPartial(object: Partial<DominoOp>): _126.DominoOp;
+            fromProtoMsg(message: DominoOpProtoMsg): _126.DominoOp;
             toProto(message: DominoOp): Uint8Array;
-            toProtoMsg(message: DominoOp): _121.DominoOpProtoMsg;
+            toProtoMsg(message: DominoOp): _126.DominoOpProtoMsg;
         };
         ProofOp: {
             typeUrl: string;
             encode(message: ProofOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _121.ProofOp;
-            fromJSON(object: any): _121.ProofOp;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.ProofOp;
+            fromJSON(object: any): _126.ProofOp;
             toJSON(message: ProofOp): unknown;
-            fromPartial(object: Partial<ProofOp>): _121.ProofOp;
-            fromProtoMsg(message: ProofOpProtoMsg): _121.ProofOp;
+            fromPartial(object: Partial<ProofOp>): _126.ProofOp;
+            fromProtoMsg(message: ProofOpProtoMsg): _126.ProofOp;
             toProto(message: ProofOp): Uint8Array;
-            toProtoMsg(message: ProofOp): _121.ProofOpProtoMsg;
+            toProtoMsg(message: ProofOp): _126.ProofOpProtoMsg;
         };
         ProofOps: {
             typeUrl: string;
             encode(message: ProofOps, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _121.ProofOps;
-            fromJSON(object: any): _121.ProofOps;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.ProofOps;
+            fromJSON(object: any): _126.ProofOps;
             toJSON(message: ProofOps): unknown;
-            fromPartial(object: Partial<ProofOps>): _121.ProofOps;
-            fromProtoMsg(message: ProofOpsProtoMsg): _121.ProofOps;
+            fromPartial(object: Partial<ProofOps>): _126.ProofOps;
+            fromProtoMsg(message: ProofOpsProtoMsg): _126.ProofOps;
             toProto(message: ProofOps): Uint8Array;
-            toProtoMsg(message: ProofOps): _121.ProofOpsProtoMsg;
+            toProtoMsg(message: ProofOps): _126.ProofOpsProtoMsg;
         };
         PublicKey: {
             typeUrl: string;
             encode(message: PublicKey, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _120.PublicKey;
-            fromJSON(object: any): _120.PublicKey;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _125.PublicKey;
+            fromJSON(object: any): _125.PublicKey;
             toJSON(message: PublicKey): unknown;
-            fromPartial(object: Partial<PublicKey>): _120.PublicKey;
-            fromProtoMsg(message: PublicKeyProtoMsg): _120.PublicKey;
+            fromPartial(object: Partial<PublicKey>): _125.PublicKey;
+            fromProtoMsg(message: PublicKeyProtoMsg): _125.PublicKey;
             toProto(message: PublicKey): Uint8Array;
-            toProtoMsg(message: PublicKey): _120.PublicKeyProtoMsg;
+            toProtoMsg(message: PublicKey): _125.PublicKeyProtoMsg;
         };
     };
     namespace libs {
@@ -585,13 +585,13 @@ export declare namespace tendermint {
             BitArray: {
                 typeUrl: string;
                 encode(message: BitArray, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _122.BitArray;
-                fromJSON(object: any): _122.BitArray;
+                decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.BitArray;
+                fromJSON(object: any): _127.BitArray;
                 toJSON(message: BitArray): unknown;
-                fromPartial(object: Partial<BitArray>): _122.BitArray;
-                fromProtoMsg(message: BitArrayProtoMsg): _122.BitArray;
+                fromPartial(object: Partial<BitArray>): _127.BitArray;
+                fromProtoMsg(message: BitArrayProtoMsg): _127.BitArray;
                 toProto(message: BitArray): Uint8Array;
-                toProtoMsg(message: BitArray): _122.BitArrayProtoMsg;
+                toProtoMsg(message: BitArray): _127.BitArrayProtoMsg;
             };
         };
     }
@@ -599,388 +599,388 @@ export declare namespace tendermint {
         ProtocolVersion: {
             typeUrl: string;
             encode(message: ProtocolVersion, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _123.ProtocolVersion;
-            fromJSON(object: any): _123.ProtocolVersion;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.ProtocolVersion;
+            fromJSON(object: any): _128.ProtocolVersion;
             toJSON(message: ProtocolVersion): unknown;
-            fromPartial(object: Partial<ProtocolVersion>): _123.ProtocolVersion;
-            fromProtoMsg(message: ProtocolVersionProtoMsg): _123.ProtocolVersion;
+            fromPartial(object: Partial<ProtocolVersion>): _128.ProtocolVersion;
+            fromProtoMsg(message: ProtocolVersionProtoMsg): _128.ProtocolVersion;
             toProto(message: ProtocolVersion): Uint8Array;
-            toProtoMsg(message: ProtocolVersion): _123.ProtocolVersionProtoMsg;
+            toProtoMsg(message: ProtocolVersion): _128.ProtocolVersionProtoMsg;
         };
         NodeInfo: {
             typeUrl: string;
             encode(message: NodeInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _123.NodeInfo;
-            fromJSON(object: any): _123.NodeInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.NodeInfo;
+            fromJSON(object: any): _128.NodeInfo;
             toJSON(message: NodeInfo): unknown;
-            fromPartial(object: Partial<NodeInfo>): _123.NodeInfo;
-            fromProtoMsg(message: NodeInfoProtoMsg): _123.NodeInfo;
+            fromPartial(object: Partial<NodeInfo>): _128.NodeInfo;
+            fromProtoMsg(message: NodeInfoProtoMsg): _128.NodeInfo;
             toProto(message: NodeInfo): Uint8Array;
-            toProtoMsg(message: NodeInfo): _123.NodeInfoProtoMsg;
+            toProtoMsg(message: NodeInfo): _128.NodeInfoProtoMsg;
         };
         NodeInfoOther: {
             typeUrl: string;
             encode(message: NodeInfoOther, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _123.NodeInfoOther;
-            fromJSON(object: any): _123.NodeInfoOther;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.NodeInfoOther;
+            fromJSON(object: any): _128.NodeInfoOther;
             toJSON(message: NodeInfoOther): unknown;
-            fromPartial(object: Partial<NodeInfoOther>): _123.NodeInfoOther;
-            fromProtoMsg(message: NodeInfoOtherProtoMsg): _123.NodeInfoOther;
+            fromPartial(object: Partial<NodeInfoOther>): _128.NodeInfoOther;
+            fromProtoMsg(message: NodeInfoOtherProtoMsg): _128.NodeInfoOther;
             toProto(message: NodeInfoOther): Uint8Array;
-            toProtoMsg(message: NodeInfoOther): _123.NodeInfoOtherProtoMsg;
+            toProtoMsg(message: NodeInfoOther): _128.NodeInfoOtherProtoMsg;
         };
         PeerInfo: {
             typeUrl: string;
             encode(message: PeerInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _123.PeerInfo;
-            fromJSON(object: any): _123.PeerInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.PeerInfo;
+            fromJSON(object: any): _128.PeerInfo;
             toJSON(message: PeerInfo): unknown;
-            fromPartial(object: Partial<PeerInfo>): _123.PeerInfo;
-            fromProtoMsg(message: PeerInfoProtoMsg): _123.PeerInfo;
+            fromPartial(object: Partial<PeerInfo>): _128.PeerInfo;
+            fromProtoMsg(message: PeerInfoProtoMsg): _128.PeerInfo;
             toProto(message: PeerInfo): Uint8Array;
-            toProtoMsg(message: PeerInfo): _123.PeerInfoProtoMsg;
+            toProtoMsg(message: PeerInfo): _128.PeerInfoProtoMsg;
         };
         PeerAddressInfo: {
             typeUrl: string;
             encode(message: PeerAddressInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _123.PeerAddressInfo;
-            fromJSON(object: any): _123.PeerAddressInfo;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.PeerAddressInfo;
+            fromJSON(object: any): _128.PeerAddressInfo;
             toJSON(message: PeerAddressInfo): unknown;
-            fromPartial(object: Partial<PeerAddressInfo>): _123.PeerAddressInfo;
-            fromProtoMsg(message: PeerAddressInfoProtoMsg): _123.PeerAddressInfo;
+            fromPartial(object: Partial<PeerAddressInfo>): _128.PeerAddressInfo;
+            fromProtoMsg(message: PeerAddressInfoProtoMsg): _128.PeerAddressInfo;
             toProto(message: PeerAddressInfo): Uint8Array;
-            toProtoMsg(message: PeerAddressInfo): _123.PeerAddressInfoProtoMsg;
+            toProtoMsg(message: PeerAddressInfo): _128.PeerAddressInfoProtoMsg;
         };
     };
     const types: {
         ValidatorSet: {
             typeUrl: string;
             encode(message: ValidatorSet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.ValidatorSet;
-            fromJSON(object: any): _128.ValidatorSet;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _133.ValidatorSet;
+            fromJSON(object: any): _133.ValidatorSet;
             toJSON(message: ValidatorSet): unknown;
-            fromPartial(object: Partial<ValidatorSet>): _128.ValidatorSet;
-            fromProtoMsg(message: ValidatorSetProtoMsg): _128.ValidatorSet;
+            fromPartial(object: Partial<ValidatorSet>): _133.ValidatorSet;
+            fromProtoMsg(message: ValidatorSetProtoMsg): _133.ValidatorSet;
             toProto(message: ValidatorSet): Uint8Array;
-            toProtoMsg(message: ValidatorSet): _128.ValidatorSetProtoMsg;
+            toProtoMsg(message: ValidatorSet): _133.ValidatorSetProtoMsg;
         };
         Validator: {
             typeUrl: string;
             encode(message: Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.Validator;
-            fromJSON(object: any): _128.Validator;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _133.Validator;
+            fromJSON(object: any): _133.Validator;
             toJSON(message: Validator): unknown;
-            fromPartial(object: Partial<Validator>): _128.Validator;
-            fromProtoMsg(message: ValidatorProtoMsg): _128.Validator;
+            fromPartial(object: Partial<Validator>): _133.Validator;
+            fromProtoMsg(message: ValidatorProtoMsg): _133.Validator;
             toProto(message: Validator): Uint8Array;
-            toProtoMsg(message: Validator): _128.ValidatorProtoMsg;
+            toProtoMsg(message: Validator): _133.ValidatorProtoMsg;
         };
         SimpleValidator: {
             typeUrl: string;
             encode(message: SimpleValidator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _128.SimpleValidator;
-            fromJSON(object: any): _128.SimpleValidator;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _133.SimpleValidator;
+            fromJSON(object: any): _133.SimpleValidator;
             toJSON(message: SimpleValidator): unknown;
-            fromPartial(object: Partial<SimpleValidator>): _128.SimpleValidator;
-            fromProtoMsg(message: SimpleValidatorProtoMsg): _128.SimpleValidator;
+            fromPartial(object: Partial<SimpleValidator>): _133.SimpleValidator;
+            fromProtoMsg(message: SimpleValidatorProtoMsg): _133.SimpleValidator;
             toProto(message: SimpleValidator): Uint8Array;
-            toProtoMsg(message: SimpleValidator): _128.SimpleValidatorProtoMsg;
+            toProtoMsg(message: SimpleValidator): _133.SimpleValidatorProtoMsg;
         };
-        blockIDFlagFromJSON(object: any): _127.BlockIDFlag;
+        blockIDFlagFromJSON(object: any): _132.BlockIDFlag;
         blockIDFlagToJSON(object: BlockIDFlag): string;
-        signedMsgTypeFromJSON(object: any): _127.SignedMsgType;
+        signedMsgTypeFromJSON(object: any): _132.SignedMsgType;
         signedMsgTypeToJSON(object: SignedMsgType): string;
-        BlockIDFlag: typeof _127.BlockIDFlag;
-        BlockIDFlagSDKType: typeof _127.BlockIDFlag;
-        SignedMsgType: typeof _127.SignedMsgType;
-        SignedMsgTypeSDKType: typeof _127.SignedMsgType;
+        BlockIDFlag: typeof _132.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _132.BlockIDFlag;
+        SignedMsgType: typeof _132.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _132.SignedMsgType;
         PartSetHeader: {
             typeUrl: string;
             encode(message: PartSetHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.PartSetHeader;
-            fromJSON(object: any): _127.PartSetHeader;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.PartSetHeader;
+            fromJSON(object: any): _132.PartSetHeader;
             toJSON(message: PartSetHeader): unknown;
-            fromPartial(object: Partial<PartSetHeader>): _127.PartSetHeader;
-            fromProtoMsg(message: PartSetHeaderProtoMsg): _127.PartSetHeader;
+            fromPartial(object: Partial<PartSetHeader>): _132.PartSetHeader;
+            fromProtoMsg(message: PartSetHeaderProtoMsg): _132.PartSetHeader;
             toProto(message: PartSetHeader): Uint8Array;
-            toProtoMsg(message: PartSetHeader): _127.PartSetHeaderProtoMsg;
+            toProtoMsg(message: PartSetHeader): _132.PartSetHeaderProtoMsg;
         };
         Part: {
             typeUrl: string;
             encode(message: Part, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Part;
-            fromJSON(object: any): _127.Part;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Part;
+            fromJSON(object: any): _132.Part;
             toJSON(message: Part): unknown;
-            fromPartial(object: Partial<Part>): _127.Part;
-            fromProtoMsg(message: PartProtoMsg): _127.Part;
+            fromPartial(object: Partial<Part>): _132.Part;
+            fromProtoMsg(message: PartProtoMsg): _132.Part;
             toProto(message: Part): Uint8Array;
-            toProtoMsg(message: Part): _127.PartProtoMsg;
+            toProtoMsg(message: Part): _132.PartProtoMsg;
         };
         BlockID: {
             typeUrl: string;
             encode(message: BlockID, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.BlockID;
-            fromJSON(object: any): _127.BlockID;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.BlockID;
+            fromJSON(object: any): _132.BlockID;
             toJSON(message: BlockID): unknown;
-            fromPartial(object: Partial<BlockID>): _127.BlockID;
-            fromProtoMsg(message: BlockIDProtoMsg): _127.BlockID;
+            fromPartial(object: Partial<BlockID>): _132.BlockID;
+            fromProtoMsg(message: BlockIDProtoMsg): _132.BlockID;
             toProto(message: BlockID): Uint8Array;
-            toProtoMsg(message: BlockID): _127.BlockIDProtoMsg;
+            toProtoMsg(message: BlockID): _132.BlockIDProtoMsg;
         };
         Header: {
             typeUrl: string;
             encode(message: Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Header;
-            fromJSON(object: any): _127.Header;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Header;
+            fromJSON(object: any): _132.Header;
             toJSON(message: Header): unknown;
-            fromPartial(object: Partial<Header>): _127.Header;
-            fromProtoMsg(message: HeaderProtoMsg): _127.Header;
+            fromPartial(object: Partial<Header>): _132.Header;
+            fromProtoMsg(message: HeaderProtoMsg): _132.Header;
             toProto(message: Header): Uint8Array;
-            toProtoMsg(message: Header): _127.HeaderProtoMsg;
+            toProtoMsg(message: Header): _132.HeaderProtoMsg;
         };
         Data: {
             typeUrl: string;
             encode(message: Data, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Data;
-            fromJSON(object: any): _127.Data;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Data;
+            fromJSON(object: any): _132.Data;
             toJSON(message: Data): unknown;
-            fromPartial(object: Partial<Data>): _127.Data;
-            fromProtoMsg(message: DataProtoMsg): _127.Data;
+            fromPartial(object: Partial<Data>): _132.Data;
+            fromProtoMsg(message: DataProtoMsg): _132.Data;
             toProto(message: Data): Uint8Array;
-            toProtoMsg(message: Data): _127.DataProtoMsg;
+            toProtoMsg(message: Data): _132.DataProtoMsg;
         };
         Vote: {
             typeUrl: string;
             encode(message: Vote, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Vote;
-            fromJSON(object: any): _127.Vote;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Vote;
+            fromJSON(object: any): _132.Vote;
             toJSON(message: Vote): unknown;
-            fromPartial(object: Partial<Vote>): _127.Vote;
-            fromProtoMsg(message: VoteProtoMsg): _127.Vote;
+            fromPartial(object: Partial<Vote>): _132.Vote;
+            fromProtoMsg(message: VoteProtoMsg): _132.Vote;
             toProto(message: Vote): Uint8Array;
-            toProtoMsg(message: Vote): _127.VoteProtoMsg;
+            toProtoMsg(message: Vote): _132.VoteProtoMsg;
         };
         Commit: {
             typeUrl: string;
             encode(message: Commit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Commit;
-            fromJSON(object: any): _127.Commit;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Commit;
+            fromJSON(object: any): _132.Commit;
             toJSON(message: Commit): unknown;
-            fromPartial(object: Partial<Commit>): _127.Commit;
-            fromProtoMsg(message: CommitProtoMsg): _127.Commit;
+            fromPartial(object: Partial<Commit>): _132.Commit;
+            fromProtoMsg(message: CommitProtoMsg): _132.Commit;
             toProto(message: Commit): Uint8Array;
-            toProtoMsg(message: Commit): _127.CommitProtoMsg;
+            toProtoMsg(message: Commit): _132.CommitProtoMsg;
         };
         CommitSig: {
             typeUrl: string;
             encode(message: CommitSig, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.CommitSig;
-            fromJSON(object: any): _127.CommitSig;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.CommitSig;
+            fromJSON(object: any): _132.CommitSig;
             toJSON(message: CommitSig): unknown;
-            fromPartial(object: Partial<CommitSig>): _127.CommitSig;
-            fromProtoMsg(message: CommitSigProtoMsg): _127.CommitSig;
+            fromPartial(object: Partial<CommitSig>): _132.CommitSig;
+            fromProtoMsg(message: CommitSigProtoMsg): _132.CommitSig;
             toProto(message: CommitSig): Uint8Array;
-            toProtoMsg(message: CommitSig): _127.CommitSigProtoMsg;
+            toProtoMsg(message: CommitSig): _132.CommitSigProtoMsg;
         };
         Proposal: {
             typeUrl: string;
             encode(message: Proposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.Proposal;
-            fromJSON(object: any): _127.Proposal;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.Proposal;
+            fromJSON(object: any): _132.Proposal;
             toJSON(message: Proposal): unknown;
-            fromPartial(object: Partial<Proposal>): _127.Proposal;
-            fromProtoMsg(message: ProposalProtoMsg): _127.Proposal;
+            fromPartial(object: Partial<Proposal>): _132.Proposal;
+            fromProtoMsg(message: ProposalProtoMsg): _132.Proposal;
             toProto(message: Proposal): Uint8Array;
-            toProtoMsg(message: Proposal): _127.ProposalProtoMsg;
+            toProtoMsg(message: Proposal): _132.ProposalProtoMsg;
         };
         SignedHeader: {
             typeUrl: string;
             encode(message: SignedHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.SignedHeader;
-            fromJSON(object: any): _127.SignedHeader;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.SignedHeader;
+            fromJSON(object: any): _132.SignedHeader;
             toJSON(message: SignedHeader): unknown;
-            fromPartial(object: Partial<SignedHeader>): _127.SignedHeader;
-            fromProtoMsg(message: SignedHeaderProtoMsg): _127.SignedHeader;
+            fromPartial(object: Partial<SignedHeader>): _132.SignedHeader;
+            fromProtoMsg(message: SignedHeaderProtoMsg): _132.SignedHeader;
             toProto(message: SignedHeader): Uint8Array;
-            toProtoMsg(message: SignedHeader): _127.SignedHeaderProtoMsg;
+            toProtoMsg(message: SignedHeader): _132.SignedHeaderProtoMsg;
         };
         LightBlock: {
             typeUrl: string;
             encode(message: LightBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.LightBlock;
-            fromJSON(object: any): _127.LightBlock;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.LightBlock;
+            fromJSON(object: any): _132.LightBlock;
             toJSON(message: LightBlock): unknown;
-            fromPartial(object: Partial<LightBlock>): _127.LightBlock;
-            fromProtoMsg(message: LightBlockProtoMsg): _127.LightBlock;
+            fromPartial(object: Partial<LightBlock>): _132.LightBlock;
+            fromProtoMsg(message: LightBlockProtoMsg): _132.LightBlock;
             toProto(message: LightBlock): Uint8Array;
-            toProtoMsg(message: LightBlock): _127.LightBlockProtoMsg;
+            toProtoMsg(message: LightBlock): _132.LightBlockProtoMsg;
         };
         BlockMeta: {
             typeUrl: string;
             encode(message: BlockMeta, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.BlockMeta;
-            fromJSON(object: any): _127.BlockMeta;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.BlockMeta;
+            fromJSON(object: any): _132.BlockMeta;
             toJSON(message: BlockMeta): unknown;
-            fromPartial(object: Partial<BlockMeta>): _127.BlockMeta;
-            fromProtoMsg(message: BlockMetaProtoMsg): _127.BlockMeta;
+            fromPartial(object: Partial<BlockMeta>): _132.BlockMeta;
+            fromProtoMsg(message: BlockMetaProtoMsg): _132.BlockMeta;
             toProto(message: BlockMeta): Uint8Array;
-            toProtoMsg(message: BlockMeta): _127.BlockMetaProtoMsg;
+            toProtoMsg(message: BlockMeta): _132.BlockMetaProtoMsg;
         };
         TxProof: {
             typeUrl: string;
             encode(message: TxProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _127.TxProof;
-            fromJSON(object: any): _127.TxProof;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _132.TxProof;
+            fromJSON(object: any): _132.TxProof;
             toJSON(message: TxProof): unknown;
-            fromPartial(object: Partial<TxProof>): _127.TxProof;
-            fromProtoMsg(message: TxProofProtoMsg): _127.TxProof;
+            fromPartial(object: Partial<TxProof>): _132.TxProof;
+            fromProtoMsg(message: TxProofProtoMsg): _132.TxProof;
             toProto(message: TxProof): Uint8Array;
-            toProtoMsg(message: TxProof): _127.TxProofProtoMsg;
+            toProtoMsg(message: TxProof): _132.TxProofProtoMsg;
         };
         ConsensusParams: {
             typeUrl: string;
             encode(message: ConsensusParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.ConsensusParams;
-            fromJSON(object: any): _126.ConsensusParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.ConsensusParams;
+            fromJSON(object: any): _131.ConsensusParams;
             toJSON(message: ConsensusParams): unknown;
-            fromPartial(object: Partial<ConsensusParams>): _126.ConsensusParams;
-            fromProtoMsg(message: ConsensusParamsProtoMsg): _126.ConsensusParams;
+            fromPartial(object: Partial<ConsensusParams>): _131.ConsensusParams;
+            fromProtoMsg(message: ConsensusParamsProtoMsg): _131.ConsensusParams;
             toProto(message: ConsensusParams): Uint8Array;
-            toProtoMsg(message: ConsensusParams): _126.ConsensusParamsProtoMsg;
+            toProtoMsg(message: ConsensusParams): _131.ConsensusParamsProtoMsg;
         };
         BlockParams: {
             typeUrl: string;
             encode(message: BlockParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.BlockParams;
-            fromJSON(object: any): _126.BlockParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.BlockParams;
+            fromJSON(object: any): _131.BlockParams;
             toJSON(message: BlockParams): unknown;
-            fromPartial(object: Partial<BlockParams>): _126.BlockParams;
-            fromProtoMsg(message: BlockParamsProtoMsg): _126.BlockParams;
+            fromPartial(object: Partial<BlockParams>): _131.BlockParams;
+            fromProtoMsg(message: BlockParamsProtoMsg): _131.BlockParams;
             toProto(message: BlockParams): Uint8Array;
-            toProtoMsg(message: BlockParams): _126.BlockParamsProtoMsg;
+            toProtoMsg(message: BlockParams): _131.BlockParamsProtoMsg;
         };
         EvidenceParams: {
             typeUrl: string;
             encode(message: EvidenceParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.EvidenceParams;
-            fromJSON(object: any): _126.EvidenceParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.EvidenceParams;
+            fromJSON(object: any): _131.EvidenceParams;
             toJSON(message: EvidenceParams): unknown;
-            fromPartial(object: Partial<EvidenceParams>): _126.EvidenceParams;
-            fromProtoMsg(message: EvidenceParamsProtoMsg): _126.EvidenceParams;
+            fromPartial(object: Partial<EvidenceParams>): _131.EvidenceParams;
+            fromProtoMsg(message: EvidenceParamsProtoMsg): _131.EvidenceParams;
             toProto(message: EvidenceParams): Uint8Array;
-            toProtoMsg(message: EvidenceParams): _126.EvidenceParamsProtoMsg;
+            toProtoMsg(message: EvidenceParams): _131.EvidenceParamsProtoMsg;
         };
         ValidatorParams: {
             typeUrl: string;
             encode(message: ValidatorParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.ValidatorParams;
-            fromJSON(object: any): _126.ValidatorParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.ValidatorParams;
+            fromJSON(object: any): _131.ValidatorParams;
             toJSON(message: ValidatorParams): unknown;
-            fromPartial(object: Partial<ValidatorParams>): _126.ValidatorParams;
-            fromProtoMsg(message: ValidatorParamsProtoMsg): _126.ValidatorParams;
+            fromPartial(object: Partial<ValidatorParams>): _131.ValidatorParams;
+            fromProtoMsg(message: ValidatorParamsProtoMsg): _131.ValidatorParams;
             toProto(message: ValidatorParams): Uint8Array;
-            toProtoMsg(message: ValidatorParams): _126.ValidatorParamsProtoMsg;
+            toProtoMsg(message: ValidatorParams): _131.ValidatorParamsProtoMsg;
         };
         VersionParams: {
             typeUrl: string;
             encode(message: VersionParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.VersionParams;
-            fromJSON(object: any): _126.VersionParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.VersionParams;
+            fromJSON(object: any): _131.VersionParams;
             toJSON(message: VersionParams): unknown;
-            fromPartial(object: Partial<VersionParams>): _126.VersionParams;
-            fromProtoMsg(message: VersionParamsProtoMsg): _126.VersionParams;
+            fromPartial(object: Partial<VersionParams>): _131.VersionParams;
+            fromProtoMsg(message: VersionParamsProtoMsg): _131.VersionParams;
             toProto(message: VersionParams): Uint8Array;
-            toProtoMsg(message: VersionParams): _126.VersionParamsProtoMsg;
+            toProtoMsg(message: VersionParams): _131.VersionParamsProtoMsg;
         };
         HashedParams: {
             typeUrl: string;
             encode(message: HashedParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _126.HashedParams;
-            fromJSON(object: any): _126.HashedParams;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _131.HashedParams;
+            fromJSON(object: any): _131.HashedParams;
             toJSON(message: HashedParams): unknown;
-            fromPartial(object: Partial<HashedParams>): _126.HashedParams;
-            fromProtoMsg(message: HashedParamsProtoMsg): _126.HashedParams;
+            fromPartial(object: Partial<HashedParams>): _131.HashedParams;
+            fromProtoMsg(message: HashedParamsProtoMsg): _131.HashedParams;
             toProto(message: HashedParams): Uint8Array;
-            toProtoMsg(message: HashedParams): _126.HashedParamsProtoMsg;
+            toProtoMsg(message: HashedParams): _131.HashedParamsProtoMsg;
         };
         Evidence: {
             typeUrl: string;
             encode(message: Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _125.Evidence;
-            fromJSON(object: any): _125.Evidence;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _130.Evidence;
+            fromJSON(object: any): _130.Evidence;
             toJSON(message: Evidence): unknown;
-            fromPartial(object: Partial<Evidence>): _125.Evidence;
-            fromProtoMsg(message: EvidenceProtoMsg): _125.Evidence;
+            fromPartial(object: Partial<Evidence>): _130.Evidence;
+            fromProtoMsg(message: EvidenceProtoMsg): _130.Evidence;
             toProto(message: Evidence): Uint8Array;
-            toProtoMsg(message: Evidence): _125.EvidenceProtoMsg;
+            toProtoMsg(message: Evidence): _130.EvidenceProtoMsg;
         };
         DuplicateVoteEvidence: {
             typeUrl: string;
             encode(message: DuplicateVoteEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _125.DuplicateVoteEvidence;
-            fromJSON(object: any): _125.DuplicateVoteEvidence;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _130.DuplicateVoteEvidence;
+            fromJSON(object: any): _130.DuplicateVoteEvidence;
             toJSON(message: DuplicateVoteEvidence): unknown;
-            fromPartial(object: Partial<DuplicateVoteEvidence>): _125.DuplicateVoteEvidence;
-            fromProtoMsg(message: DuplicateVoteEvidenceProtoMsg): _125.DuplicateVoteEvidence;
+            fromPartial(object: Partial<DuplicateVoteEvidence>): _130.DuplicateVoteEvidence;
+            fromProtoMsg(message: DuplicateVoteEvidenceProtoMsg): _130.DuplicateVoteEvidence;
             toProto(message: DuplicateVoteEvidence): Uint8Array;
-            toProtoMsg(message: DuplicateVoteEvidence): _125.DuplicateVoteEvidenceProtoMsg;
+            toProtoMsg(message: DuplicateVoteEvidence): _130.DuplicateVoteEvidenceProtoMsg;
         };
         LightClientAttackEvidence: {
             typeUrl: string;
             encode(message: LightClientAttackEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _125.LightClientAttackEvidence;
-            fromJSON(object: any): _125.LightClientAttackEvidence;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _130.LightClientAttackEvidence;
+            fromJSON(object: any): _130.LightClientAttackEvidence;
             toJSON(message: LightClientAttackEvidence): unknown;
-            fromPartial(object: Partial<LightClientAttackEvidence>): _125.LightClientAttackEvidence;
-            fromProtoMsg(message: LightClientAttackEvidenceProtoMsg): _125.LightClientAttackEvidence;
+            fromPartial(object: Partial<LightClientAttackEvidence>): _130.LightClientAttackEvidence;
+            fromProtoMsg(message: LightClientAttackEvidenceProtoMsg): _130.LightClientAttackEvidence;
             toProto(message: LightClientAttackEvidence): Uint8Array;
-            toProtoMsg(message: LightClientAttackEvidence): _125.LightClientAttackEvidenceProtoMsg;
+            toProtoMsg(message: LightClientAttackEvidence): _130.LightClientAttackEvidenceProtoMsg;
         };
         EvidenceList: {
             typeUrl: string;
             encode(message: EvidenceList, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _125.EvidenceList;
-            fromJSON(object: any): _125.EvidenceList;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _130.EvidenceList;
+            fromJSON(object: any): _130.EvidenceList;
             toJSON(message: EvidenceList): unknown;
-            fromPartial(object: Partial<EvidenceList>): _125.EvidenceList;
-            fromProtoMsg(message: EvidenceListProtoMsg): _125.EvidenceList;
+            fromPartial(object: Partial<EvidenceList>): _130.EvidenceList;
+            fromProtoMsg(message: EvidenceListProtoMsg): _130.EvidenceList;
             toProto(message: EvidenceList): Uint8Array;
-            toProtoMsg(message: EvidenceList): _125.EvidenceListProtoMsg;
+            toProtoMsg(message: EvidenceList): _130.EvidenceListProtoMsg;
         };
         Block: {
             typeUrl: string;
             encode(message: Block, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _124.Block;
-            fromJSON(object: any): _124.Block;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _129.Block;
+            fromJSON(object: any): _129.Block;
             toJSON(message: Block): unknown;
-            fromPartial(object: Partial<Block>): _124.Block;
-            fromProtoMsg(message: BlockProtoMsg): _124.Block;
+            fromPartial(object: Partial<Block>): _129.Block;
+            fromProtoMsg(message: BlockProtoMsg): _129.Block;
             toProto(message: Block): Uint8Array;
-            toProtoMsg(message: Block): _124.BlockProtoMsg;
+            toProtoMsg(message: Block): _129.BlockProtoMsg;
         };
     };
     const version: {
         App: {
             typeUrl: string;
             encode(message: App, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _129.App;
-            fromJSON(object: any): _129.App;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _134.App;
+            fromJSON(object: any): _134.App;
             toJSON(message: App): unknown;
-            fromPartial(object: Partial<App>): _129.App;
-            fromProtoMsg(message: AppProtoMsg): _129.App;
+            fromPartial(object: Partial<App>): _134.App;
+            fromProtoMsg(message: AppProtoMsg): _134.App;
             toProto(message: App): Uint8Array;
-            toProtoMsg(message: App): _129.AppProtoMsg;
+            toProtoMsg(message: App): _134.AppProtoMsg;
         };
         Consensus: {
             typeUrl: string;
             encode(message: Consensus, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _129.Consensus;
-            fromJSON(object: any): _129.Consensus;
+            decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number): _134.Consensus;
+            fromJSON(object: any): _134.Consensus;
             toJSON(message: Consensus): unknown;
-            fromPartial(object: Partial<Consensus>): _129.Consensus;
-            fromProtoMsg(message: ConsensusProtoMsg): _129.Consensus;
+            fromPartial(object: Partial<Consensus>): _134.Consensus;
+            fromProtoMsg(message: ConsensusProtoMsg): _134.Consensus;
             toProto(message: Consensus): Uint8Array;
-            toProtoMsg(message: Consensus): _129.ConsensusProtoMsg;
+            toProtoMsg(message: Consensus): _134.ConsensusProtoMsg;
         };
     };
 }