@agoric/client-utils 0.1.1-other-dev-fbe72e7.0.fbe72e7 → 0.1.1-other-dev-d15096d.0.d15096d

package/dist/codegen/tendermint/abci/types.d.ts

@@ -1,8 +1,8 @@
-import { Header, type HeaderSDKType } from '../types/types.js';
-import { ProofOps, type ProofOpsSDKType } from '../crypto/proof.js';
+import { Timestamp, type TimestampSDKType } from '../../google/protobuf/timestamp.js';
 import { ConsensusParams, type ConsensusParamsSDKType } from '../types/params.js';
+import { ProofOps, type ProofOpsSDKType } from '../crypto/proof.js';
 import { PublicKey, type PublicKeySDKType } from '../crypto/keys.js';
-import { Timestamp, type TimestampSDKType } from '../../google/protobuf/timestamp.js';
+import { BlockIDFlag } from '../types/validator.js';
 import { BinaryReader, BinaryWriter } from '../../binary.js';
 import { type JsonSafe } from '../../json-safe.js';
 export declare enum CheckTxType {
@@ -13,63 +13,169 @@ export declare enum CheckTxType {
 export declare const CheckTxTypeSDKType: typeof CheckTxType;
 export declare function checkTxTypeFromJSON(object: any): CheckTxType;
 export declare function checkTxTypeToJSON(object: CheckTxType): string;
-export declare enum EvidenceType {
+export declare enum ResponseOfferSnapshot_Result {
+    /** UNKNOWN - Unknown result, abort all snapshot restoration */
+    UNKNOWN = 0,
+    /** ACCEPT - Snapshot accepted, apply chunks */
+    ACCEPT = 1,
+    /** ABORT - Abort all snapshot restoration */
+    ABORT = 2,
+    /** REJECT - Reject this specific snapshot, try others */
+    REJECT = 3,
+    /** REJECT_FORMAT - Reject all snapshots of this format, try others */
+    REJECT_FORMAT = 4,
+    /** REJECT_SENDER - Reject all snapshots from the sender(s), try others */
+    REJECT_SENDER = 5,
+    UNRECOGNIZED = -1
+}
+export declare const ResponseOfferSnapshot_ResultSDKType: typeof ResponseOfferSnapshot_Result;
+export declare function responseOfferSnapshot_ResultFromJSON(object: any): ResponseOfferSnapshot_Result;
+export declare function responseOfferSnapshot_ResultToJSON(object: ResponseOfferSnapshot_Result): string;
+export declare enum ResponseApplySnapshotChunk_Result {
+    /** UNKNOWN - Unknown result, abort all snapshot restoration */
+    UNKNOWN = 0,
+    /** ACCEPT - Chunk successfully accepted */
+    ACCEPT = 1,
+    /** ABORT - Abort all snapshot restoration */
+    ABORT = 2,
+    /** RETRY - Retry chunk (combine with refetch and reject) */
+    RETRY = 3,
+    /** RETRY_SNAPSHOT - Retry snapshot (combine with refetch and reject) */
+    RETRY_SNAPSHOT = 4,
+    /** REJECT_SNAPSHOT - Reject this snapshot, try others */
+    REJECT_SNAPSHOT = 5,
+    UNRECOGNIZED = -1
+}
+export declare const ResponseApplySnapshotChunk_ResultSDKType: typeof ResponseApplySnapshotChunk_Result;
+export declare function responseApplySnapshotChunk_ResultFromJSON(object: any): ResponseApplySnapshotChunk_Result;
+export declare function responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySnapshotChunk_Result): string;
+export declare enum ResponseProcessProposal_ProposalStatus {
+    UNKNOWN = 0,
+    ACCEPT = 1,
+    REJECT = 2,
+    UNRECOGNIZED = -1
+}
+export declare const ResponseProcessProposal_ProposalStatusSDKType: typeof ResponseProcessProposal_ProposalStatus;
+export declare function responseProcessProposal_ProposalStatusFromJSON(object: any): ResponseProcessProposal_ProposalStatus;
+export declare function responseProcessProposal_ProposalStatusToJSON(object: ResponseProcessProposal_ProposalStatus): string;
+export declare enum ResponseVerifyVoteExtension_VerifyStatus {
+    UNKNOWN = 0,
+    ACCEPT = 1,
+    /**
+     * REJECT - Rejecting the vote extension will reject the entire precommit by the sender.
+     * Incorrectly implementing this thus has liveness implications as it may affect
+     * CometBFT's ability to receive 2/3+ valid votes to finalize the block.
+     * Honest nodes should never be rejected.
+     */
+    REJECT = 2,
+    UNRECOGNIZED = -1
+}
+export declare const ResponseVerifyVoteExtension_VerifyStatusSDKType: typeof ResponseVerifyVoteExtension_VerifyStatus;
+export declare function responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): ResponseVerifyVoteExtension_VerifyStatus;
+export declare function responseVerifyVoteExtension_VerifyStatusToJSON(object: ResponseVerifyVoteExtension_VerifyStatus): string;
+export declare enum MisbehaviorType {
     UNKNOWN = 0,
     DUPLICATE_VOTE = 1,
     LIGHT_CLIENT_ATTACK = 2,
     UNRECOGNIZED = -1
 }
-export declare const EvidenceTypeSDKType: typeof EvidenceType;
-export declare function evidenceTypeFromJSON(object: any): EvidenceType;
-export declare function evidenceTypeToJSON(object: EvidenceType): string;
-/**
- * message Request {
- * oneof value {
- * RequestEcho               echo                 = 1;
- * RequestFlush              flush                = 2;
- * RequestInfo               info                 = 3;
- * RequestSetOption          set_option           = 4;
- * RequestInitChain          init_chain           = 5;
- * RequestQuery              query                = 6;
- * RequestBeginBlock         begin_block          = 7;
- * RequestCheckTx            check_tx             = 8;
- * RequestDeliverTx          deliver_tx           = 9;
- * RequestEndBlock           end_block            = 10;
- * RequestCommit             commit               = 11;
- * RequestListSnapshots      list_snapshots       = 12;
- * RequestOfferSnapshot      offer_snapshot       = 13;
- * RequestLoadSnapshotChunk  load_snapshot_chunk  = 14;
- * RequestApplySnapshotChunk apply_snapshot_chunk = 15;
- * }
- * }
- *
- * message RequestEcho {
- * string message = 1;
- * }
- *
- * message RequestFlush {}
- *
- * message RequestInfo {
- * string version       = 1;
- * uint64 block_version = 2;
- * uint64 p2p_version   = 3;
- * }
- *
- * nondeterministic
- * message RequestSetOption {
- * string key   = 1;
- * string value = 2;
- * }
- *
- * message RequestInitChain {
- * google.protobuf.Timestamp time             = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
- * string                    chain_id         = 2;
- * ConsensusParams           consensus_params = 3;
- * repeated ValidatorUpdate  validators       = 4 [(gogoproto.nullable) = false];
- * bytes                     app_state_bytes  = 5;
- * int64                     initial_height   = 6;
- * }
- */
+export declare const MisbehaviorTypeSDKType: typeof MisbehaviorType;
+export declare function misbehaviorTypeFromJSON(object: any): MisbehaviorType;
+export declare function misbehaviorTypeToJSON(object: MisbehaviorType): string;
+export interface Request {
+    echo?: RequestEcho;
+    flush?: RequestFlush;
+    info?: RequestInfo;
+    initChain?: RequestInitChain;
+    query?: RequestQuery;
+    checkTx?: RequestCheckTx;
+    commit?: RequestCommit;
+    listSnapshots?: RequestListSnapshots;
+    offerSnapshot?: RequestOfferSnapshot;
+    loadSnapshotChunk?: RequestLoadSnapshotChunk;
+    applySnapshotChunk?: RequestApplySnapshotChunk;
+    prepareProposal?: RequestPrepareProposal;
+    processProposal?: RequestProcessProposal;
+    extendVote?: RequestExtendVote;
+    verifyVoteExtension?: RequestVerifyVoteExtension;
+    finalizeBlock?: RequestFinalizeBlock;
+}
+export interface RequestProtoMsg {
+    typeUrl: '/tendermint.abci.Request';
+    value: Uint8Array;
+}
+export interface RequestSDKType {
+    echo?: RequestEchoSDKType;
+    flush?: RequestFlushSDKType;
+    info?: RequestInfoSDKType;
+    init_chain?: RequestInitChainSDKType;
+    query?: RequestQuerySDKType;
+    check_tx?: RequestCheckTxSDKType;
+    commit?: RequestCommitSDKType;
+    list_snapshots?: RequestListSnapshotsSDKType;
+    offer_snapshot?: RequestOfferSnapshotSDKType;
+    load_snapshot_chunk?: RequestLoadSnapshotChunkSDKType;
+    apply_snapshot_chunk?: RequestApplySnapshotChunkSDKType;
+    prepare_proposal?: RequestPrepareProposalSDKType;
+    process_proposal?: RequestProcessProposalSDKType;
+    extend_vote?: RequestExtendVoteSDKType;
+    verify_vote_extension?: RequestVerifyVoteExtensionSDKType;
+    finalize_block?: RequestFinalizeBlockSDKType;
+}
+export interface RequestEcho {
+    message: string;
+}
+export interface RequestEchoProtoMsg {
+    typeUrl: '/tendermint.abci.RequestEcho';
+    value: Uint8Array;
+}
+export interface RequestEchoSDKType {
+    message: string;
+}
+export interface RequestFlush {
+}
+export interface RequestFlushProtoMsg {
+    typeUrl: '/tendermint.abci.RequestFlush';
+    value: Uint8Array;
+}
+export interface RequestFlushSDKType {
+}
+export interface RequestInfo {
+    version: string;
+    blockVersion: bigint;
+    p2pVersion: bigint;
+    abciVersion: string;
+}
+export interface RequestInfoProtoMsg {
+    typeUrl: '/tendermint.abci.RequestInfo';
+    value: Uint8Array;
+}
+export interface RequestInfoSDKType {
+    version: string;
+    block_version: bigint;
+    p2p_version: bigint;
+    abci_version: string;
+}
+export interface RequestInitChain {
+    time: Timestamp;
+    chainId: string;
+    consensusParams?: ConsensusParams;
+    validators: ValidatorUpdate[];
+    appStateBytes: Uint8Array;
+    initialHeight: bigint;
+}
+export interface RequestInitChainProtoMsg {
+    typeUrl: '/tendermint.abci.RequestInitChain';
+    value: Uint8Array;
+}
+export interface RequestInitChainSDKType {
+    time: TimestampSDKType;
+    chain_id: string;
+    consensus_params?: ConsensusParamsSDKType;
+    validators: ValidatorUpdateSDKType[];
+    app_state_bytes: Uint8Array;
+    initial_height: bigint;
+}
 export interface RequestQuery {
     data: Uint8Array;
     path: string;
@@ -80,76 +186,12 @@ export interface RequestQueryProtoMsg {
     typeUrl: '/tendermint.abci.RequestQuery';
     value: Uint8Array;
 }
-/**
- * message Request {
- * oneof value {
- * RequestEcho               echo                 = 1;
- * RequestFlush              flush                = 2;
- * RequestInfo               info                 = 3;
- * RequestSetOption          set_option           = 4;
- * RequestInitChain          init_chain           = 5;
- * RequestQuery              query                = 6;
- * RequestBeginBlock         begin_block          = 7;
- * RequestCheckTx            check_tx             = 8;
- * RequestDeliverTx          deliver_tx           = 9;
- * RequestEndBlock           end_block            = 10;
- * RequestCommit             commit               = 11;
- * RequestListSnapshots      list_snapshots       = 12;
- * RequestOfferSnapshot      offer_snapshot       = 13;
- * RequestLoadSnapshotChunk  load_snapshot_chunk  = 14;
- * RequestApplySnapshotChunk apply_snapshot_chunk = 15;
- * }
- * }
- *
- * message RequestEcho {
- * string message = 1;
- * }
- *
- * message RequestFlush {}
- *
- * message RequestInfo {
- * string version       = 1;
- * uint64 block_version = 2;
- * uint64 p2p_version   = 3;
- * }
- *
- * nondeterministic
- * message RequestSetOption {
- * string key   = 1;
- * string value = 2;
- * }
- *
- * message RequestInitChain {
- * google.protobuf.Timestamp time             = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
- * string                    chain_id         = 2;
- * ConsensusParams           consensus_params = 3;
- * repeated ValidatorUpdate  validators       = 4 [(gogoproto.nullable) = false];
- * bytes                     app_state_bytes  = 5;
- * int64                     initial_height   = 6;
- * }
- */
 export interface RequestQuerySDKType {
     data: Uint8Array;
     path: string;
     height: bigint;
     prove: boolean;
 }
-export interface RequestBeginBlock {
-    hash: Uint8Array;
-    header: Header;
-    lastCommitInfo: LastCommitInfo;
-    byzantineValidators: Evidence[];
-}
-export interface RequestBeginBlockProtoMsg {
-    typeUrl: '/tendermint.abci.RequestBeginBlock';
-    value: Uint8Array;
-}
-export interface RequestBeginBlockSDKType {
-    hash: Uint8Array;
-    header: HeaderSDKType;
-    last_commit_info: LastCommitInfoSDKType;
-    byzantine_validators: EvidenceSDKType[];
-}
 export interface RequestCheckTx {
     tx: Uint8Array;
     type: CheckTxType;
@@ -162,117 +204,308 @@ export interface RequestCheckTxSDKType {
     tx: Uint8Array;
     type: CheckTxType;
 }
-export interface RequestDeliverTx {
-    tx: Uint8Array;
+export interface RequestCommit {
 }
-export interface RequestDeliverTxProtoMsg {
-    typeUrl: '/tendermint.abci.RequestDeliverTx';
+export interface RequestCommitProtoMsg {
+    typeUrl: '/tendermint.abci.RequestCommit';
     value: Uint8Array;
 }
-export interface RequestDeliverTxSDKType {
-    tx: Uint8Array;
+export interface RequestCommitSDKType {
+}
+/** lists available snapshots */
+export interface RequestListSnapshots {
 }
-export interface RequestEndBlock {
+export interface RequestListSnapshotsProtoMsg {
+    typeUrl: '/tendermint.abci.RequestListSnapshots';
+    value: Uint8Array;
+}
+/** lists available snapshots */
+export interface RequestListSnapshotsSDKType {
+}
+/** offers a snapshot to the application */
+export interface RequestOfferSnapshot {
+    /** snapshot offered by peers */
+    snapshot?: Snapshot;
+    /** light client-verified app hash for snapshot height */
+    appHash: Uint8Array;
+}
+export interface RequestOfferSnapshotProtoMsg {
+    typeUrl: '/tendermint.abci.RequestOfferSnapshot';
+    value: Uint8Array;
+}
+/** offers a snapshot to the application */
+export interface RequestOfferSnapshotSDKType {
+    snapshot?: SnapshotSDKType;
+    app_hash: Uint8Array;
+}
+/** loads a snapshot chunk */
+export interface RequestLoadSnapshotChunk {
     height: bigint;
+    format: number;
+    chunk: number;
 }
-export interface RequestEndBlockProtoMsg {
-    typeUrl: '/tendermint.abci.RequestEndBlock';
+export interface RequestLoadSnapshotChunkProtoMsg {
+    typeUrl: '/tendermint.abci.RequestLoadSnapshotChunk';
     value: Uint8Array;
 }
-export interface RequestEndBlockSDKType {
+/** loads a snapshot chunk */
+export interface RequestLoadSnapshotChunkSDKType {
     height: bigint;
+    format: number;
+    chunk: number;
 }
-export interface RequestCommit {
+/** Applies a snapshot chunk */
+export interface RequestApplySnapshotChunk {
+    index: number;
+    chunk: Uint8Array;
+    sender: string;
 }
-export interface RequestCommitProtoMsg {
-    typeUrl: '/tendermint.abci.RequestCommit';
+export interface RequestApplySnapshotChunkProtoMsg {
+    typeUrl: '/tendermint.abci.RequestApplySnapshotChunk';
     value: Uint8Array;
 }
-export interface RequestCommitSDKType {
+/** Applies a snapshot chunk */
+export interface RequestApplySnapshotChunkSDKType {
+    index: number;
+    chunk: Uint8Array;
+    sender: string;
+}
+export interface RequestPrepareProposal {
+    /** the modified transactions cannot exceed this size. */
+    maxTxBytes: bigint;
+    /**
+     * txs is an array of transactions that will be included in a block,
+     * sent to the app for possible modifications.
+     */
+    txs: Uint8Array[];
+    localLastCommit: ExtendedCommitInfo;
+    misbehavior: Misbehavior[];
+    height: bigint;
+    time: Timestamp;
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the validator proposing the block. */
+    proposerAddress: Uint8Array;
+}
+export interface RequestPrepareProposalProtoMsg {
+    typeUrl: '/tendermint.abci.RequestPrepareProposal';
+    value: Uint8Array;
+}
+export interface RequestPrepareProposalSDKType {
+    max_tx_bytes: bigint;
+    txs: Uint8Array[];
+    local_last_commit: ExtendedCommitInfoSDKType;
+    misbehavior: MisbehaviorSDKType[];
+    height: bigint;
+    time: TimestampSDKType;
+    next_validators_hash: Uint8Array;
+    proposer_address: Uint8Array;
+}
+export interface RequestProcessProposal {
+    txs: Uint8Array[];
+    proposedLastCommit: CommitInfo;
+    misbehavior: Misbehavior[];
+    /** hash is the merkle root hash of the fields of the proposed block. */
+    hash: Uint8Array;
+    height: bigint;
+    time: Timestamp;
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+export interface RequestProcessProposalProtoMsg {
+    typeUrl: '/tendermint.abci.RequestProcessProposal';
+    value: Uint8Array;
+}
+export interface RequestProcessProposalSDKType {
+    txs: Uint8Array[];
+    proposed_last_commit: CommitInfoSDKType;
+    misbehavior: MisbehaviorSDKType[];
+    hash: Uint8Array;
+    height: bigint;
+    time: TimestampSDKType;
+    next_validators_hash: Uint8Array;
+    proposer_address: Uint8Array;
+}
+/** Extends a vote with application-injected data */
+export interface RequestExtendVote {
+    /** the hash of the block that this vote may be referring to */
+    hash: Uint8Array;
+    /** the height of the extended vote */
+    height: bigint;
+    /** info of the block that this vote may be referring to */
+    time: Timestamp;
+    txs: Uint8Array[];
+    proposedLastCommit: CommitInfo;
+    misbehavior: Misbehavior[];
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+export interface RequestExtendVoteProtoMsg {
+    typeUrl: '/tendermint.abci.RequestExtendVote';
+    value: Uint8Array;
+}
+/** Extends a vote with application-injected data */
+export interface RequestExtendVoteSDKType {
+    hash: Uint8Array;
+    height: bigint;
+    time: TimestampSDKType;
+    txs: Uint8Array[];
+    proposed_last_commit: CommitInfoSDKType;
+    misbehavior: MisbehaviorSDKType[];
+    next_validators_hash: Uint8Array;
+    proposer_address: Uint8Array;
+}
+/** Verify the vote extension */
+export interface RequestVerifyVoteExtension {
+    /** the hash of the block that this received vote corresponds to */
+    hash: Uint8Array;
+    /** the validator that signed the vote extension */
+    validatorAddress: Uint8Array;
+    height: bigint;
+    voteExtension: Uint8Array;
+}
+export interface RequestVerifyVoteExtensionProtoMsg {
+    typeUrl: '/tendermint.abci.RequestVerifyVoteExtension';
+    value: Uint8Array;
+}
+/** Verify the vote extension */
+export interface RequestVerifyVoteExtensionSDKType {
+    hash: Uint8Array;
+    validator_address: Uint8Array;
+    height: bigint;
+    vote_extension: Uint8Array;
+}
+export interface RequestFinalizeBlock {
+    txs: Uint8Array[];
+    decidedLastCommit: CommitInfo;
+    misbehavior: Misbehavior[];
+    /** hash is the merkle root hash of the fields of the decided block. */
+    hash: Uint8Array;
+    height: bigint;
+    time: Timestamp;
+    nextValidatorsHash: Uint8Array;
+    /** proposer_address is the address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+export interface RequestFinalizeBlockProtoMsg {
+    typeUrl: '/tendermint.abci.RequestFinalizeBlock';
+    value: Uint8Array;
+}
+export interface RequestFinalizeBlockSDKType {
+    txs: Uint8Array[];
+    decided_last_commit: CommitInfoSDKType;
+    misbehavior: MisbehaviorSDKType[];
+    hash: Uint8Array;
+    height: bigint;
+    time: TimestampSDKType;
+    next_validators_hash: Uint8Array;
+    proposer_address: Uint8Array;
+}
+export interface Response {
+    exception?: ResponseException;
+    echo?: ResponseEcho;
+    flush?: ResponseFlush;
+    info?: ResponseInfo;
+    initChain?: ResponseInitChain;
+    query?: ResponseQuery;
+    checkTx?: ResponseCheckTx;
+    commit?: ResponseCommit;
+    listSnapshots?: ResponseListSnapshots;
+    offerSnapshot?: ResponseOfferSnapshot;
+    loadSnapshotChunk?: ResponseLoadSnapshotChunk;
+    applySnapshotChunk?: ResponseApplySnapshotChunk;
+    prepareProposal?: ResponsePrepareProposal;
+    processProposal?: ResponseProcessProposal;
+    extendVote?: ResponseExtendVote;
+    verifyVoteExtension?: ResponseVerifyVoteExtension;
+    finalizeBlock?: ResponseFinalizeBlock;
+}
+export interface ResponseProtoMsg {
+    typeUrl: '/tendermint.abci.Response';
+    value: Uint8Array;
+}
+export interface ResponseSDKType {
+    exception?: ResponseExceptionSDKType;
+    echo?: ResponseEchoSDKType;
+    flush?: ResponseFlushSDKType;
+    info?: ResponseInfoSDKType;
+    init_chain?: ResponseInitChainSDKType;
+    query?: ResponseQuerySDKType;
+    check_tx?: ResponseCheckTxSDKType;
+    commit?: ResponseCommitSDKType;
+    list_snapshots?: ResponseListSnapshotsSDKType;
+    offer_snapshot?: ResponseOfferSnapshotSDKType;
+    load_snapshot_chunk?: ResponseLoadSnapshotChunkSDKType;
+    apply_snapshot_chunk?: ResponseApplySnapshotChunkSDKType;
+    prepare_proposal?: ResponsePrepareProposalSDKType;
+    process_proposal?: ResponseProcessProposalSDKType;
+    extend_vote?: ResponseExtendVoteSDKType;
+    verify_vote_extension?: ResponseVerifyVoteExtensionSDKType;
+    finalize_block?: ResponseFinalizeBlockSDKType;
+}
+/** nondeterministic */
+export interface ResponseException {
+    error: string;
+}
+export interface ResponseExceptionProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseException';
+    value: Uint8Array;
+}
+/** nondeterministic */
+export interface ResponseExceptionSDKType {
+    error: string;
+}
+export interface ResponseEcho {
+    message: string;
+}
+export interface ResponseEchoProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseEcho';
+    value: Uint8Array;
+}
+export interface ResponseEchoSDKType {
+    message: string;
+}
+export interface ResponseFlush {
+}
+export interface ResponseFlushProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseFlush';
+    value: Uint8Array;
+}
+export interface ResponseFlushSDKType {
+}
+export interface ResponseInfo {
+    data: string;
+    version: string;
+    appVersion: bigint;
+    lastBlockHeight: bigint;
+    lastBlockAppHash: Uint8Array;
+}
+export interface ResponseInfoProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseInfo';
+    value: Uint8Array;
+}
+export interface ResponseInfoSDKType {
+    data: string;
+    version: string;
+    app_version: bigint;
+    last_block_height: bigint;
+    last_block_app_hash: Uint8Array;
+}
+export interface ResponseInitChain {
+    consensusParams?: ConsensusParams;
+    validators: ValidatorUpdate[];
+    appHash: Uint8Array;
+}
+export interface ResponseInitChainProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseInitChain';
+    value: Uint8Array;
+}
+export interface ResponseInitChainSDKType {
+    consensus_params?: ConsensusParamsSDKType;
+    validators: ValidatorUpdateSDKType[];
+    app_hash: Uint8Array;
 }
-/**
- * lists available snapshots
- * message RequestListSnapshots {}
- *
- * offers a snapshot to the application
- * message RequestOfferSnapshot {
- * Snapshot snapshot = 1; // snapshot offered by peers
- * bytes    app_hash = 2; // light client-verified app hash for snapshot height
- * }
- *
- * loads a snapshot chunk
- * message RequestLoadSnapshotChunk {
- * uint64 height = 1;
- * uint32 format = 2;
- * uint32 chunk  = 3;
- * }
- *
- * Applies a snapshot chunk
- * message RequestApplySnapshotChunk {
- * uint32 index  = 1;
- * bytes  chunk  = 2;
- * string sender = 3;
- * }
- *
- * ----------------------------------------
- * Response types
- *
- * message Response {
- * oneof value {
- * ResponseException          exception            = 1;
- * ResponseEcho               echo                 = 2;
- * ResponseFlush              flush                = 3;
- * ResponseInfo               info                 = 4;
- * ResponseSetOption          set_option           = 5;
- * ResponseInitChain          init_chain           = 6;
- * ResponseQuery              query                = 7;
- * ResponseBeginBlock         begin_block          = 8;
- * ResponseCheckTx            check_tx             = 9;
- * ResponseDeliverTx          deliver_tx           = 10;
- * ResponseEndBlock           end_block            = 11;
- * ResponseCommit             commit               = 12;
- * ResponseListSnapshots      list_snapshots       = 13;
- * ResponseOfferSnapshot      offer_snapshot       = 14;
- * ResponseLoadSnapshotChunk  load_snapshot_chunk  = 15;
- * ResponseApplySnapshotChunk apply_snapshot_chunk = 16;
- * }
- * }
- *
- * nondeterministic
- * message ResponseException {
- * string error = 1;
- * }
- *
- * message ResponseEcho {
- * string message = 1;
- * }
- *
- * message ResponseFlush {}
- *
- * message ResponseInfo {
- * string data = 1;
- *
- * string version     = 2;
- * uint64 app_version = 3;
- *
- * int64 last_block_height   = 4;
- * bytes last_block_app_hash = 5;
- * }
- *
- * nondeterministic
- * message ResponseSetOption {
- * uint32 code = 1;
- * bytes data = 2;
- * string log  = 3;
- * string info = 4;
- * }
- *
- * message ResponseInitChain {
- * ConsensusParams          consensus_params = 1;
- * repeated ValidatorUpdate validators       = 2 [(gogoproto.nullable) = false];
- * bytes                    app_hash         = 3;
- * }
- */
 export interface ResponseQuery {
     code: number;
     /** bytes data = 2; // use "value" instead. */
@@ -290,89 +523,6 @@ export interface ResponseQueryProtoMsg {
     typeUrl: '/tendermint.abci.ResponseQuery';
     value: Uint8Array;
 }
-/**
- * lists available snapshots
- * message RequestListSnapshots {}
- *
- * offers a snapshot to the application
- * message RequestOfferSnapshot {
- * Snapshot snapshot = 1; // snapshot offered by peers
- * bytes    app_hash = 2; // light client-verified app hash for snapshot height
- * }
- *
- * loads a snapshot chunk
- * message RequestLoadSnapshotChunk {
- * uint64 height = 1;
- * uint32 format = 2;
- * uint32 chunk  = 3;
- * }
- *
- * Applies a snapshot chunk
- * message RequestApplySnapshotChunk {
- * uint32 index  = 1;
- * bytes  chunk  = 2;
- * string sender = 3;
- * }
- *
- * ----------------------------------------
- * Response types
- *
- * message Response {
- * oneof value {
- * ResponseException          exception            = 1;
- * ResponseEcho               echo                 = 2;
- * ResponseFlush              flush                = 3;
- * ResponseInfo               info                 = 4;
- * ResponseSetOption          set_option           = 5;
- * ResponseInitChain          init_chain           = 6;
- * ResponseQuery              query                = 7;
- * ResponseBeginBlock         begin_block          = 8;
- * ResponseCheckTx            check_tx             = 9;
- * ResponseDeliverTx          deliver_tx           = 10;
- * ResponseEndBlock           end_block            = 11;
- * ResponseCommit             commit               = 12;
- * ResponseListSnapshots      list_snapshots       = 13;
- * ResponseOfferSnapshot      offer_snapshot       = 14;
- * ResponseLoadSnapshotChunk  load_snapshot_chunk  = 15;
- * ResponseApplySnapshotChunk apply_snapshot_chunk = 16;
- * }
- * }
- *
- * nondeterministic
- * message ResponseException {
- * string error = 1;
- * }
- *
- * message ResponseEcho {
- * string message = 1;
- * }
- *
- * message ResponseFlush {}
- *
- * message ResponseInfo {
- * string data = 1;
- *
- * string version     = 2;
- * uint64 app_version = 3;
- *
- * int64 last_block_height   = 4;
- * bytes last_block_app_hash = 5;
- * }
- *
- * nondeterministic
- * message ResponseSetOption {
- * uint32 code = 1;
- * bytes data = 2;
- * string log  = 3;
- * string info = 4;
- * }
- *
- * message ResponseInitChain {
- * ConsensusParams          consensus_params = 1;
- * repeated ValidatorUpdate validators       = 2 [(gogoproto.nullable) = false];
- * bytes                    app_hash         = 3;
- * }
- */
 export interface ResponseQuerySDKType {
     code: number;
     log: string;
@@ -384,16 +534,6 @@ export interface ResponseQuerySDKType {
     height: bigint;
     codespace: string;
 }
-export interface ResponseBeginBlock {
-    events: Event[];
-}
-export interface ResponseBeginBlockProtoMsg {
-    typeUrl: '/tendermint.abci.ResponseBeginBlock';
-    value: Uint8Array;
-}
-export interface ResponseBeginBlockSDKType {
-    events: EventSDKType[];
-}
 export interface ResponseCheckTx {
     code: number;
     data: Uint8Array;
@@ -420,74 +560,174 @@ export interface ResponseCheckTxSDKType {
     events: EventSDKType[];
     codespace: string;
 }
-export interface ResponseDeliverTx {
-    code: number;
-    data: Uint8Array;
-    /** nondeterministic */
-    log: string;
-    /** nondeterministic */
-    info: string;
-    gasWanted: bigint;
-    gasUsed: bigint;
-    events: Event[];
-    codespace: string;
+export interface ResponseCommit {
+    retainHeight: bigint;
 }
-export interface ResponseDeliverTxProtoMsg {
-    typeUrl: '/tendermint.abci.ResponseDeliverTx';
+export interface ResponseCommitProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseCommit';
     value: Uint8Array;
 }
-export interface ResponseDeliverTxSDKType {
-    code: number;
-    data: Uint8Array;
-    log: string;
-    info: string;
-    gas_wanted: bigint;
-    gas_used: bigint;
-    events: EventSDKType[];
-    codespace: string;
+export interface ResponseCommitSDKType {
+    retain_height: bigint;
+}
+export interface ResponseListSnapshots {
+    snapshots: Snapshot[];
+}
+export interface ResponseListSnapshotsProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseListSnapshots';
+    value: Uint8Array;
+}
+export interface ResponseListSnapshotsSDKType {
+    snapshots: SnapshotSDKType[];
+}
+export interface ResponseOfferSnapshot {
+    result: ResponseOfferSnapshot_Result;
+}
+export interface ResponseOfferSnapshotProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseOfferSnapshot';
+    value: Uint8Array;
+}
+export interface ResponseOfferSnapshotSDKType {
+    result: ResponseOfferSnapshot_Result;
+}
+export interface ResponseLoadSnapshotChunk {
+    chunk: Uint8Array;
+}
+export interface ResponseLoadSnapshotChunkProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseLoadSnapshotChunk';
+    value: Uint8Array;
 }
-export interface ResponseEndBlock {
+export interface ResponseLoadSnapshotChunkSDKType {
+    chunk: Uint8Array;
+}
+export interface ResponseApplySnapshotChunk {
+    result: ResponseApplySnapshotChunk_Result;
+    /** Chunks to refetch and reapply */
+    refetchChunks: number[];
+    /** Chunk senders to reject and ban */
+    rejectSenders: string[];
+}
+export interface ResponseApplySnapshotChunkProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseApplySnapshotChunk';
+    value: Uint8Array;
+}
+export interface ResponseApplySnapshotChunkSDKType {
+    result: ResponseApplySnapshotChunk_Result;
+    refetch_chunks: number[];
+    reject_senders: string[];
+}
+export interface ResponsePrepareProposal {
+    txs: Uint8Array[];
+}
+export interface ResponsePrepareProposalProtoMsg {
+    typeUrl: '/tendermint.abci.ResponsePrepareProposal';
+    value: Uint8Array;
+}
+export interface ResponsePrepareProposalSDKType {
+    txs: Uint8Array[];
+}
+export interface ResponseProcessProposal {
+    status: ResponseProcessProposal_ProposalStatus;
+}
+export interface ResponseProcessProposalProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseProcessProposal';
+    value: Uint8Array;
+}
+export interface ResponseProcessProposalSDKType {
+    status: ResponseProcessProposal_ProposalStatus;
+}
+export interface ResponseExtendVote {
+    voteExtension: Uint8Array;
+}
+export interface ResponseExtendVoteProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseExtendVote';
+    value: Uint8Array;
+}
+export interface ResponseExtendVoteSDKType {
+    vote_extension: Uint8Array;
+}
+export interface ResponseVerifyVoteExtension {
+    status: ResponseVerifyVoteExtension_VerifyStatus;
+}
+export interface ResponseVerifyVoteExtensionProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseVerifyVoteExtension';
+    value: Uint8Array;
+}
+export interface ResponseVerifyVoteExtensionSDKType {
+    status: ResponseVerifyVoteExtension_VerifyStatus;
+}
+export interface ResponseFinalizeBlock {
+    /** set of block events emmitted as part of executing the block */
+    events: Event[];
+    /**
+     * the result of executing each transaction including the events
+     * the particular transction emitted. This should match the order
+     * of the transactions delivered in the block itself
+     */
+    txResults: ExecTxResult[];
+    /** a list of updates to the validator set. These will reflect the validator set at current height + 2. */
     validatorUpdates: ValidatorUpdate[];
+    /** updates to the consensus params, if any. */
     consensusParamUpdates?: ConsensusParams;
-    events: Event[];
+    /**
+     * app_hash is the hash of the applications' state which is used to confirm that execution of the transactions was
+     * deterministic. It is up to the application to decide which algorithm to use.
+     */
+    appHash: Uint8Array;
 }
-export interface ResponseEndBlockProtoMsg {
-    typeUrl: '/tendermint.abci.ResponseEndBlock';
+export interface ResponseFinalizeBlockProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseFinalizeBlock';
     value: Uint8Array;
 }
-export interface ResponseEndBlockSDKType {
+export interface ResponseFinalizeBlockSDKType {
+    events: EventSDKType[];
+    tx_results: ExecTxResultSDKType[];
     validator_updates: ValidatorUpdateSDKType[];
     consensus_param_updates?: ConsensusParamsSDKType;
-    events: EventSDKType[];
+    app_hash: Uint8Array;
 }
-export interface ResponseCommit {
-    /** reserve 1 */
-    data: Uint8Array;
-    retainHeight: bigint;
+export interface CommitInfo {
+    round: number;
+    votes: VoteInfo[];
 }
-export interface ResponseCommitProtoMsg {
-    typeUrl: '/tendermint.abci.ResponseCommit';
+export interface CommitInfoProtoMsg {
+    typeUrl: '/tendermint.abci.CommitInfo';
     value: Uint8Array;
 }
-export interface ResponseCommitSDKType {
-    data: Uint8Array;
-    retain_height: bigint;
+export interface CommitInfoSDKType {
+    round: number;
+    votes: VoteInfoSDKType[];
 }
-export interface LastCommitInfo {
+/**
+ * ExtendedCommitInfo is similar to CommitInfo except that it is only used in
+ * the PrepareProposal request such that CometBFT can provide vote extensions
+ * to the application.
+ */
+export interface ExtendedCommitInfo {
+    /** The round at which the block proposer decided in the previous height. */
     round: number;
-    votes: VoteInfo[];
+    /**
+     * List of validators' addresses in the last validator set with their voting
+     * information, including vote extensions.
+     */
+    votes: ExtendedVoteInfo[];
 }
-export interface LastCommitInfoProtoMsg {
-    typeUrl: '/tendermint.abci.LastCommitInfo';
+export interface ExtendedCommitInfoProtoMsg {
+    typeUrl: '/tendermint.abci.ExtendedCommitInfo';
     value: Uint8Array;
 }
-export interface LastCommitInfoSDKType {
+/**
+ * ExtendedCommitInfo is similar to CommitInfo except that it is only used in
+ * the PrepareProposal request such that CometBFT can provide vote extensions
+ * to the application.
+ */
+export interface ExtendedCommitInfoSDKType {
     round: number;
-    votes: VoteInfoSDKType[];
+    votes: ExtendedVoteInfoSDKType[];
 }
 /**
  * Event allows application developers to attach additional information to
- * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
+ * ResponseFinalizeBlock and ResponseCheckTx.
  * Later, transactions may be queried using these events.
  */
 export interface Event {
@@ -500,7 +740,7 @@ export interface EventProtoMsg {
 }
 /**
  * Event allows application developers to attach additional information to
- * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
+ * ResponseFinalizeBlock and ResponseCheckTx.
  * Later, transactions may be queried using these events.
  */
 export interface EventSDKType {
@@ -509,8 +749,8 @@ export interface EventSDKType {
 }
 /** EventAttribute is a single key-value pair, associated with an event. */
 export interface EventAttribute {
-    key: Uint8Array;
-    value: Uint8Array;
+    key: string;
+    value: string;
     /** nondeterministic */
     index: boolean;
 }
@@ -520,10 +760,46 @@ export interface EventAttributeProtoMsg {
 }
 /** EventAttribute is a single key-value pair, associated with an event. */
 export interface EventAttributeSDKType {
-    key: Uint8Array;
-    value: Uint8Array;
+    key: string;
+    value: string;
     index: boolean;
 }
+/**
+ * ExecTxResult contains results of executing one individual transaction.
+ *
+ * * Its structure is equivalent to #ResponseDeliverTx which will be deprecated/deleted
+ */
+export interface ExecTxResult {
+    code: number;
+    data: Uint8Array;
+    /** nondeterministic */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    gasWanted: bigint;
+    gasUsed: bigint;
+    events: Event[];
+    codespace: string;
+}
+export interface ExecTxResultProtoMsg {
+    typeUrl: '/tendermint.abci.ExecTxResult';
+    value: Uint8Array;
+}
+/**
+ * ExecTxResult contains results of executing one individual transaction.
+ *
+ * * Its structure is equivalent to #ResponseDeliverTx which will be deprecated/deleted
+ */
+export interface ExecTxResultSDKType {
+    code: number;
+    data: Uint8Array;
+    log: string;
+    info: string;
+    gas_wanted: bigint;
+    gas_used: bigint;
+    events: EventSDKType[];
+    codespace: string;
+}
 /**
  * TxResult contains results of executing the transaction.
  *
@@ -533,7 +809,7 @@ export interface TxResult {
     height: bigint;
     index: number;
     tx: Uint8Array;
-    result: ResponseDeliverTx;
+    result: ExecTxResult;
 }
 export interface TxResultProtoMsg {
     typeUrl: '/tendermint.abci.TxResult';
@@ -548,9 +824,8 @@ export interface TxResultSDKType {
     height: bigint;
     index: number;
     tx: Uint8Array;
-    result: ResponseDeliverTxSDKType;
+    result: ExecTxResultSDKType;
 }
-/** Validator */
 export interface Validator {
     /** The first 20 bytes of SHA256(public key) */
     address: Uint8Array;
@@ -561,12 +836,10 @@ export interface ValidatorProtoMsg {
     typeUrl: '/tendermint.abci.Validator';
     value: Uint8Array;
 }
-/** Validator */
 export interface ValidatorSDKType {
     address: Uint8Array;
     power: bigint;
 }
-/** ValidatorUpdate */
 export interface ValidatorUpdate {
     pubKey: PublicKey;
     power: bigint;
@@ -575,27 +848,44 @@ export interface ValidatorUpdateProtoMsg {
     typeUrl: '/tendermint.abci.ValidatorUpdate';
     value: Uint8Array;
 }
-/** ValidatorUpdate */
 export interface ValidatorUpdateSDKType {
     pub_key: PublicKeySDKType;
     power: bigint;
 }
-/** VoteInfo */
 export interface VoteInfo {
     validator: Validator;
-    signedLastBlock: boolean;
+    blockIdFlag: BlockIDFlag;
 }
 export interface VoteInfoProtoMsg {
     typeUrl: '/tendermint.abci.VoteInfo';
     value: Uint8Array;
 }
-/** VoteInfo */
 export interface VoteInfoSDKType {
     validator: ValidatorSDKType;
-    signed_last_block: boolean;
+    block_id_flag: BlockIDFlag;
+}
+export interface ExtendedVoteInfo {
+    /** The validator that sent the vote. */
+    validator: Validator;
+    /** Non-deterministic extension provided by the sending validator's application. */
+    voteExtension: Uint8Array;
+    /** Vote extension signature created by CometBFT */
+    extensionSignature: Uint8Array;
+    /** block_id_flag indicates whether the validator voted for a block, nil, or did not vote at all */
+    blockIdFlag: BlockIDFlag;
 }
-export interface Evidence {
-    type: EvidenceType;
+export interface ExtendedVoteInfoProtoMsg {
+    typeUrl: '/tendermint.abci.ExtendedVoteInfo';
+    value: Uint8Array;
+}
+export interface ExtendedVoteInfoSDKType {
+    validator: ValidatorSDKType;
+    vote_extension: Uint8Array;
+    extension_signature: Uint8Array;
+    block_id_flag: BlockIDFlag;
+}
+export interface Misbehavior {
+    type: MisbehaviorType;
     /** The offending validator */
     validator: Validator;
     /** The height when the offense occurred */
@@ -609,17 +899,95 @@ export interface Evidence {
      */
     totalVotingPower: bigint;
 }
-export interface EvidenceProtoMsg {
-    typeUrl: '/tendermint.abci.Evidence';
+export interface MisbehaviorProtoMsg {
+    typeUrl: '/tendermint.abci.Misbehavior';
     value: Uint8Array;
 }
-export interface EvidenceSDKType {
-    type: EvidenceType;
+export interface MisbehaviorSDKType {
+    type: MisbehaviorType;
     validator: ValidatorSDKType;
     height: bigint;
     time: TimestampSDKType;
     total_voting_power: bigint;
 }
+export interface Snapshot {
+    /** The height at which the snapshot was taken */
+    height: bigint;
+    /** The application-specific snapshot format */
+    format: number;
+    /** Number of chunks in the snapshot */
+    chunks: number;
+    /** Arbitrary snapshot hash, equal only if identical */
+    hash: Uint8Array;
+    /** Arbitrary application metadata */
+    metadata: Uint8Array;
+}
+export interface SnapshotProtoMsg {
+    typeUrl: '/tendermint.abci.Snapshot';
+    value: Uint8Array;
+}
+export interface SnapshotSDKType {
+    height: bigint;
+    format: number;
+    chunks: number;
+    hash: Uint8Array;
+    metadata: Uint8Array;
+}
+export declare const Request: {
+    typeUrl: "/tendermint.abci.Request";
+    encode(message: Request, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Request;
+    fromJSON(object: any): Request;
+    toJSON(message: Request): JsonSafe<Request>;
+    fromPartial(object: Partial<Request>): Request;
+    fromProtoMsg(message: RequestProtoMsg): Request;
+    toProto(message: Request): Uint8Array;
+    toProtoMsg(message: Request): RequestProtoMsg;
+};
+export declare const RequestEcho: {
+    typeUrl: "/tendermint.abci.RequestEcho";
+    encode(message: RequestEcho, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestEcho;
+    fromJSON(object: any): RequestEcho;
+    toJSON(message: RequestEcho): JsonSafe<RequestEcho>;
+    fromPartial(object: Partial<RequestEcho>): RequestEcho;
+    fromProtoMsg(message: RequestEchoProtoMsg): RequestEcho;
+    toProto(message: RequestEcho): Uint8Array;
+    toProtoMsg(message: RequestEcho): RequestEchoProtoMsg;
+};
+export declare const RequestFlush: {
+    typeUrl: "/tendermint.abci.RequestFlush";
+    encode(_: RequestFlush, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestFlush;
+    fromJSON(_: any): RequestFlush;
+    toJSON(_: RequestFlush): JsonSafe<RequestFlush>;
+    fromPartial(_: Partial<RequestFlush>): RequestFlush;
+    fromProtoMsg(message: RequestFlushProtoMsg): RequestFlush;
+    toProto(message: RequestFlush): Uint8Array;
+    toProtoMsg(message: RequestFlush): RequestFlushProtoMsg;
+};
+export declare const RequestInfo: {
+    typeUrl: "/tendermint.abci.RequestInfo";
+    encode(message: RequestInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestInfo;
+    fromJSON(object: any): RequestInfo;
+    toJSON(message: RequestInfo): JsonSafe<RequestInfo>;
+    fromPartial(object: Partial<RequestInfo>): RequestInfo;
+    fromProtoMsg(message: RequestInfoProtoMsg): RequestInfo;
+    toProto(message: RequestInfo): Uint8Array;
+    toProtoMsg(message: RequestInfo): RequestInfoProtoMsg;
+};
+export declare const RequestInitChain: {
+    typeUrl: "/tendermint.abci.RequestInitChain";
+    encode(message: RequestInitChain, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestInitChain;
+    fromJSON(object: any): RequestInitChain;
+    toJSON(message: RequestInitChain): JsonSafe<RequestInitChain>;
+    fromPartial(object: Partial<RequestInitChain>): RequestInitChain;
+    fromProtoMsg(message: RequestInitChainProtoMsg): RequestInitChain;
+    toProto(message: RequestInitChain): Uint8Array;
+    toProtoMsg(message: RequestInitChain): RequestInitChainProtoMsg;
+};
 export declare const RequestQuery: {
     typeUrl: "/tendermint.abci.RequestQuery";
     encode(message: RequestQuery, writer?: BinaryWriter): BinaryWriter;
@@ -631,17 +999,6 @@ export declare const RequestQuery: {
     toProto(message: RequestQuery): Uint8Array;
     toProtoMsg(message: RequestQuery): RequestQueryProtoMsg;
 };
-export declare const RequestBeginBlock: {
-    typeUrl: "/tendermint.abci.RequestBeginBlock";
-    encode(message: RequestBeginBlock, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): RequestBeginBlock;
-    fromJSON(object: any): RequestBeginBlock;
-    toJSON(message: RequestBeginBlock): JsonSafe<RequestBeginBlock>;
-    fromPartial(object: Partial<RequestBeginBlock>): RequestBeginBlock;
-    fromProtoMsg(message: RequestBeginBlockProtoMsg): RequestBeginBlock;
-    toProto(message: RequestBeginBlock): Uint8Array;
-    toProtoMsg(message: RequestBeginBlock): RequestBeginBlockProtoMsg;
-};
 export declare const RequestCheckTx: {
     typeUrl: "/tendermint.abci.RequestCheckTx";
     encode(message: RequestCheckTx, writer?: BinaryWriter): BinaryWriter;
@@ -653,28 +1010,6 @@ export declare const RequestCheckTx: {
     toProto(message: RequestCheckTx): Uint8Array;
     toProtoMsg(message: RequestCheckTx): RequestCheckTxProtoMsg;
 };
-export declare const RequestDeliverTx: {
-    typeUrl: "/tendermint.abci.RequestDeliverTx";
-    encode(message: RequestDeliverTx, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): RequestDeliverTx;
-    fromJSON(object: any): RequestDeliverTx;
-    toJSON(message: RequestDeliverTx): JsonSafe<RequestDeliverTx>;
-    fromPartial(object: Partial<RequestDeliverTx>): RequestDeliverTx;
-    fromProtoMsg(message: RequestDeliverTxProtoMsg): RequestDeliverTx;
-    toProto(message: RequestDeliverTx): Uint8Array;
-    toProtoMsg(message: RequestDeliverTx): RequestDeliverTxProtoMsg;
-};
-export declare const RequestEndBlock: {
-    typeUrl: "/tendermint.abci.RequestEndBlock";
-    encode(message: RequestEndBlock, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): RequestEndBlock;
-    fromJSON(object: any): RequestEndBlock;
-    toJSON(message: RequestEndBlock): JsonSafe<RequestEndBlock>;
-    fromPartial(object: Partial<RequestEndBlock>): RequestEndBlock;
-    fromProtoMsg(message: RequestEndBlockProtoMsg): RequestEndBlock;
-    toProto(message: RequestEndBlock): Uint8Array;
-    toProtoMsg(message: RequestEndBlock): RequestEndBlockProtoMsg;
-};
 export declare const RequestCommit: {
     typeUrl: "/tendermint.abci.RequestCommit";
     encode(_: RequestCommit, writer?: BinaryWriter): BinaryWriter;
@@ -686,6 +1021,171 @@ export declare const RequestCommit: {
     toProto(message: RequestCommit): Uint8Array;
     toProtoMsg(message: RequestCommit): RequestCommitProtoMsg;
 };
+export declare const RequestListSnapshots: {
+    typeUrl: "/tendermint.abci.RequestListSnapshots";
+    encode(_: RequestListSnapshots, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestListSnapshots;
+    fromJSON(_: any): RequestListSnapshots;
+    toJSON(_: RequestListSnapshots): JsonSafe<RequestListSnapshots>;
+    fromPartial(_: Partial<RequestListSnapshots>): RequestListSnapshots;
+    fromProtoMsg(message: RequestListSnapshotsProtoMsg): RequestListSnapshots;
+    toProto(message: RequestListSnapshots): Uint8Array;
+    toProtoMsg(message: RequestListSnapshots): RequestListSnapshotsProtoMsg;
+};
+export declare const RequestOfferSnapshot: {
+    typeUrl: "/tendermint.abci.RequestOfferSnapshot";
+    encode(message: RequestOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestOfferSnapshot;
+    fromJSON(object: any): RequestOfferSnapshot;
+    toJSON(message: RequestOfferSnapshot): JsonSafe<RequestOfferSnapshot>;
+    fromPartial(object: Partial<RequestOfferSnapshot>): RequestOfferSnapshot;
+    fromProtoMsg(message: RequestOfferSnapshotProtoMsg): RequestOfferSnapshot;
+    toProto(message: RequestOfferSnapshot): Uint8Array;
+    toProtoMsg(message: RequestOfferSnapshot): RequestOfferSnapshotProtoMsg;
+};
+export declare const RequestLoadSnapshotChunk: {
+    typeUrl: "/tendermint.abci.RequestLoadSnapshotChunk";
+    encode(message: RequestLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestLoadSnapshotChunk;
+    fromJSON(object: any): RequestLoadSnapshotChunk;
+    toJSON(message: RequestLoadSnapshotChunk): JsonSafe<RequestLoadSnapshotChunk>;
+    fromPartial(object: Partial<RequestLoadSnapshotChunk>): RequestLoadSnapshotChunk;
+    fromProtoMsg(message: RequestLoadSnapshotChunkProtoMsg): RequestLoadSnapshotChunk;
+    toProto(message: RequestLoadSnapshotChunk): Uint8Array;
+    toProtoMsg(message: RequestLoadSnapshotChunk): RequestLoadSnapshotChunkProtoMsg;
+};
+export declare const RequestApplySnapshotChunk: {
+    typeUrl: "/tendermint.abci.RequestApplySnapshotChunk";
+    encode(message: RequestApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestApplySnapshotChunk;
+    fromJSON(object: any): RequestApplySnapshotChunk;
+    toJSON(message: RequestApplySnapshotChunk): JsonSafe<RequestApplySnapshotChunk>;
+    fromPartial(object: Partial<RequestApplySnapshotChunk>): RequestApplySnapshotChunk;
+    fromProtoMsg(message: RequestApplySnapshotChunkProtoMsg): RequestApplySnapshotChunk;
+    toProto(message: RequestApplySnapshotChunk): Uint8Array;
+    toProtoMsg(message: RequestApplySnapshotChunk): RequestApplySnapshotChunkProtoMsg;
+};
+export declare const RequestPrepareProposal: {
+    typeUrl: "/tendermint.abci.RequestPrepareProposal";
+    encode(message: RequestPrepareProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestPrepareProposal;
+    fromJSON(object: any): RequestPrepareProposal;
+    toJSON(message: RequestPrepareProposal): JsonSafe<RequestPrepareProposal>;
+    fromPartial(object: Partial<RequestPrepareProposal>): RequestPrepareProposal;
+    fromProtoMsg(message: RequestPrepareProposalProtoMsg): RequestPrepareProposal;
+    toProto(message: RequestPrepareProposal): Uint8Array;
+    toProtoMsg(message: RequestPrepareProposal): RequestPrepareProposalProtoMsg;
+};
+export declare const RequestProcessProposal: {
+    typeUrl: "/tendermint.abci.RequestProcessProposal";
+    encode(message: RequestProcessProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestProcessProposal;
+    fromJSON(object: any): RequestProcessProposal;
+    toJSON(message: RequestProcessProposal): JsonSafe<RequestProcessProposal>;
+    fromPartial(object: Partial<RequestProcessProposal>): RequestProcessProposal;
+    fromProtoMsg(message: RequestProcessProposalProtoMsg): RequestProcessProposal;
+    toProto(message: RequestProcessProposal): Uint8Array;
+    toProtoMsg(message: RequestProcessProposal): RequestProcessProposalProtoMsg;
+};
+export declare const RequestExtendVote: {
+    typeUrl: "/tendermint.abci.RequestExtendVote";
+    encode(message: RequestExtendVote, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestExtendVote;
+    fromJSON(object: any): RequestExtendVote;
+    toJSON(message: RequestExtendVote): JsonSafe<RequestExtendVote>;
+    fromPartial(object: Partial<RequestExtendVote>): RequestExtendVote;
+    fromProtoMsg(message: RequestExtendVoteProtoMsg): RequestExtendVote;
+    toProto(message: RequestExtendVote): Uint8Array;
+    toProtoMsg(message: RequestExtendVote): RequestExtendVoteProtoMsg;
+};
+export declare const RequestVerifyVoteExtension: {
+    typeUrl: "/tendermint.abci.RequestVerifyVoteExtension";
+    encode(message: RequestVerifyVoteExtension, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestVerifyVoteExtension;
+    fromJSON(object: any): RequestVerifyVoteExtension;
+    toJSON(message: RequestVerifyVoteExtension): JsonSafe<RequestVerifyVoteExtension>;
+    fromPartial(object: Partial<RequestVerifyVoteExtension>): RequestVerifyVoteExtension;
+    fromProtoMsg(message: RequestVerifyVoteExtensionProtoMsg): RequestVerifyVoteExtension;
+    toProto(message: RequestVerifyVoteExtension): Uint8Array;
+    toProtoMsg(message: RequestVerifyVoteExtension): RequestVerifyVoteExtensionProtoMsg;
+};
+export declare const RequestFinalizeBlock: {
+    typeUrl: "/tendermint.abci.RequestFinalizeBlock";
+    encode(message: RequestFinalizeBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestFinalizeBlock;
+    fromJSON(object: any): RequestFinalizeBlock;
+    toJSON(message: RequestFinalizeBlock): JsonSafe<RequestFinalizeBlock>;
+    fromPartial(object: Partial<RequestFinalizeBlock>): RequestFinalizeBlock;
+    fromProtoMsg(message: RequestFinalizeBlockProtoMsg): RequestFinalizeBlock;
+    toProto(message: RequestFinalizeBlock): Uint8Array;
+    toProtoMsg(message: RequestFinalizeBlock): RequestFinalizeBlockProtoMsg;
+};
+export declare const Response: {
+    typeUrl: "/tendermint.abci.Response";
+    encode(message: Response, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Response;
+    fromJSON(object: any): Response;
+    toJSON(message: Response): JsonSafe<Response>;
+    fromPartial(object: Partial<Response>): Response;
+    fromProtoMsg(message: ResponseProtoMsg): Response;
+    toProto(message: Response): Uint8Array;
+    toProtoMsg(message: Response): ResponseProtoMsg;
+};
+export declare const ResponseException: {
+    typeUrl: "/tendermint.abci.ResponseException";
+    encode(message: ResponseException, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseException;
+    fromJSON(object: any): ResponseException;
+    toJSON(message: ResponseException): JsonSafe<ResponseException>;
+    fromPartial(object: Partial<ResponseException>): ResponseException;
+    fromProtoMsg(message: ResponseExceptionProtoMsg): ResponseException;
+    toProto(message: ResponseException): Uint8Array;
+    toProtoMsg(message: ResponseException): ResponseExceptionProtoMsg;
+};
+export declare const ResponseEcho: {
+    typeUrl: "/tendermint.abci.ResponseEcho";
+    encode(message: ResponseEcho, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseEcho;
+    fromJSON(object: any): ResponseEcho;
+    toJSON(message: ResponseEcho): JsonSafe<ResponseEcho>;
+    fromPartial(object: Partial<ResponseEcho>): ResponseEcho;
+    fromProtoMsg(message: ResponseEchoProtoMsg): ResponseEcho;
+    toProto(message: ResponseEcho): Uint8Array;
+    toProtoMsg(message: ResponseEcho): ResponseEchoProtoMsg;
+};
+export declare const ResponseFlush: {
+    typeUrl: "/tendermint.abci.ResponseFlush";
+    encode(_: ResponseFlush, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseFlush;
+    fromJSON(_: any): ResponseFlush;
+    toJSON(_: ResponseFlush): JsonSafe<ResponseFlush>;
+    fromPartial(_: Partial<ResponseFlush>): ResponseFlush;
+    fromProtoMsg(message: ResponseFlushProtoMsg): ResponseFlush;
+    toProto(message: ResponseFlush): Uint8Array;
+    toProtoMsg(message: ResponseFlush): ResponseFlushProtoMsg;
+};
+export declare const ResponseInfo: {
+    typeUrl: "/tendermint.abci.ResponseInfo";
+    encode(message: ResponseInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseInfo;
+    fromJSON(object: any): ResponseInfo;
+    toJSON(message: ResponseInfo): JsonSafe<ResponseInfo>;
+    fromPartial(object: Partial<ResponseInfo>): ResponseInfo;
+    fromProtoMsg(message: ResponseInfoProtoMsg): ResponseInfo;
+    toProto(message: ResponseInfo): Uint8Array;
+    toProtoMsg(message: ResponseInfo): ResponseInfoProtoMsg;
+};
+export declare const ResponseInitChain: {
+    typeUrl: "/tendermint.abci.ResponseInitChain";
+    encode(message: ResponseInitChain, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseInitChain;
+    fromJSON(object: any): ResponseInitChain;
+    toJSON(message: ResponseInitChain): JsonSafe<ResponseInitChain>;
+    fromPartial(object: Partial<ResponseInitChain>): ResponseInitChain;
+    fromProtoMsg(message: ResponseInitChainProtoMsg): ResponseInitChain;
+    toProto(message: ResponseInitChain): Uint8Array;
+    toProtoMsg(message: ResponseInitChain): ResponseInitChainProtoMsg;
+};
 export declare const ResponseQuery: {
     typeUrl: "/tendermint.abci.ResponseQuery";
     encode(message: ResponseQuery, writer?: BinaryWriter): BinaryWriter;
@@ -697,17 +1197,6 @@ export declare const ResponseQuery: {
     toProto(message: ResponseQuery): Uint8Array;
     toProtoMsg(message: ResponseQuery): ResponseQueryProtoMsg;
 };
-export declare const ResponseBeginBlock: {
-    typeUrl: "/tendermint.abci.ResponseBeginBlock";
-    encode(message: ResponseBeginBlock, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): ResponseBeginBlock;
-    fromJSON(object: any): ResponseBeginBlock;
-    toJSON(message: ResponseBeginBlock): JsonSafe<ResponseBeginBlock>;
-    fromPartial(object: Partial<ResponseBeginBlock>): ResponseBeginBlock;
-    fromProtoMsg(message: ResponseBeginBlockProtoMsg): ResponseBeginBlock;
-    toProto(message: ResponseBeginBlock): Uint8Array;
-    toProtoMsg(message: ResponseBeginBlock): ResponseBeginBlockProtoMsg;
-};
 export declare const ResponseCheckTx: {
     typeUrl: "/tendermint.abci.ResponseCheckTx";
     encode(message: ResponseCheckTx, writer?: BinaryWriter): BinaryWriter;
@@ -719,28 +1208,6 @@ export declare const ResponseCheckTx: {
     toProto(message: ResponseCheckTx): Uint8Array;
     toProtoMsg(message: ResponseCheckTx): ResponseCheckTxProtoMsg;
 };
-export declare const ResponseDeliverTx: {
-    typeUrl: "/tendermint.abci.ResponseDeliverTx";
-    encode(message: ResponseDeliverTx, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): ResponseDeliverTx;
-    fromJSON(object: any): ResponseDeliverTx;
-    toJSON(message: ResponseDeliverTx): JsonSafe<ResponseDeliverTx>;
-    fromPartial(object: Partial<ResponseDeliverTx>): ResponseDeliverTx;
-    fromProtoMsg(message: ResponseDeliverTxProtoMsg): ResponseDeliverTx;
-    toProto(message: ResponseDeliverTx): Uint8Array;
-    toProtoMsg(message: ResponseDeliverTx): ResponseDeliverTxProtoMsg;
-};
-export declare const ResponseEndBlock: {
-    typeUrl: "/tendermint.abci.ResponseEndBlock";
-    encode(message: ResponseEndBlock, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): ResponseEndBlock;
-    fromJSON(object: any): ResponseEndBlock;
-    toJSON(message: ResponseEndBlock): JsonSafe<ResponseEndBlock>;
-    fromPartial(object: Partial<ResponseEndBlock>): ResponseEndBlock;
-    fromProtoMsg(message: ResponseEndBlockProtoMsg): ResponseEndBlock;
-    toProto(message: ResponseEndBlock): Uint8Array;
-    toProtoMsg(message: ResponseEndBlock): ResponseEndBlockProtoMsg;
-};
 export declare const ResponseCommit: {
     typeUrl: "/tendermint.abci.ResponseCommit";
     encode(message: ResponseCommit, writer?: BinaryWriter): BinaryWriter;
@@ -752,16 +1219,126 @@ export declare const ResponseCommit: {
     toProto(message: ResponseCommit): Uint8Array;
     toProtoMsg(message: ResponseCommit): ResponseCommitProtoMsg;
 };
-export declare const LastCommitInfo: {
-    typeUrl: "/tendermint.abci.LastCommitInfo";
-    encode(message: LastCommitInfo, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): LastCommitInfo;
-    fromJSON(object: any): LastCommitInfo;
-    toJSON(message: LastCommitInfo): JsonSafe<LastCommitInfo>;
-    fromPartial(object: Partial<LastCommitInfo>): LastCommitInfo;
-    fromProtoMsg(message: LastCommitInfoProtoMsg): LastCommitInfo;
-    toProto(message: LastCommitInfo): Uint8Array;
-    toProtoMsg(message: LastCommitInfo): LastCommitInfoProtoMsg;
+export declare const ResponseListSnapshots: {
+    typeUrl: "/tendermint.abci.ResponseListSnapshots";
+    encode(message: ResponseListSnapshots, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseListSnapshots;
+    fromJSON(object: any): ResponseListSnapshots;
+    toJSON(message: ResponseListSnapshots): JsonSafe<ResponseListSnapshots>;
+    fromPartial(object: Partial<ResponseListSnapshots>): ResponseListSnapshots;
+    fromProtoMsg(message: ResponseListSnapshotsProtoMsg): ResponseListSnapshots;
+    toProto(message: ResponseListSnapshots): Uint8Array;
+    toProtoMsg(message: ResponseListSnapshots): ResponseListSnapshotsProtoMsg;
+};
+export declare const ResponseOfferSnapshot: {
+    typeUrl: "/tendermint.abci.ResponseOfferSnapshot";
+    encode(message: ResponseOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseOfferSnapshot;
+    fromJSON(object: any): ResponseOfferSnapshot;
+    toJSON(message: ResponseOfferSnapshot): JsonSafe<ResponseOfferSnapshot>;
+    fromPartial(object: Partial<ResponseOfferSnapshot>): ResponseOfferSnapshot;
+    fromProtoMsg(message: ResponseOfferSnapshotProtoMsg): ResponseOfferSnapshot;
+    toProto(message: ResponseOfferSnapshot): Uint8Array;
+    toProtoMsg(message: ResponseOfferSnapshot): ResponseOfferSnapshotProtoMsg;
+};
+export declare const ResponseLoadSnapshotChunk: {
+    typeUrl: "/tendermint.abci.ResponseLoadSnapshotChunk";
+    encode(message: ResponseLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseLoadSnapshotChunk;
+    fromJSON(object: any): ResponseLoadSnapshotChunk;
+    toJSON(message: ResponseLoadSnapshotChunk): JsonSafe<ResponseLoadSnapshotChunk>;
+    fromPartial(object: Partial<ResponseLoadSnapshotChunk>): ResponseLoadSnapshotChunk;
+    fromProtoMsg(message: ResponseLoadSnapshotChunkProtoMsg): ResponseLoadSnapshotChunk;
+    toProto(message: ResponseLoadSnapshotChunk): Uint8Array;
+    toProtoMsg(message: ResponseLoadSnapshotChunk): ResponseLoadSnapshotChunkProtoMsg;
+};
+export declare const ResponseApplySnapshotChunk: {
+    typeUrl: "/tendermint.abci.ResponseApplySnapshotChunk";
+    encode(message: ResponseApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseApplySnapshotChunk;
+    fromJSON(object: any): ResponseApplySnapshotChunk;
+    toJSON(message: ResponseApplySnapshotChunk): JsonSafe<ResponseApplySnapshotChunk>;
+    fromPartial(object: Partial<ResponseApplySnapshotChunk>): ResponseApplySnapshotChunk;
+    fromProtoMsg(message: ResponseApplySnapshotChunkProtoMsg): ResponseApplySnapshotChunk;
+    toProto(message: ResponseApplySnapshotChunk): Uint8Array;
+    toProtoMsg(message: ResponseApplySnapshotChunk): ResponseApplySnapshotChunkProtoMsg;
+};
+export declare const ResponsePrepareProposal: {
+    typeUrl: "/tendermint.abci.ResponsePrepareProposal";
+    encode(message: ResponsePrepareProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponsePrepareProposal;
+    fromJSON(object: any): ResponsePrepareProposal;
+    toJSON(message: ResponsePrepareProposal): JsonSafe<ResponsePrepareProposal>;
+    fromPartial(object: Partial<ResponsePrepareProposal>): ResponsePrepareProposal;
+    fromProtoMsg(message: ResponsePrepareProposalProtoMsg): ResponsePrepareProposal;
+    toProto(message: ResponsePrepareProposal): Uint8Array;
+    toProtoMsg(message: ResponsePrepareProposal): ResponsePrepareProposalProtoMsg;
+};
+export declare const ResponseProcessProposal: {
+    typeUrl: "/tendermint.abci.ResponseProcessProposal";
+    encode(message: ResponseProcessProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseProcessProposal;
+    fromJSON(object: any): ResponseProcessProposal;
+    toJSON(message: ResponseProcessProposal): JsonSafe<ResponseProcessProposal>;
+    fromPartial(object: Partial<ResponseProcessProposal>): ResponseProcessProposal;
+    fromProtoMsg(message: ResponseProcessProposalProtoMsg): ResponseProcessProposal;
+    toProto(message: ResponseProcessProposal): Uint8Array;
+    toProtoMsg(message: ResponseProcessProposal): ResponseProcessProposalProtoMsg;
+};
+export declare const ResponseExtendVote: {
+    typeUrl: "/tendermint.abci.ResponseExtendVote";
+    encode(message: ResponseExtendVote, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseExtendVote;
+    fromJSON(object: any): ResponseExtendVote;
+    toJSON(message: ResponseExtendVote): JsonSafe<ResponseExtendVote>;
+    fromPartial(object: Partial<ResponseExtendVote>): ResponseExtendVote;
+    fromProtoMsg(message: ResponseExtendVoteProtoMsg): ResponseExtendVote;
+    toProto(message: ResponseExtendVote): Uint8Array;
+    toProtoMsg(message: ResponseExtendVote): ResponseExtendVoteProtoMsg;
+};
+export declare const ResponseVerifyVoteExtension: {
+    typeUrl: "/tendermint.abci.ResponseVerifyVoteExtension";
+    encode(message: ResponseVerifyVoteExtension, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseVerifyVoteExtension;
+    fromJSON(object: any): ResponseVerifyVoteExtension;
+    toJSON(message: ResponseVerifyVoteExtension): JsonSafe<ResponseVerifyVoteExtension>;
+    fromPartial(object: Partial<ResponseVerifyVoteExtension>): ResponseVerifyVoteExtension;
+    fromProtoMsg(message: ResponseVerifyVoteExtensionProtoMsg): ResponseVerifyVoteExtension;
+    toProto(message: ResponseVerifyVoteExtension): Uint8Array;
+    toProtoMsg(message: ResponseVerifyVoteExtension): ResponseVerifyVoteExtensionProtoMsg;
+};
+export declare const ResponseFinalizeBlock: {
+    typeUrl: "/tendermint.abci.ResponseFinalizeBlock";
+    encode(message: ResponseFinalizeBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseFinalizeBlock;
+    fromJSON(object: any): ResponseFinalizeBlock;
+    toJSON(message: ResponseFinalizeBlock): JsonSafe<ResponseFinalizeBlock>;
+    fromPartial(object: Partial<ResponseFinalizeBlock>): ResponseFinalizeBlock;
+    fromProtoMsg(message: ResponseFinalizeBlockProtoMsg): ResponseFinalizeBlock;
+    toProto(message: ResponseFinalizeBlock): Uint8Array;
+    toProtoMsg(message: ResponseFinalizeBlock): ResponseFinalizeBlockProtoMsg;
+};
+export declare const CommitInfo: {
+    typeUrl: "/tendermint.abci.CommitInfo";
+    encode(message: CommitInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CommitInfo;
+    fromJSON(object: any): CommitInfo;
+    toJSON(message: CommitInfo): JsonSafe<CommitInfo>;
+    fromPartial(object: Partial<CommitInfo>): CommitInfo;
+    fromProtoMsg(message: CommitInfoProtoMsg): CommitInfo;
+    toProto(message: CommitInfo): Uint8Array;
+    toProtoMsg(message: CommitInfo): CommitInfoProtoMsg;
+};
+export declare const ExtendedCommitInfo: {
+    typeUrl: "/tendermint.abci.ExtendedCommitInfo";
+    encode(message: ExtendedCommitInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ExtendedCommitInfo;
+    fromJSON(object: any): ExtendedCommitInfo;
+    toJSON(message: ExtendedCommitInfo): JsonSafe<ExtendedCommitInfo>;
+    fromPartial(object: Partial<ExtendedCommitInfo>): ExtendedCommitInfo;
+    fromProtoMsg(message: ExtendedCommitInfoProtoMsg): ExtendedCommitInfo;
+    toProto(message: ExtendedCommitInfo): Uint8Array;
+    toProtoMsg(message: ExtendedCommitInfo): ExtendedCommitInfoProtoMsg;
 };
 export declare const Event: {
     typeUrl: "/tendermint.abci.Event";
@@ -785,6 +1362,17 @@ export declare const EventAttribute: {
     toProto(message: EventAttribute): Uint8Array;
     toProtoMsg(message: EventAttribute): EventAttributeProtoMsg;
 };
+export declare const ExecTxResult: {
+    typeUrl: "/tendermint.abci.ExecTxResult";
+    encode(message: ExecTxResult, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ExecTxResult;
+    fromJSON(object: any): ExecTxResult;
+    toJSON(message: ExecTxResult): JsonSafe<ExecTxResult>;
+    fromPartial(object: Partial<ExecTxResult>): ExecTxResult;
+    fromProtoMsg(message: ExecTxResultProtoMsg): ExecTxResult;
+    toProto(message: ExecTxResult): Uint8Array;
+    toProtoMsg(message: ExecTxResult): ExecTxResultProtoMsg;
+};
 export declare const TxResult: {
     typeUrl: "/tendermint.abci.TxResult";
     encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
@@ -829,15 +1417,37 @@ export declare const VoteInfo: {
     toProto(message: VoteInfo): Uint8Array;
     toProtoMsg(message: VoteInfo): VoteInfoProtoMsg;
 };
-export declare const Evidence: {
-    typeUrl: "/tendermint.abci.Evidence";
-    encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): Evidence;
-    fromJSON(object: any): Evidence;
-    toJSON(message: Evidence): JsonSafe<Evidence>;
-    fromPartial(object: Partial<Evidence>): Evidence;
-    fromProtoMsg(message: EvidenceProtoMsg): Evidence;
-    toProto(message: Evidence): Uint8Array;
-    toProtoMsg(message: Evidence): EvidenceProtoMsg;
+export declare const ExtendedVoteInfo: {
+    typeUrl: "/tendermint.abci.ExtendedVoteInfo";
+    encode(message: ExtendedVoteInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ExtendedVoteInfo;
+    fromJSON(object: any): ExtendedVoteInfo;
+    toJSON(message: ExtendedVoteInfo): JsonSafe<ExtendedVoteInfo>;
+    fromPartial(object: Partial<ExtendedVoteInfo>): ExtendedVoteInfo;
+    fromProtoMsg(message: ExtendedVoteInfoProtoMsg): ExtendedVoteInfo;
+    toProto(message: ExtendedVoteInfo): Uint8Array;
+    toProtoMsg(message: ExtendedVoteInfo): ExtendedVoteInfoProtoMsg;
+};
+export declare const Misbehavior: {
+    typeUrl: "/tendermint.abci.Misbehavior";
+    encode(message: Misbehavior, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Misbehavior;
+    fromJSON(object: any): Misbehavior;
+    toJSON(message: Misbehavior): JsonSafe<Misbehavior>;
+    fromPartial(object: Partial<Misbehavior>): Misbehavior;
+    fromProtoMsg(message: MisbehaviorProtoMsg): Misbehavior;
+    toProto(message: Misbehavior): Uint8Array;
+    toProtoMsg(message: Misbehavior): MisbehaviorProtoMsg;
+};
+export declare const Snapshot: {
+    typeUrl: "/tendermint.abci.Snapshot";
+    encode(message: Snapshot, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Snapshot;
+    fromJSON(object: any): Snapshot;
+    toJSON(message: Snapshot): JsonSafe<Snapshot>;
+    fromPartial(object: Partial<Snapshot>): Snapshot;
+    fromProtoMsg(message: SnapshotProtoMsg): Snapshot;
+    toProto(message: Snapshot): Uint8Array;
+    toProtoMsg(message: Snapshot): SnapshotProtoMsg;
 };
 //# sourceMappingURL=types.d.ts.map