@ark-us/wasmxjs 0.0.9 → 0.0.11

package/src/codegen/tendermint/abci/types.ts

@@ -1,8 +1,8 @@
 import { Timestamp, TimestampSDKType } from "../../google/protobuf/timestamp";
-import { Header, HeaderSDKType } from "../types/types";
+import { ConsensusParams, ConsensusParamsSDKType } from "../types/params";
 import { ProofOps, ProofOpsSDKType } from "../crypto/proof";
-import { EvidenceParams, EvidenceParamsSDKType, ValidatorParams, ValidatorParamsSDKType, VersionParams, VersionParamsSDKType } from "../types/params";
 import { PublicKey, PublicKeySDKType } from "../crypto/keys";
+import { BlockIDFlag, BlockIDFlagSDKType, blockIDFlagFromJSON, blockIDFlagToJSON } from "../types/validator";
 import * as _m0 from "protobufjs/minimal";
 import { isSet, Long, fromJsonTimestamp, bytesFromBase64, fromTimestamp, base64FromBytes } from "../../helpers";
 export enum CheckTxType {
@@ -238,50 +238,160 @@ export function responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySna
       return "UNRECOGNIZED";
   }
 }
-export enum EvidenceType {
+export enum ResponseProcessProposal_ProposalStatus {
+  UNKNOWN = 0,
+  ACCEPT = 1,
+  REJECT = 2,
+  UNRECOGNIZED = -1,
+}
+export enum ResponseProcessProposal_ProposalStatusSDKType {
+  UNKNOWN = 0,
+  ACCEPT = 1,
+  REJECT = 2,
+  UNRECOGNIZED = -1,
+}
+export function responseProcessProposal_ProposalStatusFromJSON(object: any): ResponseProcessProposal_ProposalStatus {
+  switch (object) {
+    case 0:
+    case "UNKNOWN":
+      return ResponseProcessProposal_ProposalStatus.UNKNOWN;
+
+    case 1:
+    case "ACCEPT":
+      return ResponseProcessProposal_ProposalStatus.ACCEPT;
+
+    case 2:
+    case "REJECT":
+      return ResponseProcessProposal_ProposalStatus.REJECT;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ResponseProcessProposal_ProposalStatus.UNRECOGNIZED;
+  }
+}
+export function responseProcessProposal_ProposalStatusToJSON(object: ResponseProcessProposal_ProposalStatus): string {
+  switch (object) {
+    case ResponseProcessProposal_ProposalStatus.UNKNOWN:
+      return "UNKNOWN";
+
+    case ResponseProcessProposal_ProposalStatus.ACCEPT:
+      return "ACCEPT";
+
+    case ResponseProcessProposal_ProposalStatus.REJECT:
+      return "REJECT";
+
+    case ResponseProcessProposal_ProposalStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+export 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 enum ResponseVerifyVoteExtension_VerifyStatusSDKType {
+  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 function responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): ResponseVerifyVoteExtension_VerifyStatus {
+  switch (object) {
+    case 0:
+    case "UNKNOWN":
+      return ResponseVerifyVoteExtension_VerifyStatus.UNKNOWN;
+
+    case 1:
+    case "ACCEPT":
+      return ResponseVerifyVoteExtension_VerifyStatus.ACCEPT;
+
+    case 2:
+    case "REJECT":
+      return ResponseVerifyVoteExtension_VerifyStatus.REJECT;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ResponseVerifyVoteExtension_VerifyStatus.UNRECOGNIZED;
+  }
+}
+export function responseVerifyVoteExtension_VerifyStatusToJSON(object: ResponseVerifyVoteExtension_VerifyStatus): string {
+  switch (object) {
+    case ResponseVerifyVoteExtension_VerifyStatus.UNKNOWN:
+      return "UNKNOWN";
+
+    case ResponseVerifyVoteExtension_VerifyStatus.ACCEPT:
+      return "ACCEPT";
+
+    case ResponseVerifyVoteExtension_VerifyStatus.REJECT:
+      return "REJECT";
+
+    case ResponseVerifyVoteExtension_VerifyStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+export enum MisbehaviorType {
   UNKNOWN = 0,
   DUPLICATE_VOTE = 1,
   LIGHT_CLIENT_ATTACK = 2,
   UNRECOGNIZED = -1,
 }
-export enum EvidenceTypeSDKType {
+export enum MisbehaviorTypeSDKType {
   UNKNOWN = 0,
   DUPLICATE_VOTE = 1,
   LIGHT_CLIENT_ATTACK = 2,
   UNRECOGNIZED = -1,
 }
-export function evidenceTypeFromJSON(object: any): EvidenceType {
+export function misbehaviorTypeFromJSON(object: any): MisbehaviorType {
   switch (object) {
     case 0:
     case "UNKNOWN":
-      return EvidenceType.UNKNOWN;
+      return MisbehaviorType.UNKNOWN;
 
     case 1:
     case "DUPLICATE_VOTE":
-      return EvidenceType.DUPLICATE_VOTE;
+      return MisbehaviorType.DUPLICATE_VOTE;
 
     case 2:
     case "LIGHT_CLIENT_ATTACK":
-      return EvidenceType.LIGHT_CLIENT_ATTACK;
+      return MisbehaviorType.LIGHT_CLIENT_ATTACK;
 
     case -1:
     case "UNRECOGNIZED":
     default:
-      return EvidenceType.UNRECOGNIZED;
+      return MisbehaviorType.UNRECOGNIZED;
   }
 }
-export function evidenceTypeToJSON(object: EvidenceType): string {
+export function misbehaviorTypeToJSON(object: MisbehaviorType): string {
   switch (object) {
-    case EvidenceType.UNKNOWN:
+    case MisbehaviorType.UNKNOWN:
       return "UNKNOWN";
 
-    case EvidenceType.DUPLICATE_VOTE:
+    case MisbehaviorType.DUPLICATE_VOTE:
       return "DUPLICATE_VOTE";
 
-    case EvidenceType.LIGHT_CLIENT_ATTACK:
+    case MisbehaviorType.LIGHT_CLIENT_ATTACK:
       return "LIGHT_CLIENT_ATTACK";
 
-    case EvidenceType.UNRECOGNIZED:
+    case MisbehaviorType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
@@ -290,35 +400,37 @@ export interface Request {
   echo?: RequestEcho;
   flush?: RequestFlush;
   info?: RequestInfo;
-  setOption?: RequestSetOption;
   initChain?: RequestInitChain;
   query?: RequestQuery;
-  beginBlock?: RequestBeginBlock;
   checkTx?: RequestCheckTx;
-  deliverTx?: RequestDeliverTx;
-  endBlock?: RequestEndBlock;
   commit?: RequestCommit;
   listSnapshots?: RequestListSnapshots;
   offerSnapshot?: RequestOfferSnapshot;
   loadSnapshotChunk?: RequestLoadSnapshotChunk;
   applySnapshotChunk?: RequestApplySnapshotChunk;
+  prepareProposal?: RequestPrepareProposal;
+  processProposal?: RequestProcessProposal;
+  extendVote?: RequestExtendVote;
+  verifyVoteExtension?: RequestVerifyVoteExtension;
+  finalizeBlock?: RequestFinalizeBlock;
 }
 export interface RequestSDKType {
   echo?: RequestEchoSDKType;
   flush?: RequestFlushSDKType;
   info?: RequestInfoSDKType;
-  set_option?: RequestSetOptionSDKType;
   init_chain?: RequestInitChainSDKType;
   query?: RequestQuerySDKType;
-  begin_block?: RequestBeginBlockSDKType;
   check_tx?: RequestCheckTxSDKType;
-  deliver_tx?: RequestDeliverTxSDKType;
-  end_block?: RequestEndBlockSDKType;
   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;
@@ -332,23 +444,13 @@ export interface RequestInfo {
   version: string;
   blockVersion: Long;
   p2pVersion: Long;
+  abciVersion: string;
 }
 export interface RequestInfoSDKType {
   version: string;
   block_version: Long;
   p2p_version: Long;
-}
-/** nondeterministic */
-
-export interface RequestSetOption {
-  key: string;
-  value: string;
-}
-/** nondeterministic */
-
-export interface RequestSetOptionSDKType {
-  key: string;
-  value: string;
+  abci_version: string;
 }
 export interface RequestInitChain {
   time?: Timestamp;
@@ -378,18 +480,6 @@ export interface RequestQuerySDKType {
   height: Long;
   prove: boolean;
 }
-export interface RequestBeginBlock {
-  hash: Uint8Array;
-  header?: Header;
-  lastCommitInfo?: LastCommitInfo;
-  byzantineValidators: Evidence[];
-}
-export interface RequestBeginBlockSDKType {
-  hash: Uint8Array;
-  header?: HeaderSDKType;
-  last_commit_info?: LastCommitInfoSDKType;
-  byzantine_validators: EvidenceSDKType[];
-}
 export interface RequestCheckTx {
   tx: Uint8Array;
   type: CheckTxType;
@@ -398,18 +488,6 @@ export interface RequestCheckTxSDKType {
   tx: Uint8Array;
   type: CheckTxTypeSDKType;
 }
-export interface RequestDeliverTx {
-  tx: Uint8Array;
-}
-export interface RequestDeliverTxSDKType {
-  tx: Uint8Array;
-}
-export interface RequestEndBlock {
-  height: Long;
-}
-export interface RequestEndBlockSDKType {
-  height: Long;
-}
 export interface RequestCommit {}
 export interface RequestCommitSDKType {}
 /** lists available snapshots */
@@ -464,52 +542,204 @@ export interface RequestApplySnapshotChunkSDKType {
   chunk: Uint8Array;
   sender: string;
 }
+export interface RequestPrepareProposal {
+  /** the modified transactions cannot exceed this size. */
+  maxTxBytes: Long;
+  /**
+   * 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: Long;
+  time?: Timestamp;
+  nextValidatorsHash: Uint8Array;
+  /** address of the public key of the validator proposing the block. */
+
+  proposerAddress: Uint8Array;
+}
+export interface RequestPrepareProposalSDKType {
+  /** the modified transactions cannot exceed this size. */
+  max_tx_bytes: Long;
+  /**
+   * txs is an array of transactions that will be included in a block,
+   * sent to the app for possible modifications.
+   */
+
+  txs: Uint8Array[];
+  local_last_commit?: ExtendedCommitInfoSDKType;
+  misbehavior: MisbehaviorSDKType[];
+  height: Long;
+  time?: TimestampSDKType;
+  next_validators_hash: Uint8Array;
+  /** address of the public key of the validator proposing the block. */
+
+  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: Long;
+  time?: Timestamp;
+  nextValidatorsHash: Uint8Array;
+  /** address of the public key of the original proposer of the block. */
+
+  proposerAddress: Uint8Array;
+}
+export interface RequestProcessProposalSDKType {
+  txs: Uint8Array[];
+  proposed_last_commit?: CommitInfoSDKType;
+  misbehavior: MisbehaviorSDKType[];
+  /** hash is the merkle root hash of the fields of the proposed block. */
+
+  hash: Uint8Array;
+  height: Long;
+  time?: TimestampSDKType;
+  next_validators_hash: Uint8Array;
+  /** address of the public key of the original proposer of the block. */
+
+  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: Long;
+  /** 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;
+}
+/** Extends a vote with application-injected data */
+
+export interface RequestExtendVoteSDKType {
+  /** the hash of the block that this vote may be referring to */
+  hash: Uint8Array;
+  /** the height of the extended vote */
+
+  height: Long;
+  /** info of the block that this vote may be referring to */
+
+  time?: TimestampSDKType;
+  txs: Uint8Array[];
+  proposed_last_commit?: CommitInfoSDKType;
+  misbehavior: MisbehaviorSDKType[];
+  next_validators_hash: Uint8Array;
+  /** address of the public key of the original proposer of the block. */
+
+  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: Long;
+  voteExtension: Uint8Array;
+}
+/** Verify the vote extension */
+
+export interface RequestVerifyVoteExtensionSDKType {
+  /** the hash of the block that this received vote corresponds to */
+  hash: Uint8Array;
+  /** the validator that signed the vote extension */
+
+  validator_address: Uint8Array;
+  height: Long;
+  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: Long;
+  time?: Timestamp;
+  nextValidatorsHash: Uint8Array;
+  /** proposer_address is the address of the public key of the original proposer of the block. */
+
+  proposerAddress: Uint8Array;
+}
+export interface RequestFinalizeBlockSDKType {
+  txs: Uint8Array[];
+  decided_last_commit?: CommitInfoSDKType;
+  misbehavior: MisbehaviorSDKType[];
+  /** hash is the merkle root hash of the fields of the decided block. */
+
+  hash: Uint8Array;
+  height: Long;
+  time?: TimestampSDKType;
+  next_validators_hash: Uint8Array;
+  /** proposer_address is the address of the public key of the original proposer of the block. */
+
+  proposer_address: Uint8Array;
+}
 export interface Response {
   exception?: ResponseException;
   echo?: ResponseEcho;
   flush?: ResponseFlush;
   info?: ResponseInfo;
-  setOption?: ResponseSetOption;
   initChain?: ResponseInitChain;
   query?: ResponseQuery;
-  beginBlock?: ResponseBeginBlock;
   checkTx?: ResponseCheckTx;
-  deliverTx?: ResponseDeliverTx;
-  endBlock?: ResponseEndBlock;
   commit?: ResponseCommit;
   listSnapshots?: ResponseListSnapshots;
   offerSnapshot?: ResponseOfferSnapshot;
   loadSnapshotChunk?: ResponseLoadSnapshotChunk;
   applySnapshotChunk?: ResponseApplySnapshotChunk;
+  prepareProposal?: ResponsePrepareProposal;
+  processProposal?: ResponseProcessProposal;
+  extendVote?: ResponseExtendVote;
+  verifyVoteExtension?: ResponseVerifyVoteExtension;
+  finalizeBlock?: ResponseFinalizeBlock;
 }
 export interface ResponseSDKType {
   exception?: ResponseExceptionSDKType;
   echo?: ResponseEchoSDKType;
   flush?: ResponseFlushSDKType;
   info?: ResponseInfoSDKType;
-  set_option?: ResponseSetOptionSDKType;
   init_chain?: ResponseInitChainSDKType;
   query?: ResponseQuerySDKType;
-  begin_block?: ResponseBeginBlockSDKType;
   check_tx?: ResponseCheckTxSDKType;
-  deliver_tx?: ResponseDeliverTxSDKType;
-  end_block?: ResponseEndBlockSDKType;
   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 {
-  /** nondeterministic */
   error: string;
 }
 /** nondeterministic */
 
 export interface ResponseExceptionSDKType {
-  /** nondeterministic */
   error: string;
 }
 export interface ResponseEcho {
@@ -534,24 +764,6 @@ export interface ResponseInfoSDKType {
   last_block_height: Long;
   last_block_app_hash: Uint8Array;
 }
-/** nondeterministic */
-
-export interface ResponseSetOption {
-  code: number;
-  /** bytes data = 2; */
-
-  log: string;
-  info: string;
-}
-/** nondeterministic */
-
-export interface ResponseSetOptionSDKType {
-  code: number;
-  /** bytes data = 2; */
-
-  log: string;
-  info: string;
-}
 export interface ResponseInitChain {
   consensusParams?: ConsensusParams;
   validators: ValidatorUpdate[];
@@ -592,12 +804,6 @@ export interface ResponseQuerySDKType {
   height: Long;
   codespace: string;
 }
-export interface ResponseBeginBlock {
-  events: Event[];
-}
-export interface ResponseBeginBlockSDKType {
-  events: EventSDKType[];
-}
 export interface ResponseCheckTx {
   code: number;
   data: Uint8Array;
@@ -626,52 +832,10 @@ export interface ResponseCheckTxSDKType {
   events: EventSDKType[];
   codespace: string;
 }
-export interface ResponseDeliverTx {
-  code: number;
-  data: Uint8Array;
-  /** nondeterministic */
-
-  log: string;
-  /** nondeterministic */
-
-  info: string;
-  gasWanted: Long;
-  gasUsed: Long;
-  events: Event[];
-  codespace: string;
-}
-export interface ResponseDeliverTxSDKType {
-  code: number;
-  data: Uint8Array;
-  /** nondeterministic */
-
-  log: string;
-  /** nondeterministic */
-
-  info: string;
-  gas_wanted: Long;
-  gas_used: Long;
-  events: EventSDKType[];
-  codespace: string;
-}
-export interface ResponseEndBlock {
-  validatorUpdates: ValidatorUpdate[];
-  consensusParamUpdates?: ConsensusParams;
-  events: Event[];
-}
-export interface ResponseEndBlockSDKType {
-  validator_updates: ValidatorUpdateSDKType[];
-  consensus_param_updates?: ConsensusParamsSDKType;
-  events: EventSDKType[];
-}
 export interface ResponseCommit {
-  /** reserve 1 */
-  data: Uint8Array;
   retainHeight: Long;
 }
 export interface ResponseCommitSDKType {
-  /** reserve 1 */
-  data: Uint8Array;
   retain_height: Long;
 }
 export interface ResponseListSnapshots {
@@ -710,67 +874,129 @@ export interface ResponseApplySnapshotChunkSDKType {
 
   reject_senders: string[];
 }
-/**
- * ConsensusParams contains all consensus-relevant parameters
- * that can be adjusted by the abci app
- */
-
-export interface ConsensusParams {
-  block?: BlockParams;
-  evidence?: EvidenceParams;
-  validator?: ValidatorParams;
-  version?: VersionParams;
+export interface ResponsePrepareProposal {
+  txs: Uint8Array[];
 }
-/**
- * ConsensusParams contains all consensus-relevant parameters
- * that can be adjusted by the abci app
- */
-
-export interface ConsensusParamsSDKType {
-  block?: BlockParamsSDKType;
-  evidence?: EvidenceParamsSDKType;
-  validator?: ValidatorParamsSDKType;
-  version?: VersionParamsSDKType;
+export interface ResponsePrepareProposalSDKType {
+  txs: Uint8Array[];
+}
+export interface ResponseProcessProposal {
+  status: ResponseProcessProposal_ProposalStatus;
+}
+export interface ResponseProcessProposalSDKType {
+  status: ResponseProcessProposal_ProposalStatusSDKType;
 }
-/** BlockParams contains limits on the block size. */
+export interface ResponseExtendVote {
+  voteExtension: Uint8Array;
+}
+export interface ResponseExtendVoteSDKType {
+  vote_extension: Uint8Array;
+}
+export interface ResponseVerifyVoteExtension {
+  status: ResponseVerifyVoteExtension_VerifyStatus;
+}
+export interface ResponseVerifyVoteExtensionSDKType {
+  status: ResponseVerifyVoteExtension_VerifyStatusSDKType;
+}
+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. */
 
-export interface BlockParams {
-  /** Note: must be greater than 0 */
-  maxBytes: Long;
-  /** Note: must be greater or equal to -1 */
+  validatorUpdates: ValidatorUpdate[];
+  /** updates to the consensus params, if any. */
+
+  consensusParamUpdates?: ConsensusParams;
+  /**
+   * 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.
+   */
 
-  maxGas: Long;
+  appHash: Uint8Array;
 }
-/** BlockParams contains limits on the block size. */
+export interface ResponseFinalizeBlockSDKType {
+  /** set of block events emmitted as part of executing the block */
+  events: EventSDKType[];
+  /**
+   * 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
+   */
+
+  tx_results: ExecTxResultSDKType[];
+  /** a list of updates to the validator set. These will reflect the validator set at current height + 2. */
+
+  validator_updates: ValidatorUpdateSDKType[];
+  /** updates to the consensus params, if any. */
 
-export interface BlockParamsSDKType {
-  /** Note: must be greater than 0 */
-  max_bytes: Long;
-  /** Note: must be greater or equal to -1 */
+  consensus_param_updates?: ConsensusParamsSDKType;
+  /**
+   * 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.
+   */
 
-  max_gas: Long;
+  app_hash: Uint8Array;
 }
-export interface LastCommitInfo {
+export interface CommitInfo {
   round: number;
   votes: VoteInfo[];
 }
-export interface LastCommitInfoSDKType {
+export interface CommitInfoSDKType {
   round: number;
   votes: VoteInfoSDKType[];
 }
 /**
- * Event allows application developers to attach additional information to
- * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
- * Later, transactions may be queried using these events.
+ * 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 Event {
-  type: string;
-  attributes: EventAttribute[];
-}
-/**
- * Event allows application developers to attach additional information to
- * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
+export interface ExtendedCommitInfo {
+  /** The round at which the block proposer decided in the previous height. */
+  round: number;
+  /**
+   * List of validators' addresses in the last validator set with their voting
+   * information, including vote extensions.
+   */
+
+  votes: ExtendedVoteInfo[];
+}
+/**
+ * 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 {
+  /** The round at which the block proposer decided in the previous height. */
+  round: number;
+  /**
+   * List of validators' addresses in the last validator set with their voting
+   * information, including vote extensions.
+   */
+
+  votes: ExtendedVoteInfoSDKType[];
+}
+/**
+ * Event allows application developers to attach additional information to
+ * ResponseFinalizeBlock and ResponseCheckTx.
+ * Later, transactions may be queried using these events.
+ */
+
+export interface Event {
+  type: string;
+  attributes: EventAttribute[];
+}
+/**
+ * Event allows application developers to attach additional information to
+ * ResponseFinalizeBlock and ResponseCheckTx.
  * Later, transactions may be queried using these events.
  */
 
@@ -781,8 +1007,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;
@@ -790,12 +1016,52 @@ export interface EventAttribute {
 /** EventAttribute is a single key-value pair, associated with an event. */
 
 export interface EventAttributeSDKType {
-  key: Uint8Array;
-  value: Uint8Array;
+  key: string;
+  value: string;
   /** nondeterministic */
 
   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: Long;
+  gasUsed: Long;
+  events: Event[];
+  codespace: string;
+}
+/**
+ * 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;
+  /** nondeterministic */
+
+  log: string;
+  /** nondeterministic */
+
+  info: string;
+  gas_wanted: Long;
+  gas_used: Long;
+  events: EventSDKType[];
+  codespace: string;
+}
 /**
  * TxResult contains results of executing the transaction.
  * 
@@ -806,7 +1072,7 @@ export interface TxResult {
   height: Long;
   index: number;
   tx: Uint8Array;
-  result?: ResponseDeliverTx;
+  result?: ExecTxResult;
 }
 /**
  * TxResult contains results of executing the transaction.
@@ -818,10 +1084,8 @@ export interface TxResultSDKType {
   height: Long;
   index: number;
   tx: Uint8Array;
-  result?: ResponseDeliverTxSDKType;
+  result?: ExecTxResultSDKType;
 }
-/** Validator */
-
 export interface Validator {
   /**
    * The first 20 bytes of SHA256(public key)
@@ -832,8 +1096,6 @@ export interface Validator {
 
   power: Long;
 }
-/** Validator */
-
 export interface ValidatorSDKType {
   /**
    * The first 20 bytes of SHA256(public key)
@@ -844,32 +1106,50 @@ export interface ValidatorSDKType {
 
   power: Long;
 }
-/** ValidatorUpdate */
-
 export interface ValidatorUpdate {
   pubKey?: PublicKey;
   power: Long;
 }
-/** ValidatorUpdate */
-
 export interface ValidatorUpdateSDKType {
   pub_key?: PublicKeySDKType;
   power: Long;
 }
-/** VoteInfo */
-
 export interface VoteInfo {
   validator?: Validator;
-  signedLastBlock: boolean;
+  blockIdFlag: BlockIDFlag;
 }
-/** VoteInfo */
-
 export interface VoteInfoSDKType {
   validator?: ValidatorSDKType;
-  signed_last_block: boolean;
+  block_id_flag: BlockIDFlagSDKType;
+}
+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 ExtendedVoteInfoSDKType {
+  /** The validator that sent the vote. */
+  validator?: ValidatorSDKType;
+  /** Non-deterministic extension provided by the sending validator's application. */
+
+  vote_extension: Uint8Array;
+  /** Vote extension signature created by CometBFT */
+
+  extension_signature: Uint8Array;
+  /** block_id_flag indicates whether the validator voted for a block, nil, or did not vote at all */
+
+  block_id_flag: BlockIDFlagSDKType;
 }
-export interface Evidence {
-  type: EvidenceType;
+export interface Misbehavior {
+  type: MisbehaviorType;
   /** The offending validator */
 
   validator?: Validator;
@@ -887,8 +1167,8 @@ export interface Evidence {
 
   totalVotingPower: Long;
 }
-export interface EvidenceSDKType {
-  type: EvidenceTypeSDKType;
+export interface MisbehaviorSDKType {
+  type: MisbehaviorTypeSDKType;
   /** The offending validator */
 
   validator?: ValidatorSDKType;
@@ -944,18 +1224,19 @@ function createBaseRequest(): Request {
     echo: undefined,
     flush: undefined,
     info: undefined,
-    setOption: undefined,
     initChain: undefined,
     query: undefined,
-    beginBlock: undefined,
     checkTx: undefined,
-    deliverTx: undefined,
-    endBlock: undefined,
     commit: undefined,
     listSnapshots: undefined,
     offerSnapshot: undefined,
     loadSnapshotChunk: undefined,
-    applySnapshotChunk: undefined
+    applySnapshotChunk: undefined,
+    prepareProposal: undefined,
+    processProposal: undefined,
+    extendVote: undefined,
+    verifyVoteExtension: undefined,
+    finalizeBlock: undefined
   };
 }
 
@@ -973,10 +1254,6 @@ export const Request = {
       RequestInfo.encode(message.info, writer.uint32(26).fork()).ldelim();
     }
 
-    if (message.setOption !== undefined) {
-      RequestSetOption.encode(message.setOption, writer.uint32(34).fork()).ldelim();
-    }
-
     if (message.initChain !== undefined) {
       RequestInitChain.encode(message.initChain, writer.uint32(42).fork()).ldelim();
     }
@@ -985,22 +1262,10 @@ export const Request = {
       RequestQuery.encode(message.query, writer.uint32(50).fork()).ldelim();
     }
 
-    if (message.beginBlock !== undefined) {
-      RequestBeginBlock.encode(message.beginBlock, writer.uint32(58).fork()).ldelim();
-    }
-
     if (message.checkTx !== undefined) {
       RequestCheckTx.encode(message.checkTx, writer.uint32(66).fork()).ldelim();
     }
 
-    if (message.deliverTx !== undefined) {
-      RequestDeliverTx.encode(message.deliverTx, writer.uint32(74).fork()).ldelim();
-    }
-
-    if (message.endBlock !== undefined) {
-      RequestEndBlock.encode(message.endBlock, writer.uint32(82).fork()).ldelim();
-    }
-
     if (message.commit !== undefined) {
       RequestCommit.encode(message.commit, writer.uint32(90).fork()).ldelim();
     }
@@ -1021,6 +1286,26 @@ export const Request = {
       RequestApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(122).fork()).ldelim();
     }
 
+    if (message.prepareProposal !== undefined) {
+      RequestPrepareProposal.encode(message.prepareProposal, writer.uint32(130).fork()).ldelim();
+    }
+
+    if (message.processProposal !== undefined) {
+      RequestProcessProposal.encode(message.processProposal, writer.uint32(138).fork()).ldelim();
+    }
+
+    if (message.extendVote !== undefined) {
+      RequestExtendVote.encode(message.extendVote, writer.uint32(146).fork()).ldelim();
+    }
+
+    if (message.verifyVoteExtension !== undefined) {
+      RequestVerifyVoteExtension.encode(message.verifyVoteExtension, writer.uint32(154).fork()).ldelim();
+    }
+
+    if (message.finalizeBlock !== undefined) {
+      RequestFinalizeBlock.encode(message.finalizeBlock, writer.uint32(162).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -1045,10 +1330,6 @@ export const Request = {
           message.info = RequestInfo.decode(reader, reader.uint32());
           break;
 
-        case 4:
-          message.setOption = RequestSetOption.decode(reader, reader.uint32());
-          break;
-
         case 5:
           message.initChain = RequestInitChain.decode(reader, reader.uint32());
           break;
@@ -1057,22 +1338,10 @@ export const Request = {
           message.query = RequestQuery.decode(reader, reader.uint32());
           break;
 
-        case 7:
-          message.beginBlock = RequestBeginBlock.decode(reader, reader.uint32());
-          break;
-
         case 8:
           message.checkTx = RequestCheckTx.decode(reader, reader.uint32());
           break;
 
-        case 9:
-          message.deliverTx = RequestDeliverTx.decode(reader, reader.uint32());
-          break;
-
-        case 10:
-          message.endBlock = RequestEndBlock.decode(reader, reader.uint32());
-          break;
-
         case 11:
           message.commit = RequestCommit.decode(reader, reader.uint32());
           break;
@@ -1093,6 +1362,26 @@ export const Request = {
           message.applySnapshotChunk = RequestApplySnapshotChunk.decode(reader, reader.uint32());
           break;
 
+        case 16:
+          message.prepareProposal = RequestPrepareProposal.decode(reader, reader.uint32());
+          break;
+
+        case 17:
+          message.processProposal = RequestProcessProposal.decode(reader, reader.uint32());
+          break;
+
+        case 18:
+          message.extendVote = RequestExtendVote.decode(reader, reader.uint32());
+          break;
+
+        case 19:
+          message.verifyVoteExtension = RequestVerifyVoteExtension.decode(reader, reader.uint32());
+          break;
+
+        case 20:
+          message.finalizeBlock = RequestFinalizeBlock.decode(reader, reader.uint32());
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -1107,18 +1396,19 @@ export const Request = {
       echo: isSet(object.echo) ? RequestEcho.fromJSON(object.echo) : undefined,
       flush: isSet(object.flush) ? RequestFlush.fromJSON(object.flush) : undefined,
       info: isSet(object.info) ? RequestInfo.fromJSON(object.info) : undefined,
-      setOption: isSet(object.setOption) ? RequestSetOption.fromJSON(object.setOption) : undefined,
       initChain: isSet(object.initChain) ? RequestInitChain.fromJSON(object.initChain) : undefined,
       query: isSet(object.query) ? RequestQuery.fromJSON(object.query) : undefined,
-      beginBlock: isSet(object.beginBlock) ? RequestBeginBlock.fromJSON(object.beginBlock) : undefined,
       checkTx: isSet(object.checkTx) ? RequestCheckTx.fromJSON(object.checkTx) : undefined,
-      deliverTx: isSet(object.deliverTx) ? RequestDeliverTx.fromJSON(object.deliverTx) : undefined,
-      endBlock: isSet(object.endBlock) ? RequestEndBlock.fromJSON(object.endBlock) : undefined,
       commit: isSet(object.commit) ? RequestCommit.fromJSON(object.commit) : undefined,
       listSnapshots: isSet(object.listSnapshots) ? RequestListSnapshots.fromJSON(object.listSnapshots) : undefined,
       offerSnapshot: isSet(object.offerSnapshot) ? RequestOfferSnapshot.fromJSON(object.offerSnapshot) : undefined,
       loadSnapshotChunk: isSet(object.loadSnapshotChunk) ? RequestLoadSnapshotChunk.fromJSON(object.loadSnapshotChunk) : undefined,
-      applySnapshotChunk: isSet(object.applySnapshotChunk) ? RequestApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : undefined
+      applySnapshotChunk: isSet(object.applySnapshotChunk) ? RequestApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : undefined,
+      prepareProposal: isSet(object.prepareProposal) ? RequestPrepareProposal.fromJSON(object.prepareProposal) : undefined,
+      processProposal: isSet(object.processProposal) ? RequestProcessProposal.fromJSON(object.processProposal) : undefined,
+      extendVote: isSet(object.extendVote) ? RequestExtendVote.fromJSON(object.extendVote) : undefined,
+      verifyVoteExtension: isSet(object.verifyVoteExtension) ? RequestVerifyVoteExtension.fromJSON(object.verifyVoteExtension) : undefined,
+      finalizeBlock: isSet(object.finalizeBlock) ? RequestFinalizeBlock.fromJSON(object.finalizeBlock) : undefined
     };
   },
 
@@ -1127,18 +1417,19 @@ export const Request = {
     message.echo !== undefined && (obj.echo = message.echo ? RequestEcho.toJSON(message.echo) : undefined);
     message.flush !== undefined && (obj.flush = message.flush ? RequestFlush.toJSON(message.flush) : undefined);
     message.info !== undefined && (obj.info = message.info ? RequestInfo.toJSON(message.info) : undefined);
-    message.setOption !== undefined && (obj.setOption = message.setOption ? RequestSetOption.toJSON(message.setOption) : undefined);
     message.initChain !== undefined && (obj.initChain = message.initChain ? RequestInitChain.toJSON(message.initChain) : undefined);
     message.query !== undefined && (obj.query = message.query ? RequestQuery.toJSON(message.query) : undefined);
-    message.beginBlock !== undefined && (obj.beginBlock = message.beginBlock ? RequestBeginBlock.toJSON(message.beginBlock) : undefined);
     message.checkTx !== undefined && (obj.checkTx = message.checkTx ? RequestCheckTx.toJSON(message.checkTx) : undefined);
-    message.deliverTx !== undefined && (obj.deliverTx = message.deliverTx ? RequestDeliverTx.toJSON(message.deliverTx) : undefined);
-    message.endBlock !== undefined && (obj.endBlock = message.endBlock ? RequestEndBlock.toJSON(message.endBlock) : undefined);
     message.commit !== undefined && (obj.commit = message.commit ? RequestCommit.toJSON(message.commit) : undefined);
     message.listSnapshots !== undefined && (obj.listSnapshots = message.listSnapshots ? RequestListSnapshots.toJSON(message.listSnapshots) : undefined);
     message.offerSnapshot !== undefined && (obj.offerSnapshot = message.offerSnapshot ? RequestOfferSnapshot.toJSON(message.offerSnapshot) : undefined);
     message.loadSnapshotChunk !== undefined && (obj.loadSnapshotChunk = message.loadSnapshotChunk ? RequestLoadSnapshotChunk.toJSON(message.loadSnapshotChunk) : undefined);
     message.applySnapshotChunk !== undefined && (obj.applySnapshotChunk = message.applySnapshotChunk ? RequestApplySnapshotChunk.toJSON(message.applySnapshotChunk) : undefined);
+    message.prepareProposal !== undefined && (obj.prepareProposal = message.prepareProposal ? RequestPrepareProposal.toJSON(message.prepareProposal) : undefined);
+    message.processProposal !== undefined && (obj.processProposal = message.processProposal ? RequestProcessProposal.toJSON(message.processProposal) : undefined);
+    message.extendVote !== undefined && (obj.extendVote = message.extendVote ? RequestExtendVote.toJSON(message.extendVote) : undefined);
+    message.verifyVoteExtension !== undefined && (obj.verifyVoteExtension = message.verifyVoteExtension ? RequestVerifyVoteExtension.toJSON(message.verifyVoteExtension) : undefined);
+    message.finalizeBlock !== undefined && (obj.finalizeBlock = message.finalizeBlock ? RequestFinalizeBlock.toJSON(message.finalizeBlock) : undefined);
     return obj;
   },
 
@@ -1147,18 +1438,19 @@ export const Request = {
     message.echo = object.echo !== undefined && object.echo !== null ? RequestEcho.fromPartial(object.echo) : undefined;
     message.flush = object.flush !== undefined && object.flush !== null ? RequestFlush.fromPartial(object.flush) : undefined;
     message.info = object.info !== undefined && object.info !== null ? RequestInfo.fromPartial(object.info) : undefined;
-    message.setOption = object.setOption !== undefined && object.setOption !== null ? RequestSetOption.fromPartial(object.setOption) : undefined;
     message.initChain = object.initChain !== undefined && object.initChain !== null ? RequestInitChain.fromPartial(object.initChain) : undefined;
     message.query = object.query !== undefined && object.query !== null ? RequestQuery.fromPartial(object.query) : undefined;
-    message.beginBlock = object.beginBlock !== undefined && object.beginBlock !== null ? RequestBeginBlock.fromPartial(object.beginBlock) : undefined;
     message.checkTx = object.checkTx !== undefined && object.checkTx !== null ? RequestCheckTx.fromPartial(object.checkTx) : undefined;
-    message.deliverTx = object.deliverTx !== undefined && object.deliverTx !== null ? RequestDeliverTx.fromPartial(object.deliverTx) : undefined;
-    message.endBlock = object.endBlock !== undefined && object.endBlock !== null ? RequestEndBlock.fromPartial(object.endBlock) : undefined;
     message.commit = object.commit !== undefined && object.commit !== null ? RequestCommit.fromPartial(object.commit) : undefined;
     message.listSnapshots = object.listSnapshots !== undefined && object.listSnapshots !== null ? RequestListSnapshots.fromPartial(object.listSnapshots) : undefined;
     message.offerSnapshot = object.offerSnapshot !== undefined && object.offerSnapshot !== null ? RequestOfferSnapshot.fromPartial(object.offerSnapshot) : undefined;
     message.loadSnapshotChunk = object.loadSnapshotChunk !== undefined && object.loadSnapshotChunk !== null ? RequestLoadSnapshotChunk.fromPartial(object.loadSnapshotChunk) : undefined;
     message.applySnapshotChunk = object.applySnapshotChunk !== undefined && object.applySnapshotChunk !== null ? RequestApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : undefined;
+    message.prepareProposal = object.prepareProposal !== undefined && object.prepareProposal !== null ? RequestPrepareProposal.fromPartial(object.prepareProposal) : undefined;
+    message.processProposal = object.processProposal !== undefined && object.processProposal !== null ? RequestProcessProposal.fromPartial(object.processProposal) : undefined;
+    message.extendVote = object.extendVote !== undefined && object.extendVote !== null ? RequestExtendVote.fromPartial(object.extendVote) : undefined;
+    message.verifyVoteExtension = object.verifyVoteExtension !== undefined && object.verifyVoteExtension !== null ? RequestVerifyVoteExtension.fromPartial(object.verifyVoteExtension) : undefined;
+    message.finalizeBlock = object.finalizeBlock !== undefined && object.finalizeBlock !== null ? RequestFinalizeBlock.fromPartial(object.finalizeBlock) : undefined;
     return message;
   }
 
@@ -1268,7 +1560,8 @@ function createBaseRequestInfo(): RequestInfo {
   return {
     version: "",
     blockVersion: Long.UZERO,
-    p2pVersion: Long.UZERO
+    p2pVersion: Long.UZERO,
+    abciVersion: ""
   };
 }
 
@@ -1286,6 +1579,10 @@ export const RequestInfo = {
       writer.uint32(24).uint64(message.p2pVersion);
     }
 
+    if (message.abciVersion !== "") {
+      writer.uint32(34).string(message.abciVersion);
+    }
+
     return writer;
   },
 
@@ -1310,6 +1607,10 @@ export const RequestInfo = {
           message.p2pVersion = (reader.uint64() as Long);
           break;
 
+        case 4:
+          message.abciVersion = reader.string();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -1323,7 +1624,8 @@ export const RequestInfo = {
     return {
       version: isSet(object.version) ? String(object.version) : "",
       blockVersion: isSet(object.blockVersion) ? Long.fromValue(object.blockVersion) : Long.UZERO,
-      p2pVersion: isSet(object.p2pVersion) ? Long.fromValue(object.p2pVersion) : Long.UZERO
+      p2pVersion: isSet(object.p2pVersion) ? Long.fromValue(object.p2pVersion) : Long.UZERO,
+      abciVersion: isSet(object.abciVersion) ? String(object.abciVersion) : ""
     };
   },
 
@@ -1332,6 +1634,7 @@ export const RequestInfo = {
     message.version !== undefined && (obj.version = message.version);
     message.blockVersion !== undefined && (obj.blockVersion = (message.blockVersion || Long.UZERO).toString());
     message.p2pVersion !== undefined && (obj.p2pVersion = (message.p2pVersion || Long.UZERO).toString());
+    message.abciVersion !== undefined && (obj.abciVersion = message.abciVersion);
     return obj;
   },
 
@@ -1340,75 +1643,7 @@ export const RequestInfo = {
     message.version = object.version ?? "";
     message.blockVersion = object.blockVersion !== undefined && object.blockVersion !== null ? Long.fromValue(object.blockVersion) : Long.UZERO;
     message.p2pVersion = object.p2pVersion !== undefined && object.p2pVersion !== null ? Long.fromValue(object.p2pVersion) : Long.UZERO;
-    return message;
-  }
-
-};
-
-function createBaseRequestSetOption(): RequestSetOption {
-  return {
-    key: "",
-    value: ""
-  };
-}
-
-export const RequestSetOption = {
-  encode(message: RequestSetOption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
-    }
-
-    if (message.value !== "") {
-      writer.uint32(18).string(message.value);
-    }
-
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): RequestSetOption {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRequestSetOption();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.key = reader.string();
-          break;
-
-        case 2:
-          message.value = reader.string();
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): RequestSetOption {
-    return {
-      key: isSet(object.key) ? String(object.key) : "",
-      value: isSet(object.value) ? String(object.value) : ""
-    };
-  },
-
-  toJSON(message: RequestSetOption): unknown {
-    const obj: any = {};
-    message.key !== undefined && (obj.key = message.key);
-    message.value !== undefined && (obj.value = message.value);
-    return obj;
-  },
-
-  fromPartial(object: Partial<RequestSetOption>): RequestSetOption {
-    const message = createBaseRequestSetOption();
-    message.key = object.key ?? "";
-    message.value = object.value ?? "";
+    message.abciVersion = object.abciVersion ?? "";
     return message;
   }
 
@@ -1630,105 +1865,6 @@ export const RequestQuery = {
 
 };
 
-function createBaseRequestBeginBlock(): RequestBeginBlock {
-  return {
-    hash: new Uint8Array(),
-    header: undefined,
-    lastCommitInfo: undefined,
-    byzantineValidators: []
-  };
-}
-
-export const RequestBeginBlock = {
-  encode(message: RequestBeginBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.hash.length !== 0) {
-      writer.uint32(10).bytes(message.hash);
-    }
-
-    if (message.header !== undefined) {
-      Header.encode(message.header, writer.uint32(18).fork()).ldelim();
-    }
-
-    if (message.lastCommitInfo !== undefined) {
-      LastCommitInfo.encode(message.lastCommitInfo, writer.uint32(26).fork()).ldelim();
-    }
-
-    for (const v of message.byzantineValidators) {
-      Evidence.encode(v!, writer.uint32(34).fork()).ldelim();
-    }
-
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): RequestBeginBlock {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRequestBeginBlock();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.hash = reader.bytes();
-          break;
-
-        case 2:
-          message.header = Header.decode(reader, reader.uint32());
-          break;
-
-        case 3:
-          message.lastCommitInfo = LastCommitInfo.decode(reader, reader.uint32());
-          break;
-
-        case 4:
-          message.byzantineValidators.push(Evidence.decode(reader, reader.uint32()));
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): RequestBeginBlock {
-    return {
-      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
-      header: isSet(object.header) ? Header.fromJSON(object.header) : undefined,
-      lastCommitInfo: isSet(object.lastCommitInfo) ? LastCommitInfo.fromJSON(object.lastCommitInfo) : undefined,
-      byzantineValidators: Array.isArray(object?.byzantineValidators) ? object.byzantineValidators.map((e: any) => Evidence.fromJSON(e)) : []
-    };
-  },
-
-  toJSON(message: RequestBeginBlock): unknown {
-    const obj: any = {};
-    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
-    message.header !== undefined && (obj.header = message.header ? Header.toJSON(message.header) : undefined);
-    message.lastCommitInfo !== undefined && (obj.lastCommitInfo = message.lastCommitInfo ? LastCommitInfo.toJSON(message.lastCommitInfo) : undefined);
-
-    if (message.byzantineValidators) {
-      obj.byzantineValidators = message.byzantineValidators.map(e => e ? Evidence.toJSON(e) : undefined);
-    } else {
-      obj.byzantineValidators = [];
-    }
-
-    return obj;
-  },
-
-  fromPartial(object: Partial<RequestBeginBlock>): RequestBeginBlock {
-    const message = createBaseRequestBeginBlock();
-    message.hash = object.hash ?? new Uint8Array();
-    message.header = object.header !== undefined && object.header !== null ? Header.fromPartial(object.header) : undefined;
-    message.lastCommitInfo = object.lastCommitInfo !== undefined && object.lastCommitInfo !== null ? LastCommitInfo.fromPartial(object.lastCommitInfo) : undefined;
-    message.byzantineValidators = object.byzantineValidators?.map(e => Evidence.fromPartial(e)) || [];
-    return message;
-  }
-
-};
-
 function createBaseRequestCheckTx(): RequestCheckTx {
   return {
     tx: new Uint8Array(),
@@ -1798,120 +1934,6 @@ export const RequestCheckTx = {
 
 };
 
-function createBaseRequestDeliverTx(): RequestDeliverTx {
-  return {
-    tx: new Uint8Array()
-  };
-}
-
-export const RequestDeliverTx = {
-  encode(message: RequestDeliverTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.tx.length !== 0) {
-      writer.uint32(10).bytes(message.tx);
-    }
-
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): RequestDeliverTx {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRequestDeliverTx();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.tx = reader.bytes();
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): RequestDeliverTx {
-    return {
-      tx: isSet(object.tx) ? bytesFromBase64(object.tx) : new Uint8Array()
-    };
-  },
-
-  toJSON(message: RequestDeliverTx): unknown {
-    const obj: any = {};
-    message.tx !== undefined && (obj.tx = base64FromBytes(message.tx !== undefined ? message.tx : new Uint8Array()));
-    return obj;
-  },
-
-  fromPartial(object: Partial<RequestDeliverTx>): RequestDeliverTx {
-    const message = createBaseRequestDeliverTx();
-    message.tx = object.tx ?? new Uint8Array();
-    return message;
-  }
-
-};
-
-function createBaseRequestEndBlock(): RequestEndBlock {
-  return {
-    height: Long.ZERO
-  };
-}
-
-export const RequestEndBlock = {
-  encode(message: RequestEndBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (!message.height.isZero()) {
-      writer.uint32(8).int64(message.height);
-    }
-
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): RequestEndBlock {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRequestEndBlock();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.height = (reader.int64() as Long);
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): RequestEndBlock {
-    return {
-      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO
-    };
-  },
-
-  toJSON(message: RequestEndBlock): unknown {
-    const obj: any = {};
-    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
-    return obj;
-  },
-
-  fromPartial(object: Partial<RequestEndBlock>): RequestEndBlock {
-    const message = createBaseRequestEndBlock();
-    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
-    return message;
-  }
-
-};
-
 function createBaseRequestCommit(): RequestCommit {
   return {};
 }
@@ -2229,167 +2251,95 @@ export const RequestApplySnapshotChunk = {
 
 };
 
-function createBaseResponse(): Response {
+function createBaseRequestPrepareProposal(): RequestPrepareProposal {
   return {
-    exception: undefined,
-    echo: undefined,
-    flush: undefined,
-    info: undefined,
-    setOption: undefined,
-    initChain: undefined,
-    query: undefined,
-    beginBlock: undefined,
-    checkTx: undefined,
-    deliverTx: undefined,
-    endBlock: undefined,
-    commit: undefined,
-    listSnapshots: undefined,
-    offerSnapshot: undefined,
-    loadSnapshotChunk: undefined,
-    applySnapshotChunk: undefined
+    maxTxBytes: Long.ZERO,
+    txs: [],
+    localLastCommit: undefined,
+    misbehavior: [],
+    height: Long.ZERO,
+    time: undefined,
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array()
   };
 }
 
-export const Response = {
-  encode(message: Response, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.exception !== undefined) {
-      ResponseException.encode(message.exception, writer.uint32(10).fork()).ldelim();
-    }
-
-    if (message.echo !== undefined) {
-      ResponseEcho.encode(message.echo, writer.uint32(18).fork()).ldelim();
-    }
-
-    if (message.flush !== undefined) {
-      ResponseFlush.encode(message.flush, writer.uint32(26).fork()).ldelim();
-    }
-
-    if (message.info !== undefined) {
-      ResponseInfo.encode(message.info, writer.uint32(34).fork()).ldelim();
-    }
-
-    if (message.setOption !== undefined) {
-      ResponseSetOption.encode(message.setOption, writer.uint32(42).fork()).ldelim();
-    }
-
-    if (message.initChain !== undefined) {
-      ResponseInitChain.encode(message.initChain, writer.uint32(50).fork()).ldelim();
-    }
-
-    if (message.query !== undefined) {
-      ResponseQuery.encode(message.query, writer.uint32(58).fork()).ldelim();
-    }
-
-    if (message.beginBlock !== undefined) {
-      ResponseBeginBlock.encode(message.beginBlock, writer.uint32(66).fork()).ldelim();
-    }
-
-    if (message.checkTx !== undefined) {
-      ResponseCheckTx.encode(message.checkTx, writer.uint32(74).fork()).ldelim();
+export const RequestPrepareProposal = {
+  encode(message: RequestPrepareProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.maxTxBytes.isZero()) {
+      writer.uint32(8).int64(message.maxTxBytes);
     }
 
-    if (message.deliverTx !== undefined) {
-      ResponseDeliverTx.encode(message.deliverTx, writer.uint32(82).fork()).ldelim();
+    for (const v of message.txs) {
+      writer.uint32(18).bytes(v!);
     }
 
-    if (message.endBlock !== undefined) {
-      ResponseEndBlock.encode(message.endBlock, writer.uint32(90).fork()).ldelim();
+    if (message.localLastCommit !== undefined) {
+      ExtendedCommitInfo.encode(message.localLastCommit, writer.uint32(26).fork()).ldelim();
     }
 
-    if (message.commit !== undefined) {
-      ResponseCommit.encode(message.commit, writer.uint32(98).fork()).ldelim();
+    for (const v of message.misbehavior) {
+      Misbehavior.encode(v!, writer.uint32(34).fork()).ldelim();
     }
 
-    if (message.listSnapshots !== undefined) {
-      ResponseListSnapshots.encode(message.listSnapshots, writer.uint32(106).fork()).ldelim();
+    if (!message.height.isZero()) {
+      writer.uint32(40).int64(message.height);
     }
 
-    if (message.offerSnapshot !== undefined) {
-      ResponseOfferSnapshot.encode(message.offerSnapshot, writer.uint32(114).fork()).ldelim();
+    if (message.time !== undefined) {
+      Timestamp.encode(message.time, writer.uint32(50).fork()).ldelim();
     }
 
-    if (message.loadSnapshotChunk !== undefined) {
-      ResponseLoadSnapshotChunk.encode(message.loadSnapshotChunk, writer.uint32(122).fork()).ldelim();
+    if (message.nextValidatorsHash.length !== 0) {
+      writer.uint32(58).bytes(message.nextValidatorsHash);
     }
 
-    if (message.applySnapshotChunk !== undefined) {
-      ResponseApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(130).fork()).ldelim();
+    if (message.proposerAddress.length !== 0) {
+      writer.uint32(66).bytes(message.proposerAddress);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Response {
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestPrepareProposal {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponse();
+    const message = createBaseRequestPrepareProposal();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.exception = ResponseException.decode(reader, reader.uint32());
+          message.maxTxBytes = (reader.int64() as Long);
           break;
 
         case 2:
-          message.echo = ResponseEcho.decode(reader, reader.uint32());
+          message.txs.push(reader.bytes());
           break;
 
         case 3:
-          message.flush = ResponseFlush.decode(reader, reader.uint32());
+          message.localLastCommit = ExtendedCommitInfo.decode(reader, reader.uint32());
           break;
 
         case 4:
-          message.info = ResponseInfo.decode(reader, reader.uint32());
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
           break;
 
         case 5:
-          message.setOption = ResponseSetOption.decode(reader, reader.uint32());
+          message.height = (reader.int64() as Long);
           break;
 
         case 6:
-          message.initChain = ResponseInitChain.decode(reader, reader.uint32());
+          message.time = Timestamp.decode(reader, reader.uint32());
           break;
 
         case 7:
-          message.query = ResponseQuery.decode(reader, reader.uint32());
+          message.nextValidatorsHash = reader.bytes();
           break;
 
         case 8:
-          message.beginBlock = ResponseBeginBlock.decode(reader, reader.uint32());
-          break;
-
-        case 9:
-          message.checkTx = ResponseCheckTx.decode(reader, reader.uint32());
-          break;
-
-        case 10:
-          message.deliverTx = ResponseDeliverTx.decode(reader, reader.uint32());
-          break;
-
-        case 11:
-          message.endBlock = ResponseEndBlock.decode(reader, reader.uint32());
-          break;
-
-        case 12:
-          message.commit = ResponseCommit.decode(reader, reader.uint32());
-          break;
-
-        case 13:
-          message.listSnapshots = ResponseListSnapshots.decode(reader, reader.uint32());
-          break;
-
-        case 14:
-          message.offerSnapshot = ResponseOfferSnapshot.decode(reader, reader.uint32());
-          break;
-
-        case 15:
-          message.loadSnapshotChunk = ResponseLoadSnapshotChunk.decode(reader, reader.uint32());
-          break;
-
-        case 16:
-          message.applySnapshotChunk = ResponseApplySnapshotChunk.decode(reader, reader.uint32());
+          message.proposerAddress = reader.bytes();
           break;
 
         default:
@@ -2401,203 +2351,150 @@ export const Response = {
     return message;
   },
 
-  fromJSON(object: any): Response {
+  fromJSON(object: any): RequestPrepareProposal {
     return {
-      exception: isSet(object.exception) ? ResponseException.fromJSON(object.exception) : undefined,
-      echo: isSet(object.echo) ? ResponseEcho.fromJSON(object.echo) : undefined,
-      flush: isSet(object.flush) ? ResponseFlush.fromJSON(object.flush) : undefined,
-      info: isSet(object.info) ? ResponseInfo.fromJSON(object.info) : undefined,
-      setOption: isSet(object.setOption) ? ResponseSetOption.fromJSON(object.setOption) : undefined,
-      initChain: isSet(object.initChain) ? ResponseInitChain.fromJSON(object.initChain) : undefined,
-      query: isSet(object.query) ? ResponseQuery.fromJSON(object.query) : undefined,
-      beginBlock: isSet(object.beginBlock) ? ResponseBeginBlock.fromJSON(object.beginBlock) : undefined,
-      checkTx: isSet(object.checkTx) ? ResponseCheckTx.fromJSON(object.checkTx) : undefined,
-      deliverTx: isSet(object.deliverTx) ? ResponseDeliverTx.fromJSON(object.deliverTx) : undefined,
-      endBlock: isSet(object.endBlock) ? ResponseEndBlock.fromJSON(object.endBlock) : undefined,
-      commit: isSet(object.commit) ? ResponseCommit.fromJSON(object.commit) : undefined,
-      listSnapshots: isSet(object.listSnapshots) ? ResponseListSnapshots.fromJSON(object.listSnapshots) : undefined,
-      offerSnapshot: isSet(object.offerSnapshot) ? ResponseOfferSnapshot.fromJSON(object.offerSnapshot) : undefined,
-      loadSnapshotChunk: isSet(object.loadSnapshotChunk) ? ResponseLoadSnapshotChunk.fromJSON(object.loadSnapshotChunk) : undefined,
-      applySnapshotChunk: isSet(object.applySnapshotChunk) ? ResponseApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : undefined
+      maxTxBytes: isSet(object.maxTxBytes) ? Long.fromValue(object.maxTxBytes) : Long.ZERO,
+      txs: Array.isArray(object?.txs) ? object.txs.map((e: any) => bytesFromBase64(e)) : [],
+      localLastCommit: isSet(object.localLastCommit) ? ExtendedCommitInfo.fromJSON(object.localLastCommit) : undefined,
+      misbehavior: Array.isArray(object?.misbehavior) ? object.misbehavior.map((e: any) => Misbehavior.fromJSON(e)) : [],
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
+      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
+      nextValidatorsHash: isSet(object.nextValidatorsHash) ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array(),
+      proposerAddress: isSet(object.proposerAddress) ? bytesFromBase64(object.proposerAddress) : new Uint8Array()
     };
   },
 
-  toJSON(message: Response): unknown {
+  toJSON(message: RequestPrepareProposal): unknown {
     const obj: any = {};
-    message.exception !== undefined && (obj.exception = message.exception ? ResponseException.toJSON(message.exception) : undefined);
-    message.echo !== undefined && (obj.echo = message.echo ? ResponseEcho.toJSON(message.echo) : undefined);
-    message.flush !== undefined && (obj.flush = message.flush ? ResponseFlush.toJSON(message.flush) : undefined);
-    message.info !== undefined && (obj.info = message.info ? ResponseInfo.toJSON(message.info) : undefined);
-    message.setOption !== undefined && (obj.setOption = message.setOption ? ResponseSetOption.toJSON(message.setOption) : undefined);
-    message.initChain !== undefined && (obj.initChain = message.initChain ? ResponseInitChain.toJSON(message.initChain) : undefined);
-    message.query !== undefined && (obj.query = message.query ? ResponseQuery.toJSON(message.query) : undefined);
-    message.beginBlock !== undefined && (obj.beginBlock = message.beginBlock ? ResponseBeginBlock.toJSON(message.beginBlock) : undefined);
-    message.checkTx !== undefined && (obj.checkTx = message.checkTx ? ResponseCheckTx.toJSON(message.checkTx) : undefined);
-    message.deliverTx !== undefined && (obj.deliverTx = message.deliverTx ? ResponseDeliverTx.toJSON(message.deliverTx) : undefined);
-    message.endBlock !== undefined && (obj.endBlock = message.endBlock ? ResponseEndBlock.toJSON(message.endBlock) : undefined);
-    message.commit !== undefined && (obj.commit = message.commit ? ResponseCommit.toJSON(message.commit) : undefined);
-    message.listSnapshots !== undefined && (obj.listSnapshots = message.listSnapshots ? ResponseListSnapshots.toJSON(message.listSnapshots) : undefined);
-    message.offerSnapshot !== undefined && (obj.offerSnapshot = message.offerSnapshot ? ResponseOfferSnapshot.toJSON(message.offerSnapshot) : undefined);
-    message.loadSnapshotChunk !== undefined && (obj.loadSnapshotChunk = message.loadSnapshotChunk ? ResponseLoadSnapshotChunk.toJSON(message.loadSnapshotChunk) : undefined);
-    message.applySnapshotChunk !== undefined && (obj.applySnapshotChunk = message.applySnapshotChunk ? ResponseApplySnapshotChunk.toJSON(message.applySnapshotChunk) : undefined);
+    message.maxTxBytes !== undefined && (obj.maxTxBytes = (message.maxTxBytes || Long.ZERO).toString());
+
+    if (message.txs) {
+      obj.txs = message.txs.map(e => base64FromBytes(e !== undefined ? e : new Uint8Array()));
+    } else {
+      obj.txs = [];
+    }
+
+    message.localLastCommit !== undefined && (obj.localLastCommit = message.localLastCommit ? ExtendedCommitInfo.toJSON(message.localLastCommit) : undefined);
+
+    if (message.misbehavior) {
+      obj.misbehavior = message.misbehavior.map(e => e ? Misbehavior.toJSON(e) : undefined);
+    } else {
+      obj.misbehavior = [];
+    }
+
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
+    message.time !== undefined && (obj.time = fromTimestamp(message.time).toISOString());
+    message.nextValidatorsHash !== undefined && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== undefined ? message.nextValidatorsHash : new Uint8Array()));
+    message.proposerAddress !== undefined && (obj.proposerAddress = base64FromBytes(message.proposerAddress !== undefined ? message.proposerAddress : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<Response>): Response {
-    const message = createBaseResponse();
-    message.exception = object.exception !== undefined && object.exception !== null ? ResponseException.fromPartial(object.exception) : undefined;
-    message.echo = object.echo !== undefined && object.echo !== null ? ResponseEcho.fromPartial(object.echo) : undefined;
-    message.flush = object.flush !== undefined && object.flush !== null ? ResponseFlush.fromPartial(object.flush) : undefined;
-    message.info = object.info !== undefined && object.info !== null ? ResponseInfo.fromPartial(object.info) : undefined;
-    message.setOption = object.setOption !== undefined && object.setOption !== null ? ResponseSetOption.fromPartial(object.setOption) : undefined;
-    message.initChain = object.initChain !== undefined && object.initChain !== null ? ResponseInitChain.fromPartial(object.initChain) : undefined;
-    message.query = object.query !== undefined && object.query !== null ? ResponseQuery.fromPartial(object.query) : undefined;
-    message.beginBlock = object.beginBlock !== undefined && object.beginBlock !== null ? ResponseBeginBlock.fromPartial(object.beginBlock) : undefined;
-    message.checkTx = object.checkTx !== undefined && object.checkTx !== null ? ResponseCheckTx.fromPartial(object.checkTx) : undefined;
-    message.deliverTx = object.deliverTx !== undefined && object.deliverTx !== null ? ResponseDeliverTx.fromPartial(object.deliverTx) : undefined;
-    message.endBlock = object.endBlock !== undefined && object.endBlock !== null ? ResponseEndBlock.fromPartial(object.endBlock) : undefined;
-    message.commit = object.commit !== undefined && object.commit !== null ? ResponseCommit.fromPartial(object.commit) : undefined;
-    message.listSnapshots = object.listSnapshots !== undefined && object.listSnapshots !== null ? ResponseListSnapshots.fromPartial(object.listSnapshots) : undefined;
-    message.offerSnapshot = object.offerSnapshot !== undefined && object.offerSnapshot !== null ? ResponseOfferSnapshot.fromPartial(object.offerSnapshot) : undefined;
-    message.loadSnapshotChunk = object.loadSnapshotChunk !== undefined && object.loadSnapshotChunk !== null ? ResponseLoadSnapshotChunk.fromPartial(object.loadSnapshotChunk) : undefined;
-    message.applySnapshotChunk = object.applySnapshotChunk !== undefined && object.applySnapshotChunk !== null ? ResponseApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : undefined;
+  fromPartial(object: Partial<RequestPrepareProposal>): RequestPrepareProposal {
+    const message = createBaseRequestPrepareProposal();
+    message.maxTxBytes = object.maxTxBytes !== undefined && object.maxTxBytes !== null ? Long.fromValue(object.maxTxBytes) : Long.ZERO;
+    message.txs = object.txs?.map(e => e) || [];
+    message.localLastCommit = object.localLastCommit !== undefined && object.localLastCommit !== null ? ExtendedCommitInfo.fromPartial(object.localLastCommit) : undefined;
+    message.misbehavior = object.misbehavior?.map(e => Misbehavior.fromPartial(e)) || [];
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
+    message.time = object.time !== undefined && object.time !== null ? Timestamp.fromPartial(object.time) : undefined;
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseException(): ResponseException {
+function createBaseRequestProcessProposal(): RequestProcessProposal {
   return {
-    error: ""
+    txs: [],
+    proposedLastCommit: undefined,
+    misbehavior: [],
+    hash: new Uint8Array(),
+    height: Long.ZERO,
+    time: undefined,
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array()
   };
 }
 
-export const ResponseException = {
-  encode(message: ResponseException, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.error !== "") {
-      writer.uint32(10).string(message.error);
+export const RequestProcessProposal = {
+  encode(message: RequestProcessProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.txs) {
+      writer.uint32(10).bytes(v!);
     }
 
-    return writer;
-  },
+    if (message.proposedLastCommit !== undefined) {
+      CommitInfo.encode(message.proposedLastCommit, writer.uint32(18).fork()).ldelim();
+    }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseException {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseException();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.error = reader.string();
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
+    for (const v of message.misbehavior) {
+      Misbehavior.encode(v!, writer.uint32(26).fork()).ldelim();
     }
 
-    return message;
-  },
-
-  fromJSON(object: any): ResponseException {
-    return {
-      error: isSet(object.error) ? String(object.error) : ""
-    };
-  },
-
-  toJSON(message: ResponseException): unknown {
-    const obj: any = {};
-    message.error !== undefined && (obj.error = message.error);
-    return obj;
-  },
+    if (message.hash.length !== 0) {
+      writer.uint32(34).bytes(message.hash);
+    }
 
-  fromPartial(object: Partial<ResponseException>): ResponseException {
-    const message = createBaseResponseException();
-    message.error = object.error ?? "";
-    return message;
-  }
+    if (!message.height.isZero()) {
+      writer.uint32(40).int64(message.height);
+    }
 
-};
+    if (message.time !== undefined) {
+      Timestamp.encode(message.time, writer.uint32(50).fork()).ldelim();
+    }
 
-function createBaseResponseEcho(): ResponseEcho {
-  return {
-    message: ""
-  };
-}
+    if (message.nextValidatorsHash.length !== 0) {
+      writer.uint32(58).bytes(message.nextValidatorsHash);
+    }
 
-export const ResponseEcho = {
-  encode(message: ResponseEcho, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.message !== "") {
-      writer.uint32(10).string(message.message);
+    if (message.proposerAddress.length !== 0) {
+      writer.uint32(66).bytes(message.proposerAddress);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseEcho {
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestProcessProposal {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseEcho();
+    const message = createBaseRequestProcessProposal();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.message = reader.string();
+          message.txs.push(reader.bytes());
           break;
 
-        default:
-          reader.skipType(tag & 7);
+        case 2:
+          message.proposedLastCommit = CommitInfo.decode(reader, reader.uint32());
           break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): ResponseEcho {
-    return {
-      message: isSet(object.message) ? String(object.message) : ""
-    };
-  },
-
-  toJSON(message: ResponseEcho): unknown {
-    const obj: any = {};
-    message.message !== undefined && (obj.message = message.message);
-    return obj;
-  },
 
-  fromPartial(object: Partial<ResponseEcho>): ResponseEcho {
-    const message = createBaseResponseEcho();
-    message.message = object.message ?? "";
-    return message;
-  }
+        case 3:
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
+          break;
 
-};
+        case 4:
+          message.hash = reader.bytes();
+          break;
 
-function createBaseResponseFlush(): ResponseFlush {
-  return {};
-}
+        case 5:
+          message.height = (reader.int64() as Long);
+          break;
 
-export const ResponseFlush = {
-  encode(_: ResponseFlush, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    return writer;
-  },
+        case 6:
+          message.time = Timestamp.decode(reader, reader.uint32());
+          break;
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseFlush {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseFlush();
+        case 7:
+          message.nextValidatorsHash = reader.bytes();
+          break;
 
-    while (reader.pos < end) {
-      const tag = reader.uint32();
+        case 8:
+          message.proposerAddress = reader.bytes();
+          break;
 
-      switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
@@ -2607,84 +2504,148 @@ export const ResponseFlush = {
     return message;
   },
 
-  fromJSON(_: any): ResponseFlush {
-    return {};
+  fromJSON(object: any): RequestProcessProposal {
+    return {
+      txs: Array.isArray(object?.txs) ? object.txs.map((e: any) => bytesFromBase64(e)) : [],
+      proposedLastCommit: isSet(object.proposedLastCommit) ? CommitInfo.fromJSON(object.proposedLastCommit) : undefined,
+      misbehavior: Array.isArray(object?.misbehavior) ? object.misbehavior.map((e: any) => Misbehavior.fromJSON(e)) : [],
+      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
+      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
+      nextValidatorsHash: isSet(object.nextValidatorsHash) ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array(),
+      proposerAddress: isSet(object.proposerAddress) ? bytesFromBase64(object.proposerAddress) : new Uint8Array()
+    };
   },
 
-  toJSON(_: ResponseFlush): unknown {
+  toJSON(message: RequestProcessProposal): unknown {
     const obj: any = {};
+
+    if (message.txs) {
+      obj.txs = message.txs.map(e => base64FromBytes(e !== undefined ? e : new Uint8Array()));
+    } else {
+      obj.txs = [];
+    }
+
+    message.proposedLastCommit !== undefined && (obj.proposedLastCommit = message.proposedLastCommit ? CommitInfo.toJSON(message.proposedLastCommit) : undefined);
+
+    if (message.misbehavior) {
+      obj.misbehavior = message.misbehavior.map(e => e ? Misbehavior.toJSON(e) : undefined);
+    } else {
+      obj.misbehavior = [];
+    }
+
+    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
+    message.time !== undefined && (obj.time = fromTimestamp(message.time).toISOString());
+    message.nextValidatorsHash !== undefined && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== undefined ? message.nextValidatorsHash : new Uint8Array()));
+    message.proposerAddress !== undefined && (obj.proposerAddress = base64FromBytes(message.proposerAddress !== undefined ? message.proposerAddress : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(_: Partial<ResponseFlush>): ResponseFlush {
-    const message = createBaseResponseFlush();
+  fromPartial(object: Partial<RequestProcessProposal>): RequestProcessProposal {
+    const message = createBaseRequestProcessProposal();
+    message.txs = object.txs?.map(e => e) || [];
+    message.proposedLastCommit = object.proposedLastCommit !== undefined && object.proposedLastCommit !== null ? CommitInfo.fromPartial(object.proposedLastCommit) : undefined;
+    message.misbehavior = object.misbehavior?.map(e => Misbehavior.fromPartial(e)) || [];
+    message.hash = object.hash ?? new Uint8Array();
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
+    message.time = object.time !== undefined && object.time !== null ? Timestamp.fromPartial(object.time) : undefined;
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseInfo(): ResponseInfo {
+function createBaseRequestExtendVote(): RequestExtendVote {
   return {
-    data: "",
-    version: "",
-    appVersion: Long.UZERO,
-    lastBlockHeight: Long.ZERO,
-    lastBlockAppHash: new Uint8Array()
+    hash: new Uint8Array(),
+    height: Long.ZERO,
+    time: undefined,
+    txs: [],
+    proposedLastCommit: undefined,
+    misbehavior: [],
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array()
   };
 }
 
-export const ResponseInfo = {
-  encode(message: ResponseInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.data !== "") {
-      writer.uint32(10).string(message.data);
+export const RequestExtendVote = {
+  encode(message: RequestExtendVote, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash.length !== 0) {
+      writer.uint32(10).bytes(message.hash);
     }
 
-    if (message.version !== "") {
-      writer.uint32(18).string(message.version);
+    if (!message.height.isZero()) {
+      writer.uint32(16).int64(message.height);
     }
 
-    if (!message.appVersion.isZero()) {
-      writer.uint32(24).uint64(message.appVersion);
+    if (message.time !== undefined) {
+      Timestamp.encode(message.time, writer.uint32(26).fork()).ldelim();
     }
 
-    if (!message.lastBlockHeight.isZero()) {
-      writer.uint32(32).int64(message.lastBlockHeight);
+    for (const v of message.txs) {
+      writer.uint32(34).bytes(v!);
     }
 
-    if (message.lastBlockAppHash.length !== 0) {
-      writer.uint32(42).bytes(message.lastBlockAppHash);
+    if (message.proposedLastCommit !== undefined) {
+      CommitInfo.encode(message.proposedLastCommit, writer.uint32(42).fork()).ldelim();
+    }
+
+    for (const v of message.misbehavior) {
+      Misbehavior.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
+    if (message.nextValidatorsHash.length !== 0) {
+      writer.uint32(58).bytes(message.nextValidatorsHash);
+    }
+
+    if (message.proposerAddress.length !== 0) {
+      writer.uint32(66).bytes(message.proposerAddress);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseInfo {
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestExtendVote {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseInfo();
+    const message = createBaseRequestExtendVote();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.data = reader.string();
+          message.hash = reader.bytes();
           break;
 
         case 2:
-          message.version = reader.string();
+          message.height = (reader.int64() as Long);
           break;
 
         case 3:
-          message.appVersion = (reader.uint64() as Long);
+          message.time = Timestamp.decode(reader, reader.uint32());
           break;
 
         case 4:
-          message.lastBlockHeight = (reader.int64() as Long);
+          message.txs.push(reader.bytes());
           break;
 
         case 5:
-          message.lastBlockAppHash = reader.bytes();
+          message.proposedLastCommit = CommitInfo.decode(reader, reader.uint32());
+          break;
+
+        case 6:
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
+          break;
+
+        case 7:
+          message.nextValidatorsHash = reader.bytes();
+          break;
+
+        case 8:
+          message.proposerAddress = reader.bytes();
           break;
 
         default:
@@ -2696,82 +2657,112 @@ export const ResponseInfo = {
     return message;
   },
 
-  fromJSON(object: any): ResponseInfo {
+  fromJSON(object: any): RequestExtendVote {
     return {
-      data: isSet(object.data) ? String(object.data) : "",
-      version: isSet(object.version) ? String(object.version) : "",
-      appVersion: isSet(object.appVersion) ? Long.fromValue(object.appVersion) : Long.UZERO,
-      lastBlockHeight: isSet(object.lastBlockHeight) ? Long.fromValue(object.lastBlockHeight) : Long.ZERO,
-      lastBlockAppHash: isSet(object.lastBlockAppHash) ? bytesFromBase64(object.lastBlockAppHash) : new Uint8Array()
+      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
+      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
+      txs: Array.isArray(object?.txs) ? object.txs.map((e: any) => bytesFromBase64(e)) : [],
+      proposedLastCommit: isSet(object.proposedLastCommit) ? CommitInfo.fromJSON(object.proposedLastCommit) : undefined,
+      misbehavior: Array.isArray(object?.misbehavior) ? object.misbehavior.map((e: any) => Misbehavior.fromJSON(e)) : [],
+      nextValidatorsHash: isSet(object.nextValidatorsHash) ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array(),
+      proposerAddress: isSet(object.proposerAddress) ? bytesFromBase64(object.proposerAddress) : new Uint8Array()
     };
   },
 
-  toJSON(message: ResponseInfo): unknown {
+  toJSON(message: RequestExtendVote): unknown {
     const obj: any = {};
-    message.data !== undefined && (obj.data = message.data);
-    message.version !== undefined && (obj.version = message.version);
-    message.appVersion !== undefined && (obj.appVersion = (message.appVersion || Long.UZERO).toString());
-    message.lastBlockHeight !== undefined && (obj.lastBlockHeight = (message.lastBlockHeight || Long.ZERO).toString());
-    message.lastBlockAppHash !== undefined && (obj.lastBlockAppHash = base64FromBytes(message.lastBlockAppHash !== undefined ? message.lastBlockAppHash : new Uint8Array()));
+    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
+    message.time !== undefined && (obj.time = fromTimestamp(message.time).toISOString());
+
+    if (message.txs) {
+      obj.txs = message.txs.map(e => base64FromBytes(e !== undefined ? e : new Uint8Array()));
+    } else {
+      obj.txs = [];
+    }
+
+    message.proposedLastCommit !== undefined && (obj.proposedLastCommit = message.proposedLastCommit ? CommitInfo.toJSON(message.proposedLastCommit) : undefined);
+
+    if (message.misbehavior) {
+      obj.misbehavior = message.misbehavior.map(e => e ? Misbehavior.toJSON(e) : undefined);
+    } else {
+      obj.misbehavior = [];
+    }
+
+    message.nextValidatorsHash !== undefined && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== undefined ? message.nextValidatorsHash : new Uint8Array()));
+    message.proposerAddress !== undefined && (obj.proposerAddress = base64FromBytes(message.proposerAddress !== undefined ? message.proposerAddress : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseInfo>): ResponseInfo {
-    const message = createBaseResponseInfo();
-    message.data = object.data ?? "";
-    message.version = object.version ?? "";
-    message.appVersion = object.appVersion !== undefined && object.appVersion !== null ? Long.fromValue(object.appVersion) : Long.UZERO;
-    message.lastBlockHeight = object.lastBlockHeight !== undefined && object.lastBlockHeight !== null ? Long.fromValue(object.lastBlockHeight) : Long.ZERO;
-    message.lastBlockAppHash = object.lastBlockAppHash ?? new Uint8Array();
+  fromPartial(object: Partial<RequestExtendVote>): RequestExtendVote {
+    const message = createBaseRequestExtendVote();
+    message.hash = object.hash ?? new Uint8Array();
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
+    message.time = object.time !== undefined && object.time !== null ? Timestamp.fromPartial(object.time) : undefined;
+    message.txs = object.txs?.map(e => e) || [];
+    message.proposedLastCommit = object.proposedLastCommit !== undefined && object.proposedLastCommit !== null ? CommitInfo.fromPartial(object.proposedLastCommit) : undefined;
+    message.misbehavior = object.misbehavior?.map(e => Misbehavior.fromPartial(e)) || [];
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseSetOption(): ResponseSetOption {
+function createBaseRequestVerifyVoteExtension(): RequestVerifyVoteExtension {
   return {
-    code: 0,
-    log: "",
-    info: ""
+    hash: new Uint8Array(),
+    validatorAddress: new Uint8Array(),
+    height: Long.ZERO,
+    voteExtension: new Uint8Array()
   };
 }
 
-export const ResponseSetOption = {
-  encode(message: ResponseSetOption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.code !== 0) {
-      writer.uint32(8).uint32(message.code);
+export const RequestVerifyVoteExtension = {
+  encode(message: RequestVerifyVoteExtension, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash.length !== 0) {
+      writer.uint32(10).bytes(message.hash);
     }
 
-    if (message.log !== "") {
-      writer.uint32(26).string(message.log);
+    if (message.validatorAddress.length !== 0) {
+      writer.uint32(18).bytes(message.validatorAddress);
     }
 
-    if (message.info !== "") {
-      writer.uint32(34).string(message.info);
+    if (!message.height.isZero()) {
+      writer.uint32(24).int64(message.height);
+    }
+
+    if (message.voteExtension.length !== 0) {
+      writer.uint32(34).bytes(message.voteExtension);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseSetOption {
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestVerifyVoteExtension {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseSetOption();
+    const message = createBaseRequestVerifyVoteExtension();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.uint32();
+          message.hash = reader.bytes();
+          break;
+
+        case 2:
+          message.validatorAddress = reader.bytes();
           break;
 
         case 3:
-          message.log = reader.string();
+          message.height = (reader.int64() as Long);
           break;
 
         case 4:
-          message.info = reader.string();
+          message.voteExtension = reader.bytes();
           break;
 
         default:
@@ -2783,76 +2774,124 @@ export const ResponseSetOption = {
     return message;
   },
 
-  fromJSON(object: any): ResponseSetOption {
+  fromJSON(object: any): RequestVerifyVoteExtension {
     return {
-      code: isSet(object.code) ? Number(object.code) : 0,
-      log: isSet(object.log) ? String(object.log) : "",
-      info: isSet(object.info) ? String(object.info) : ""
+      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
+      validatorAddress: isSet(object.validatorAddress) ? bytesFromBase64(object.validatorAddress) : new Uint8Array(),
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
+      voteExtension: isSet(object.voteExtension) ? bytesFromBase64(object.voteExtension) : new Uint8Array()
     };
   },
 
-  toJSON(message: ResponseSetOption): unknown {
+  toJSON(message: RequestVerifyVoteExtension): unknown {
     const obj: any = {};
-    message.code !== undefined && (obj.code = Math.round(message.code));
-    message.log !== undefined && (obj.log = message.log);
-    message.info !== undefined && (obj.info = message.info);
+    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+    message.validatorAddress !== undefined && (obj.validatorAddress = base64FromBytes(message.validatorAddress !== undefined ? message.validatorAddress : new Uint8Array()));
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
+    message.voteExtension !== undefined && (obj.voteExtension = base64FromBytes(message.voteExtension !== undefined ? message.voteExtension : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseSetOption>): ResponseSetOption {
-    const message = createBaseResponseSetOption();
-    message.code = object.code ?? 0;
-    message.log = object.log ?? "";
-    message.info = object.info ?? "";
+  fromPartial(object: Partial<RequestVerifyVoteExtension>): RequestVerifyVoteExtension {
+    const message = createBaseRequestVerifyVoteExtension();
+    message.hash = object.hash ?? new Uint8Array();
+    message.validatorAddress = object.validatorAddress ?? new Uint8Array();
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
+    message.voteExtension = object.voteExtension ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseInitChain(): ResponseInitChain {
+function createBaseRequestFinalizeBlock(): RequestFinalizeBlock {
   return {
-    consensusParams: undefined,
-    validators: [],
-    appHash: new Uint8Array()
+    txs: [],
+    decidedLastCommit: undefined,
+    misbehavior: [],
+    hash: new Uint8Array(),
+    height: Long.ZERO,
+    time: undefined,
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array()
   };
 }
 
-export const ResponseInitChain = {
-  encode(message: ResponseInitChain, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.consensusParams !== undefined) {
-      ConsensusParams.encode(message.consensusParams, writer.uint32(10).fork()).ldelim();
+export const RequestFinalizeBlock = {
+  encode(message: RequestFinalizeBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.txs) {
+      writer.uint32(10).bytes(v!);
     }
 
-    for (const v of message.validators) {
-      ValidatorUpdate.encode(v!, writer.uint32(18).fork()).ldelim();
+    if (message.decidedLastCommit !== undefined) {
+      CommitInfo.encode(message.decidedLastCommit, writer.uint32(18).fork()).ldelim();
     }
 
-    if (message.appHash.length !== 0) {
-      writer.uint32(26).bytes(message.appHash);
+    for (const v of message.misbehavior) {
+      Misbehavior.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.hash.length !== 0) {
+      writer.uint32(34).bytes(message.hash);
+    }
+
+    if (!message.height.isZero()) {
+      writer.uint32(40).int64(message.height);
+    }
+
+    if (message.time !== undefined) {
+      Timestamp.encode(message.time, writer.uint32(50).fork()).ldelim();
+    }
+
+    if (message.nextValidatorsHash.length !== 0) {
+      writer.uint32(58).bytes(message.nextValidatorsHash);
+    }
+
+    if (message.proposerAddress.length !== 0) {
+      writer.uint32(66).bytes(message.proposerAddress);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseInitChain {
+  decode(input: _m0.Reader | Uint8Array, length?: number): RequestFinalizeBlock {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseInitChain();
+    const message = createBaseRequestFinalizeBlock();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.consensusParams = ConsensusParams.decode(reader, reader.uint32());
+          message.txs.push(reader.bytes());
           break;
 
         case 2:
-          message.validators.push(ValidatorUpdate.decode(reader, reader.uint32()));
+          message.decidedLastCommit = CommitInfo.decode(reader, reader.uint32());
           break;
 
         case 3:
-          message.appHash = reader.bytes();
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.hash = reader.bytes();
+          break;
+
+        case 5:
+          message.height = (reader.int64() as Long);
+          break;
+
+        case 6:
+          message.time = Timestamp.decode(reader, reader.uint32());
+          break;
+
+        case 7:
+          message.nextValidatorsHash = reader.bytes();
+          break;
+
+        case 8:
+          message.proposerAddress = reader.bytes();
           break;
 
         default:
@@ -2864,136 +2903,229 @@ export const ResponseInitChain = {
     return message;
   },
 
-  fromJSON(object: any): ResponseInitChain {
+  fromJSON(object: any): RequestFinalizeBlock {
     return {
-      consensusParams: isSet(object.consensusParams) ? ConsensusParams.fromJSON(object.consensusParams) : undefined,
-      validators: Array.isArray(object?.validators) ? object.validators.map((e: any) => ValidatorUpdate.fromJSON(e)) : [],
-      appHash: isSet(object.appHash) ? bytesFromBase64(object.appHash) : new Uint8Array()
+      txs: Array.isArray(object?.txs) ? object.txs.map((e: any) => bytesFromBase64(e)) : [],
+      decidedLastCommit: isSet(object.decidedLastCommit) ? CommitInfo.fromJSON(object.decidedLastCommit) : undefined,
+      misbehavior: Array.isArray(object?.misbehavior) ? object.misbehavior.map((e: any) => Misbehavior.fromJSON(e)) : [],
+      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array(),
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
+      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
+      nextValidatorsHash: isSet(object.nextValidatorsHash) ? bytesFromBase64(object.nextValidatorsHash) : new Uint8Array(),
+      proposerAddress: isSet(object.proposerAddress) ? bytesFromBase64(object.proposerAddress) : new Uint8Array()
     };
   },
 
-  toJSON(message: ResponseInitChain): unknown {
+  toJSON(message: RequestFinalizeBlock): unknown {
     const obj: any = {};
-    message.consensusParams !== undefined && (obj.consensusParams = message.consensusParams ? ConsensusParams.toJSON(message.consensusParams) : undefined);
 
-    if (message.validators) {
-      obj.validators = message.validators.map(e => e ? ValidatorUpdate.toJSON(e) : undefined);
+    if (message.txs) {
+      obj.txs = message.txs.map(e => base64FromBytes(e !== undefined ? e : new Uint8Array()));
     } else {
-      obj.validators = [];
+      obj.txs = [];
     }
 
-    message.appHash !== undefined && (obj.appHash = base64FromBytes(message.appHash !== undefined ? message.appHash : new Uint8Array()));
+    message.decidedLastCommit !== undefined && (obj.decidedLastCommit = message.decidedLastCommit ? CommitInfo.toJSON(message.decidedLastCommit) : undefined);
+
+    if (message.misbehavior) {
+      obj.misbehavior = message.misbehavior.map(e => e ? Misbehavior.toJSON(e) : undefined);
+    } else {
+      obj.misbehavior = [];
+    }
+
+    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
+    message.time !== undefined && (obj.time = fromTimestamp(message.time).toISOString());
+    message.nextValidatorsHash !== undefined && (obj.nextValidatorsHash = base64FromBytes(message.nextValidatorsHash !== undefined ? message.nextValidatorsHash : new Uint8Array()));
+    message.proposerAddress !== undefined && (obj.proposerAddress = base64FromBytes(message.proposerAddress !== undefined ? message.proposerAddress : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseInitChain>): ResponseInitChain {
-    const message = createBaseResponseInitChain();
-    message.consensusParams = object.consensusParams !== undefined && object.consensusParams !== null ? ConsensusParams.fromPartial(object.consensusParams) : undefined;
-    message.validators = object.validators?.map(e => ValidatorUpdate.fromPartial(e)) || [];
-    message.appHash = object.appHash ?? new Uint8Array();
+  fromPartial(object: Partial<RequestFinalizeBlock>): RequestFinalizeBlock {
+    const message = createBaseRequestFinalizeBlock();
+    message.txs = object.txs?.map(e => e) || [];
+    message.decidedLastCommit = object.decidedLastCommit !== undefined && object.decidedLastCommit !== null ? CommitInfo.fromPartial(object.decidedLastCommit) : undefined;
+    message.misbehavior = object.misbehavior?.map(e => Misbehavior.fromPartial(e)) || [];
+    message.hash = object.hash ?? new Uint8Array();
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
+    message.time = object.time !== undefined && object.time !== null ? Timestamp.fromPartial(object.time) : undefined;
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseQuery(): ResponseQuery {
+function createBaseResponse(): Response {
   return {
-    code: 0,
-    log: "",
-    info: "",
-    index: Long.ZERO,
-    key: new Uint8Array(),
-    value: new Uint8Array(),
-    proofOps: undefined,
-    height: Long.ZERO,
-    codespace: ""
+    exception: undefined,
+    echo: undefined,
+    flush: undefined,
+    info: undefined,
+    initChain: undefined,
+    query: undefined,
+    checkTx: undefined,
+    commit: undefined,
+    listSnapshots: undefined,
+    offerSnapshot: undefined,
+    loadSnapshotChunk: undefined,
+    applySnapshotChunk: undefined,
+    prepareProposal: undefined,
+    processProposal: undefined,
+    extendVote: undefined,
+    verifyVoteExtension: undefined,
+    finalizeBlock: undefined
   };
 }
 
-export const ResponseQuery = {
-  encode(message: ResponseQuery, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.code !== 0) {
-      writer.uint32(8).uint32(message.code);
+export const Response = {
+  encode(message: Response, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.exception !== undefined) {
+      ResponseException.encode(message.exception, writer.uint32(10).fork()).ldelim();
     }
 
-    if (message.log !== "") {
-      writer.uint32(26).string(message.log);
+    if (message.echo !== undefined) {
+      ResponseEcho.encode(message.echo, writer.uint32(18).fork()).ldelim();
     }
 
-    if (message.info !== "") {
-      writer.uint32(34).string(message.info);
+    if (message.flush !== undefined) {
+      ResponseFlush.encode(message.flush, writer.uint32(26).fork()).ldelim();
     }
 
-    if (!message.index.isZero()) {
-      writer.uint32(40).int64(message.index);
+    if (message.info !== undefined) {
+      ResponseInfo.encode(message.info, writer.uint32(34).fork()).ldelim();
     }
 
-    if (message.key.length !== 0) {
-      writer.uint32(50).bytes(message.key);
+    if (message.initChain !== undefined) {
+      ResponseInitChain.encode(message.initChain, writer.uint32(50).fork()).ldelim();
     }
 
-    if (message.value.length !== 0) {
-      writer.uint32(58).bytes(message.value);
+    if (message.query !== undefined) {
+      ResponseQuery.encode(message.query, writer.uint32(58).fork()).ldelim();
     }
 
-    if (message.proofOps !== undefined) {
-      ProofOps.encode(message.proofOps, writer.uint32(66).fork()).ldelim();
+    if (message.checkTx !== undefined) {
+      ResponseCheckTx.encode(message.checkTx, writer.uint32(74).fork()).ldelim();
     }
 
-    if (!message.height.isZero()) {
-      writer.uint32(72).int64(message.height);
+    if (message.commit !== undefined) {
+      ResponseCommit.encode(message.commit, writer.uint32(98).fork()).ldelim();
     }
 
-    if (message.codespace !== "") {
-      writer.uint32(82).string(message.codespace);
+    if (message.listSnapshots !== undefined) {
+      ResponseListSnapshots.encode(message.listSnapshots, writer.uint32(106).fork()).ldelim();
+    }
+
+    if (message.offerSnapshot !== undefined) {
+      ResponseOfferSnapshot.encode(message.offerSnapshot, writer.uint32(114).fork()).ldelim();
+    }
+
+    if (message.loadSnapshotChunk !== undefined) {
+      ResponseLoadSnapshotChunk.encode(message.loadSnapshotChunk, writer.uint32(122).fork()).ldelim();
+    }
+
+    if (message.applySnapshotChunk !== undefined) {
+      ResponseApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(130).fork()).ldelim();
+    }
+
+    if (message.prepareProposal !== undefined) {
+      ResponsePrepareProposal.encode(message.prepareProposal, writer.uint32(138).fork()).ldelim();
+    }
+
+    if (message.processProposal !== undefined) {
+      ResponseProcessProposal.encode(message.processProposal, writer.uint32(146).fork()).ldelim();
+    }
+
+    if (message.extendVote !== undefined) {
+      ResponseExtendVote.encode(message.extendVote, writer.uint32(154).fork()).ldelim();
+    }
+
+    if (message.verifyVoteExtension !== undefined) {
+      ResponseVerifyVoteExtension.encode(message.verifyVoteExtension, writer.uint32(162).fork()).ldelim();
+    }
+
+    if (message.finalizeBlock !== undefined) {
+      ResponseFinalizeBlock.encode(message.finalizeBlock, writer.uint32(170).fork()).ldelim();
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseQuery {
+  decode(input: _m0.Reader | Uint8Array, length?: number): Response {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseQuery();
+    const message = createBaseResponse();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.uint32();
+          message.exception = ResponseException.decode(reader, reader.uint32());
           break;
 
-        case 3:
-          message.log = reader.string();
+        case 2:
+          message.echo = ResponseEcho.decode(reader, reader.uint32());
           break;
 
-        case 4:
-          message.info = reader.string();
+        case 3:
+          message.flush = ResponseFlush.decode(reader, reader.uint32());
           break;
 
-        case 5:
-          message.index = (reader.int64() as Long);
+        case 4:
+          message.info = ResponseInfo.decode(reader, reader.uint32());
           break;
 
         case 6:
-          message.key = reader.bytes();
+          message.initChain = ResponseInitChain.decode(reader, reader.uint32());
           break;
 
         case 7:
-          message.value = reader.bytes();
+          message.query = ResponseQuery.decode(reader, reader.uint32());
           break;
 
-        case 8:
-          message.proofOps = ProofOps.decode(reader, reader.uint32());
+        case 9:
+          message.checkTx = ResponseCheckTx.decode(reader, reader.uint32());
           break;
 
-        case 9:
-          message.height = (reader.int64() as Long);
+        case 12:
+          message.commit = ResponseCommit.decode(reader, reader.uint32());
           break;
 
-        case 10:
-          message.codespace = reader.string();
+        case 13:
+          message.listSnapshots = ResponseListSnapshots.decode(reader, reader.uint32());
+          break;
+
+        case 14:
+          message.offerSnapshot = ResponseOfferSnapshot.decode(reader, reader.uint32());
+          break;
+
+        case 15:
+          message.loadSnapshotChunk = ResponseLoadSnapshotChunk.decode(reader, reader.uint32());
+          break;
+
+        case 16:
+          message.applySnapshotChunk = ResponseApplySnapshotChunk.decode(reader, reader.uint32());
+          break;
+
+        case 17:
+          message.prepareProposal = ResponsePrepareProposal.decode(reader, reader.uint32());
+          break;
+
+        case 18:
+          message.processProposal = ResponseProcessProposal.decode(reader, reader.uint32());
+          break;
+
+        case 19:
+          message.extendVote = ResponseExtendVote.decode(reader, reader.uint32());
+          break;
+
+        case 20:
+          message.verifyVoteExtension = ResponseVerifyVoteExtension.decode(reader, reader.uint32());
+          break;
+
+        case 21:
+          message.finalizeBlock = ResponseFinalizeBlock.decode(reader, reader.uint32());
           break;
 
         default:
@@ -3005,76 +3137,380 @@ export const ResponseQuery = {
     return message;
   },
 
-  fromJSON(object: any): ResponseQuery {
+  fromJSON(object: any): Response {
     return {
-      code: isSet(object.code) ? Number(object.code) : 0,
-      log: isSet(object.log) ? String(object.log) : "",
-      info: isSet(object.info) ? String(object.info) : "",
-      index: isSet(object.index) ? Long.fromValue(object.index) : Long.ZERO,
-      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
-      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(),
-      proofOps: isSet(object.proofOps) ? ProofOps.fromJSON(object.proofOps) : undefined,
-      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
-      codespace: isSet(object.codespace) ? String(object.codespace) : ""
+      exception: isSet(object.exception) ? ResponseException.fromJSON(object.exception) : undefined,
+      echo: isSet(object.echo) ? ResponseEcho.fromJSON(object.echo) : undefined,
+      flush: isSet(object.flush) ? ResponseFlush.fromJSON(object.flush) : undefined,
+      info: isSet(object.info) ? ResponseInfo.fromJSON(object.info) : undefined,
+      initChain: isSet(object.initChain) ? ResponseInitChain.fromJSON(object.initChain) : undefined,
+      query: isSet(object.query) ? ResponseQuery.fromJSON(object.query) : undefined,
+      checkTx: isSet(object.checkTx) ? ResponseCheckTx.fromJSON(object.checkTx) : undefined,
+      commit: isSet(object.commit) ? ResponseCommit.fromJSON(object.commit) : undefined,
+      listSnapshots: isSet(object.listSnapshots) ? ResponseListSnapshots.fromJSON(object.listSnapshots) : undefined,
+      offerSnapshot: isSet(object.offerSnapshot) ? ResponseOfferSnapshot.fromJSON(object.offerSnapshot) : undefined,
+      loadSnapshotChunk: isSet(object.loadSnapshotChunk) ? ResponseLoadSnapshotChunk.fromJSON(object.loadSnapshotChunk) : undefined,
+      applySnapshotChunk: isSet(object.applySnapshotChunk) ? ResponseApplySnapshotChunk.fromJSON(object.applySnapshotChunk) : undefined,
+      prepareProposal: isSet(object.prepareProposal) ? ResponsePrepareProposal.fromJSON(object.prepareProposal) : undefined,
+      processProposal: isSet(object.processProposal) ? ResponseProcessProposal.fromJSON(object.processProposal) : undefined,
+      extendVote: isSet(object.extendVote) ? ResponseExtendVote.fromJSON(object.extendVote) : undefined,
+      verifyVoteExtension: isSet(object.verifyVoteExtension) ? ResponseVerifyVoteExtension.fromJSON(object.verifyVoteExtension) : undefined,
+      finalizeBlock: isSet(object.finalizeBlock) ? ResponseFinalizeBlock.fromJSON(object.finalizeBlock) : undefined
     };
   },
 
-  toJSON(message: ResponseQuery): unknown {
+  toJSON(message: Response): unknown {
     const obj: any = {};
-    message.code !== undefined && (obj.code = Math.round(message.code));
-    message.log !== undefined && (obj.log = message.log);
-    message.info !== undefined && (obj.info = message.info);
-    message.index !== undefined && (obj.index = (message.index || Long.ZERO).toString());
-    message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
-    message.value !== undefined && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
-    message.proofOps !== undefined && (obj.proofOps = message.proofOps ? ProofOps.toJSON(message.proofOps) : undefined);
-    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
-    message.codespace !== undefined && (obj.codespace = message.codespace);
-    return obj;
-  },
-
-  fromPartial(object: Partial<ResponseQuery>): ResponseQuery {
-    const message = createBaseResponseQuery();
-    message.code = object.code ?? 0;
-    message.log = object.log ?? "";
-    message.info = object.info ?? "";
-    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.ZERO;
-    message.key = object.key ?? new Uint8Array();
-    message.value = object.value ?? new Uint8Array();
-    message.proofOps = object.proofOps !== undefined && object.proofOps !== null ? ProofOps.fromPartial(object.proofOps) : undefined;
-    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
-    message.codespace = object.codespace ?? "";
+    message.exception !== undefined && (obj.exception = message.exception ? ResponseException.toJSON(message.exception) : undefined);
+    message.echo !== undefined && (obj.echo = message.echo ? ResponseEcho.toJSON(message.echo) : undefined);
+    message.flush !== undefined && (obj.flush = message.flush ? ResponseFlush.toJSON(message.flush) : undefined);
+    message.info !== undefined && (obj.info = message.info ? ResponseInfo.toJSON(message.info) : undefined);
+    message.initChain !== undefined && (obj.initChain = message.initChain ? ResponseInitChain.toJSON(message.initChain) : undefined);
+    message.query !== undefined && (obj.query = message.query ? ResponseQuery.toJSON(message.query) : undefined);
+    message.checkTx !== undefined && (obj.checkTx = message.checkTx ? ResponseCheckTx.toJSON(message.checkTx) : undefined);
+    message.commit !== undefined && (obj.commit = message.commit ? ResponseCommit.toJSON(message.commit) : undefined);
+    message.listSnapshots !== undefined && (obj.listSnapshots = message.listSnapshots ? ResponseListSnapshots.toJSON(message.listSnapshots) : undefined);
+    message.offerSnapshot !== undefined && (obj.offerSnapshot = message.offerSnapshot ? ResponseOfferSnapshot.toJSON(message.offerSnapshot) : undefined);
+    message.loadSnapshotChunk !== undefined && (obj.loadSnapshotChunk = message.loadSnapshotChunk ? ResponseLoadSnapshotChunk.toJSON(message.loadSnapshotChunk) : undefined);
+    message.applySnapshotChunk !== undefined && (obj.applySnapshotChunk = message.applySnapshotChunk ? ResponseApplySnapshotChunk.toJSON(message.applySnapshotChunk) : undefined);
+    message.prepareProposal !== undefined && (obj.prepareProposal = message.prepareProposal ? ResponsePrepareProposal.toJSON(message.prepareProposal) : undefined);
+    message.processProposal !== undefined && (obj.processProposal = message.processProposal ? ResponseProcessProposal.toJSON(message.processProposal) : undefined);
+    message.extendVote !== undefined && (obj.extendVote = message.extendVote ? ResponseExtendVote.toJSON(message.extendVote) : undefined);
+    message.verifyVoteExtension !== undefined && (obj.verifyVoteExtension = message.verifyVoteExtension ? ResponseVerifyVoteExtension.toJSON(message.verifyVoteExtension) : undefined);
+    message.finalizeBlock !== undefined && (obj.finalizeBlock = message.finalizeBlock ? ResponseFinalizeBlock.toJSON(message.finalizeBlock) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: Partial<Response>): Response {
+    const message = createBaseResponse();
+    message.exception = object.exception !== undefined && object.exception !== null ? ResponseException.fromPartial(object.exception) : undefined;
+    message.echo = object.echo !== undefined && object.echo !== null ? ResponseEcho.fromPartial(object.echo) : undefined;
+    message.flush = object.flush !== undefined && object.flush !== null ? ResponseFlush.fromPartial(object.flush) : undefined;
+    message.info = object.info !== undefined && object.info !== null ? ResponseInfo.fromPartial(object.info) : undefined;
+    message.initChain = object.initChain !== undefined && object.initChain !== null ? ResponseInitChain.fromPartial(object.initChain) : undefined;
+    message.query = object.query !== undefined && object.query !== null ? ResponseQuery.fromPartial(object.query) : undefined;
+    message.checkTx = object.checkTx !== undefined && object.checkTx !== null ? ResponseCheckTx.fromPartial(object.checkTx) : undefined;
+    message.commit = object.commit !== undefined && object.commit !== null ? ResponseCommit.fromPartial(object.commit) : undefined;
+    message.listSnapshots = object.listSnapshots !== undefined && object.listSnapshots !== null ? ResponseListSnapshots.fromPartial(object.listSnapshots) : undefined;
+    message.offerSnapshot = object.offerSnapshot !== undefined && object.offerSnapshot !== null ? ResponseOfferSnapshot.fromPartial(object.offerSnapshot) : undefined;
+    message.loadSnapshotChunk = object.loadSnapshotChunk !== undefined && object.loadSnapshotChunk !== null ? ResponseLoadSnapshotChunk.fromPartial(object.loadSnapshotChunk) : undefined;
+    message.applySnapshotChunk = object.applySnapshotChunk !== undefined && object.applySnapshotChunk !== null ? ResponseApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : undefined;
+    message.prepareProposal = object.prepareProposal !== undefined && object.prepareProposal !== null ? ResponsePrepareProposal.fromPartial(object.prepareProposal) : undefined;
+    message.processProposal = object.processProposal !== undefined && object.processProposal !== null ? ResponseProcessProposal.fromPartial(object.processProposal) : undefined;
+    message.extendVote = object.extendVote !== undefined && object.extendVote !== null ? ResponseExtendVote.fromPartial(object.extendVote) : undefined;
+    message.verifyVoteExtension = object.verifyVoteExtension !== undefined && object.verifyVoteExtension !== null ? ResponseVerifyVoteExtension.fromPartial(object.verifyVoteExtension) : undefined;
+    message.finalizeBlock = object.finalizeBlock !== undefined && object.finalizeBlock !== null ? ResponseFinalizeBlock.fromPartial(object.finalizeBlock) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseResponseException(): ResponseException {
+  return {
+    error: ""
+  };
+}
+
+export const ResponseException = {
+  encode(message: ResponseException, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.error !== "") {
+      writer.uint32(10).string(message.error);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseException {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseException();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.error = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponseException {
+    return {
+      error: isSet(object.error) ? String(object.error) : ""
+    };
+  },
+
+  toJSON(message: ResponseException): unknown {
+    const obj: any = {};
+    message.error !== undefined && (obj.error = message.error);
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseException>): ResponseException {
+    const message = createBaseResponseException();
+    message.error = object.error ?? "";
+    return message;
+  }
+
+};
+
+function createBaseResponseEcho(): ResponseEcho {
+  return {
+    message: ""
+  };
+}
+
+export const ResponseEcho = {
+  encode(message: ResponseEcho, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseEcho {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseEcho();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.message = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponseEcho {
+    return {
+      message: isSet(object.message) ? String(object.message) : ""
+    };
+  },
+
+  toJSON(message: ResponseEcho): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseEcho>): ResponseEcho {
+    const message = createBaseResponseEcho();
+    message.message = object.message ?? "";
+    return message;
+  }
+
+};
+
+function createBaseResponseFlush(): ResponseFlush {
+  return {};
+}
+
+export const ResponseFlush = {
+  encode(_: ResponseFlush, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseFlush {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseFlush();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(_: any): ResponseFlush {
+    return {};
+  },
+
+  toJSON(_: ResponseFlush): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial(_: Partial<ResponseFlush>): ResponseFlush {
+    const message = createBaseResponseFlush();
+    return message;
+  }
+
+};
+
+function createBaseResponseInfo(): ResponseInfo {
+  return {
+    data: "",
+    version: "",
+    appVersion: Long.UZERO,
+    lastBlockHeight: Long.ZERO,
+    lastBlockAppHash: new Uint8Array()
+  };
+}
+
+export const ResponseInfo = {
+  encode(message: ResponseInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.data !== "") {
+      writer.uint32(10).string(message.data);
+    }
+
+    if (message.version !== "") {
+      writer.uint32(18).string(message.version);
+    }
+
+    if (!message.appVersion.isZero()) {
+      writer.uint32(24).uint64(message.appVersion);
+    }
+
+    if (!message.lastBlockHeight.isZero()) {
+      writer.uint32(32).int64(message.lastBlockHeight);
+    }
+
+    if (message.lastBlockAppHash.length !== 0) {
+      writer.uint32(42).bytes(message.lastBlockAppHash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.string();
+          break;
+
+        case 2:
+          message.version = reader.string();
+          break;
+
+        case 3:
+          message.appVersion = (reader.uint64() as Long);
+          break;
+
+        case 4:
+          message.lastBlockHeight = (reader.int64() as Long);
+          break;
+
+        case 5:
+          message.lastBlockAppHash = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponseInfo {
+    return {
+      data: isSet(object.data) ? String(object.data) : "",
+      version: isSet(object.version) ? String(object.version) : "",
+      appVersion: isSet(object.appVersion) ? Long.fromValue(object.appVersion) : Long.UZERO,
+      lastBlockHeight: isSet(object.lastBlockHeight) ? Long.fromValue(object.lastBlockHeight) : Long.ZERO,
+      lastBlockAppHash: isSet(object.lastBlockAppHash) ? bytesFromBase64(object.lastBlockAppHash) : new Uint8Array()
+    };
+  },
+
+  toJSON(message: ResponseInfo): unknown {
+    const obj: any = {};
+    message.data !== undefined && (obj.data = message.data);
+    message.version !== undefined && (obj.version = message.version);
+    message.appVersion !== undefined && (obj.appVersion = (message.appVersion || Long.UZERO).toString());
+    message.lastBlockHeight !== undefined && (obj.lastBlockHeight = (message.lastBlockHeight || Long.ZERO).toString());
+    message.lastBlockAppHash !== undefined && (obj.lastBlockAppHash = base64FromBytes(message.lastBlockAppHash !== undefined ? message.lastBlockAppHash : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseInfo>): ResponseInfo {
+    const message = createBaseResponseInfo();
+    message.data = object.data ?? "";
+    message.version = object.version ?? "";
+    message.appVersion = object.appVersion !== undefined && object.appVersion !== null ? Long.fromValue(object.appVersion) : Long.UZERO;
+    message.lastBlockHeight = object.lastBlockHeight !== undefined && object.lastBlockHeight !== null ? Long.fromValue(object.lastBlockHeight) : Long.ZERO;
+    message.lastBlockAppHash = object.lastBlockAppHash ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseBeginBlock(): ResponseBeginBlock {
+function createBaseResponseInitChain(): ResponseInitChain {
   return {
-    events: []
+    consensusParams: undefined,
+    validators: [],
+    appHash: new Uint8Array()
   };
 }
 
-export const ResponseBeginBlock = {
-  encode(message: ResponseBeginBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.events) {
-      Event.encode(v!, writer.uint32(10).fork()).ldelim();
+export const ResponseInitChain = {
+  encode(message: ResponseInitChain, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.consensusParams !== undefined) {
+      ConsensusParams.encode(message.consensusParams, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.validators) {
+      ValidatorUpdate.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.appHash.length !== 0) {
+      writer.uint32(26).bytes(message.appHash);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseBeginBlock {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseInitChain {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseBeginBlock();
+    const message = createBaseResponseInitChain();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.events.push(Event.decode(reader, reader.uint32()));
+          message.consensusParams = ConsensusParams.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.validators.push(ValidatorUpdate.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.appHash = reader.bytes();
           break;
 
         default:
@@ -3086,55 +3522,58 @@ export const ResponseBeginBlock = {
     return message;
   },
 
-  fromJSON(object: any): ResponseBeginBlock {
+  fromJSON(object: any): ResponseInitChain {
     return {
-      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : []
+      consensusParams: isSet(object.consensusParams) ? ConsensusParams.fromJSON(object.consensusParams) : undefined,
+      validators: Array.isArray(object?.validators) ? object.validators.map((e: any) => ValidatorUpdate.fromJSON(e)) : [],
+      appHash: isSet(object.appHash) ? bytesFromBase64(object.appHash) : new Uint8Array()
     };
   },
 
-  toJSON(message: ResponseBeginBlock): unknown {
+  toJSON(message: ResponseInitChain): unknown {
     const obj: any = {};
+    message.consensusParams !== undefined && (obj.consensusParams = message.consensusParams ? ConsensusParams.toJSON(message.consensusParams) : undefined);
 
-    if (message.events) {
-      obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
+    if (message.validators) {
+      obj.validators = message.validators.map(e => e ? ValidatorUpdate.toJSON(e) : undefined);
     } else {
-      obj.events = [];
+      obj.validators = [];
     }
 
+    message.appHash !== undefined && (obj.appHash = base64FromBytes(message.appHash !== undefined ? message.appHash : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseBeginBlock>): ResponseBeginBlock {
-    const message = createBaseResponseBeginBlock();
-    message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+  fromPartial(object: Partial<ResponseInitChain>): ResponseInitChain {
+    const message = createBaseResponseInitChain();
+    message.consensusParams = object.consensusParams !== undefined && object.consensusParams !== null ? ConsensusParams.fromPartial(object.consensusParams) : undefined;
+    message.validators = object.validators?.map(e => ValidatorUpdate.fromPartial(e)) || [];
+    message.appHash = object.appHash ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseResponseCheckTx(): ResponseCheckTx {
+function createBaseResponseQuery(): ResponseQuery {
   return {
     code: 0,
-    data: new Uint8Array(),
     log: "",
     info: "",
-    gasWanted: Long.ZERO,
-    gasUsed: Long.ZERO,
-    events: [],
+    index: Long.ZERO,
+    key: new Uint8Array(),
+    value: new Uint8Array(),
+    proofOps: undefined,
+    height: Long.ZERO,
     codespace: ""
   };
 }
 
-export const ResponseCheckTx = {
-  encode(message: ResponseCheckTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ResponseQuery = {
+  encode(message: ResponseQuery, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.code !== 0) {
       writer.uint32(8).uint32(message.code);
     }
 
-    if (message.data.length !== 0) {
-      writer.uint32(18).bytes(message.data);
-    }
-
     if (message.log !== "") {
       writer.uint32(26).string(message.log);
     }
@@ -3143,29 +3582,37 @@ export const ResponseCheckTx = {
       writer.uint32(34).string(message.info);
     }
 
-    if (!message.gasWanted.isZero()) {
-      writer.uint32(40).int64(message.gasWanted);
+    if (!message.index.isZero()) {
+      writer.uint32(40).int64(message.index);
     }
 
-    if (!message.gasUsed.isZero()) {
-      writer.uint32(48).int64(message.gasUsed);
+    if (message.key.length !== 0) {
+      writer.uint32(50).bytes(message.key);
     }
 
-    for (const v of message.events) {
-      Event.encode(v!, writer.uint32(58).fork()).ldelim();
+    if (message.value.length !== 0) {
+      writer.uint32(58).bytes(message.value);
+    }
+
+    if (message.proofOps !== undefined) {
+      ProofOps.encode(message.proofOps, writer.uint32(66).fork()).ldelim();
+    }
+
+    if (!message.height.isZero()) {
+      writer.uint32(72).int64(message.height);
     }
 
     if (message.codespace !== "") {
-      writer.uint32(66).string(message.codespace);
+      writer.uint32(82).string(message.codespace);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseCheckTx {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseQuery {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseCheckTx();
+    const message = createBaseResponseQuery();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -3175,10 +3622,6 @@ export const ResponseCheckTx = {
           message.code = reader.uint32();
           break;
 
-        case 2:
-          message.data = reader.bytes();
-          break;
-
         case 3:
           message.log = reader.string();
           break;
@@ -3188,18 +3631,26 @@ export const ResponseCheckTx = {
           break;
 
         case 5:
-          message.gasWanted = (reader.int64() as Long);
+          message.index = (reader.int64() as Long);
           break;
 
         case 6:
-          message.gasUsed = (reader.int64() as Long);
+          message.key = reader.bytes();
           break;
 
         case 7:
-          message.events.push(Event.decode(reader, reader.uint32()));
+          message.value = reader.bytes();
           break;
 
         case 8:
+          message.proofOps = ProofOps.decode(reader, reader.uint32());
+          break;
+
+        case 9:
+          message.height = (reader.int64() as Long);
+          break;
+
+        case 10:
           message.codespace = reader.string();
           break;
 
@@ -3212,54 +3663,51 @@ export const ResponseCheckTx = {
     return message;
   },
 
-  fromJSON(object: any): ResponseCheckTx {
+  fromJSON(object: any): ResponseQuery {
     return {
       code: isSet(object.code) ? Number(object.code) : 0,
-      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
       log: isSet(object.log) ? String(object.log) : "",
       info: isSet(object.info) ? String(object.info) : "",
-      gasWanted: isSet(object.gas_wanted) ? Long.fromValue(object.gas_wanted) : Long.ZERO,
-      gasUsed: isSet(object.gas_used) ? Long.fromValue(object.gas_used) : Long.ZERO,
-      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : [],
+      index: isSet(object.index) ? Long.fromValue(object.index) : Long.ZERO,
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
+      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(),
+      proofOps: isSet(object.proofOps) ? ProofOps.fromJSON(object.proofOps) : undefined,
+      height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
       codespace: isSet(object.codespace) ? String(object.codespace) : ""
     };
   },
 
-  toJSON(message: ResponseCheckTx): unknown {
+  toJSON(message: ResponseQuery): unknown {
     const obj: any = {};
     message.code !== undefined && (obj.code = Math.round(message.code));
-    message.data !== undefined && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
     message.log !== undefined && (obj.log = message.log);
     message.info !== undefined && (obj.info = message.info);
-    message.gasWanted !== undefined && (obj.gas_wanted = (message.gasWanted || Long.ZERO).toString());
-    message.gasUsed !== undefined && (obj.gas_used = (message.gasUsed || Long.ZERO).toString());
-
-    if (message.events) {
-      obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
-    } else {
-      obj.events = [];
-    }
-
+    message.index !== undefined && (obj.index = (message.index || Long.ZERO).toString());
+    message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+    message.value !== undefined && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
+    message.proofOps !== undefined && (obj.proofOps = message.proofOps ? ProofOps.toJSON(message.proofOps) : undefined);
+    message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
     message.codespace !== undefined && (obj.codespace = message.codespace);
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseCheckTx>): ResponseCheckTx {
-    const message = createBaseResponseCheckTx();
+  fromPartial(object: Partial<ResponseQuery>): ResponseQuery {
+    const message = createBaseResponseQuery();
     message.code = object.code ?? 0;
-    message.data = object.data ?? new Uint8Array();
     message.log = object.log ?? "";
     message.info = object.info ?? "";
-    message.gasWanted = object.gasWanted !== undefined && object.gasWanted !== null ? Long.fromValue(object.gasWanted) : Long.ZERO;
-    message.gasUsed = object.gasUsed !== undefined && object.gasUsed !== null ? Long.fromValue(object.gasUsed) : Long.ZERO;
-    message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.ZERO;
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    message.proofOps = object.proofOps !== undefined && object.proofOps !== null ? ProofOps.fromPartial(object.proofOps) : undefined;
+    message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
     message.codespace = object.codespace ?? "";
     return message;
   }
 
 };
 
-function createBaseResponseDeliverTx(): ResponseDeliverTx {
+function createBaseResponseCheckTx(): ResponseCheckTx {
   return {
     code: 0,
     data: new Uint8Array(),
@@ -3272,8 +3720,8 @@ function createBaseResponseDeliverTx(): ResponseDeliverTx {
   };
 }
 
-export const ResponseDeliverTx = {
-  encode(message: ResponseDeliverTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ResponseCheckTx = {
+  encode(message: ResponseCheckTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.code !== 0) {
       writer.uint32(8).uint32(message.code);
     }
@@ -3309,10 +3757,10 @@ export const ResponseDeliverTx = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseDeliverTx {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseCheckTx {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseDeliverTx();
+    const message = createBaseResponseCheckTx();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -3359,126 +3807,27 @@ export const ResponseDeliverTx = {
     return message;
   },
 
-  fromJSON(object: any): ResponseDeliverTx {
+  fromJSON(object: any): ResponseCheckTx {
     return {
       code: isSet(object.code) ? Number(object.code) : 0,
-      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
-      log: isSet(object.log) ? String(object.log) : "",
-      info: isSet(object.info) ? String(object.info) : "",
-      gasWanted: isSet(object.gas_wanted) ? Long.fromValue(object.gas_wanted) : Long.ZERO,
-      gasUsed: isSet(object.gas_used) ? Long.fromValue(object.gas_used) : Long.ZERO,
-      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : [],
-      codespace: isSet(object.codespace) ? String(object.codespace) : ""
-    };
-  },
-
-  toJSON(message: ResponseDeliverTx): unknown {
-    const obj: any = {};
-    message.code !== undefined && (obj.code = Math.round(message.code));
-    message.data !== undefined && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
-    message.log !== undefined && (obj.log = message.log);
-    message.info !== undefined && (obj.info = message.info);
-    message.gasWanted !== undefined && (obj.gas_wanted = (message.gasWanted || Long.ZERO).toString());
-    message.gasUsed !== undefined && (obj.gas_used = (message.gasUsed || Long.ZERO).toString());
-
-    if (message.events) {
-      obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
-    } else {
-      obj.events = [];
-    }
-
-    message.codespace !== undefined && (obj.codespace = message.codespace);
-    return obj;
-  },
-
-  fromPartial(object: Partial<ResponseDeliverTx>): ResponseDeliverTx {
-    const message = createBaseResponseDeliverTx();
-    message.code = object.code ?? 0;
-    message.data = object.data ?? new Uint8Array();
-    message.log = object.log ?? "";
-    message.info = object.info ?? "";
-    message.gasWanted = object.gasWanted !== undefined && object.gasWanted !== null ? Long.fromValue(object.gasWanted) : Long.ZERO;
-    message.gasUsed = object.gasUsed !== undefined && object.gasUsed !== null ? Long.fromValue(object.gasUsed) : Long.ZERO;
-    message.events = object.events?.map(e => Event.fromPartial(e)) || [];
-    message.codespace = object.codespace ?? "";
-    return message;
-  }
-
-};
-
-function createBaseResponseEndBlock(): ResponseEndBlock {
-  return {
-    validatorUpdates: [],
-    consensusParamUpdates: undefined,
-    events: []
-  };
-}
-
-export const ResponseEndBlock = {
-  encode(message: ResponseEndBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.validatorUpdates) {
-      ValidatorUpdate.encode(v!, writer.uint32(10).fork()).ldelim();
-    }
-
-    if (message.consensusParamUpdates !== undefined) {
-      ConsensusParams.encode(message.consensusParamUpdates, writer.uint32(18).fork()).ldelim();
-    }
-
-    for (const v of message.events) {
-      Event.encode(v!, writer.uint32(26).fork()).ldelim();
-    }
-
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseEndBlock {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseEndBlock();
-
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-
-      switch (tag >>> 3) {
-        case 1:
-          message.validatorUpdates.push(ValidatorUpdate.decode(reader, reader.uint32()));
-          break;
-
-        case 2:
-          message.consensusParamUpdates = ConsensusParams.decode(reader, reader.uint32());
-          break;
-
-        case 3:
-          message.events.push(Event.decode(reader, reader.uint32()));
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  },
-
-  fromJSON(object: any): ResponseEndBlock {
-    return {
-      validatorUpdates: Array.isArray(object?.validatorUpdates) ? object.validatorUpdates.map((e: any) => ValidatorUpdate.fromJSON(e)) : [],
-      consensusParamUpdates: isSet(object.consensusParamUpdates) ? ConsensusParams.fromJSON(object.consensusParamUpdates) : undefined,
-      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : []
+      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+      log: isSet(object.log) ? String(object.log) : "",
+      info: isSet(object.info) ? String(object.info) : "",
+      gasWanted: isSet(object.gas_wanted) ? Long.fromValue(object.gas_wanted) : Long.ZERO,
+      gasUsed: isSet(object.gas_used) ? Long.fromValue(object.gas_used) : Long.ZERO,
+      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : [],
+      codespace: isSet(object.codespace) ? String(object.codespace) : ""
     };
   },
 
-  toJSON(message: ResponseEndBlock): unknown {
+  toJSON(message: ResponseCheckTx): unknown {
     const obj: any = {};
-
-    if (message.validatorUpdates) {
-      obj.validatorUpdates = message.validatorUpdates.map(e => e ? ValidatorUpdate.toJSON(e) : undefined);
-    } else {
-      obj.validatorUpdates = [];
-    }
-
-    message.consensusParamUpdates !== undefined && (obj.consensusParamUpdates = message.consensusParamUpdates ? ConsensusParams.toJSON(message.consensusParamUpdates) : undefined);
+    message.code !== undefined && (obj.code = Math.round(message.code));
+    message.data !== undefined && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+    message.log !== undefined && (obj.log = message.log);
+    message.info !== undefined && (obj.info = message.info);
+    message.gasWanted !== undefined && (obj.gas_wanted = (message.gasWanted || Long.ZERO).toString());
+    message.gasUsed !== undefined && (obj.gas_used = (message.gasUsed || Long.ZERO).toString());
 
     if (message.events) {
       obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
@@ -3486,14 +3835,20 @@ export const ResponseEndBlock = {
       obj.events = [];
     }
 
+    message.codespace !== undefined && (obj.codespace = message.codespace);
     return obj;
   },
 
-  fromPartial(object: Partial<ResponseEndBlock>): ResponseEndBlock {
-    const message = createBaseResponseEndBlock();
-    message.validatorUpdates = object.validatorUpdates?.map(e => ValidatorUpdate.fromPartial(e)) || [];
-    message.consensusParamUpdates = object.consensusParamUpdates !== undefined && object.consensusParamUpdates !== null ? ConsensusParams.fromPartial(object.consensusParamUpdates) : undefined;
+  fromPartial(object: Partial<ResponseCheckTx>): ResponseCheckTx {
+    const message = createBaseResponseCheckTx();
+    message.code = object.code ?? 0;
+    message.data = object.data ?? new Uint8Array();
+    message.log = object.log ?? "";
+    message.info = object.info ?? "";
+    message.gasWanted = object.gasWanted !== undefined && object.gasWanted !== null ? Long.fromValue(object.gasWanted) : Long.ZERO;
+    message.gasUsed = object.gasUsed !== undefined && object.gasUsed !== null ? Long.fromValue(object.gasUsed) : Long.ZERO;
     message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+    message.codespace = object.codespace ?? "";
     return message;
   }
 
@@ -3501,17 +3856,12 @@ export const ResponseEndBlock = {
 
 function createBaseResponseCommit(): ResponseCommit {
   return {
-    data: new Uint8Array(),
     retainHeight: Long.ZERO
   };
 }
 
 export const ResponseCommit = {
   encode(message: ResponseCommit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.data.length !== 0) {
-      writer.uint32(18).bytes(message.data);
-    }
-
     if (!message.retainHeight.isZero()) {
       writer.uint32(24).int64(message.retainHeight);
     }
@@ -3528,10 +3878,6 @@ export const ResponseCommit = {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
-        case 2:
-          message.data = reader.bytes();
-          break;
-
         case 3:
           message.retainHeight = (reader.int64() as Long);
           break;
@@ -3547,21 +3893,18 @@ export const ResponseCommit = {
 
   fromJSON(object: any): ResponseCommit {
     return {
-      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
       retainHeight: isSet(object.retainHeight) ? Long.fromValue(object.retainHeight) : Long.ZERO
     };
   },
 
   toJSON(message: ResponseCommit): unknown {
     const obj: any = {};
-    message.data !== undefined && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
     message.retainHeight !== undefined && (obj.retainHeight = (message.retainHeight || Long.ZERO).toString());
     return obj;
   },
 
   fromPartial(object: Partial<ResponseCommit>): ResponseCommit {
     const message = createBaseResponseCommit();
-    message.data = object.data ?? new Uint8Array();
     message.retainHeight = object.retainHeight !== undefined && object.retainHeight !== null ? Long.fromValue(object.retainHeight) : Long.ZERO;
     return message;
   }
@@ -3850,59 +4193,302 @@ export const ResponseApplySnapshotChunk = {
 
 };
 
-function createBaseConsensusParams(): ConsensusParams {
+function createBaseResponsePrepareProposal(): ResponsePrepareProposal {
   return {
-    block: undefined,
-    evidence: undefined,
-    validator: undefined,
-    version: undefined
+    txs: []
+  };
+}
+
+export const ResponsePrepareProposal = {
+  encode(message: ResponsePrepareProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.txs) {
+      writer.uint32(10).bytes(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponsePrepareProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponsePrepareProposal();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.txs.push(reader.bytes());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponsePrepareProposal {
+    return {
+      txs: Array.isArray(object?.txs) ? object.txs.map((e: any) => bytesFromBase64(e)) : []
+    };
+  },
+
+  toJSON(message: ResponsePrepareProposal): unknown {
+    const obj: any = {};
+
+    if (message.txs) {
+      obj.txs = message.txs.map(e => base64FromBytes(e !== undefined ? e : new Uint8Array()));
+    } else {
+      obj.txs = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponsePrepareProposal>): ResponsePrepareProposal {
+    const message = createBaseResponsePrepareProposal();
+    message.txs = object.txs?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseResponseProcessProposal(): ResponseProcessProposal {
+  return {
+    status: 0
   };
 }
 
-export const ConsensusParams = {
-  encode(message: ConsensusParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.block !== undefined) {
-      BlockParams.encode(message.block, writer.uint32(10).fork()).ldelim();
+export const ResponseProcessProposal = {
+  encode(message: ResponseProcessProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
     }
 
-    if (message.evidence !== undefined) {
-      EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseProcessProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseProcessProposal();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.status = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
     }
 
-    if (message.validator !== undefined) {
-      ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
+    return message;
+  },
+
+  fromJSON(object: any): ResponseProcessProposal {
+    return {
+      status: isSet(object.status) ? responseProcessProposal_ProposalStatusFromJSON(object.status) : 0
+    };
+  },
+
+  toJSON(message: ResponseProcessProposal): unknown {
+    const obj: any = {};
+    message.status !== undefined && (obj.status = responseProcessProposal_ProposalStatusToJSON(message.status));
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseProcessProposal>): ResponseProcessProposal {
+    const message = createBaseResponseProcessProposal();
+    message.status = object.status ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseResponseExtendVote(): ResponseExtendVote {
+  return {
+    voteExtension: new Uint8Array()
+  };
+}
+
+export const ResponseExtendVote = {
+  encode(message: ResponseExtendVote, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.voteExtension.length !== 0) {
+      writer.uint32(10).bytes(message.voteExtension);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseExtendVote {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseExtendVote();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.voteExtension = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponseExtendVote {
+    return {
+      voteExtension: isSet(object.voteExtension) ? bytesFromBase64(object.voteExtension) : new Uint8Array()
+    };
+  },
+
+  toJSON(message: ResponseExtendVote): unknown {
+    const obj: any = {};
+    message.voteExtension !== undefined && (obj.voteExtension = base64FromBytes(message.voteExtension !== undefined ? message.voteExtension : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseExtendVote>): ResponseExtendVote {
+    const message = createBaseResponseExtendVote();
+    message.voteExtension = object.voteExtension ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseResponseVerifyVoteExtension(): ResponseVerifyVoteExtension {
+  return {
+    status: 0
+  };
+}
+
+export const ResponseVerifyVoteExtension = {
+  encode(message: ResponseVerifyVoteExtension, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseVerifyVoteExtension {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResponseVerifyVoteExtension();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.status = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ResponseVerifyVoteExtension {
+    return {
+      status: isSet(object.status) ? responseVerifyVoteExtension_VerifyStatusFromJSON(object.status) : 0
+    };
+  },
+
+  toJSON(message: ResponseVerifyVoteExtension): unknown {
+    const obj: any = {};
+    message.status !== undefined && (obj.status = responseVerifyVoteExtension_VerifyStatusToJSON(message.status));
+    return obj;
+  },
+
+  fromPartial(object: Partial<ResponseVerifyVoteExtension>): ResponseVerifyVoteExtension {
+    const message = createBaseResponseVerifyVoteExtension();
+    message.status = object.status ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseResponseFinalizeBlock(): ResponseFinalizeBlock {
+  return {
+    events: [],
+    txResults: [],
+    validatorUpdates: [],
+    consensusParamUpdates: undefined,
+    appHash: new Uint8Array()
+  };
+}
+
+export const ResponseFinalizeBlock = {
+  encode(message: ResponseFinalizeBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.events) {
+      Event.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.txResults) {
+      ExecTxResult.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.validatorUpdates) {
+      ValidatorUpdate.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.consensusParamUpdates !== undefined) {
+      ConsensusParams.encode(message.consensusParamUpdates, writer.uint32(34).fork()).ldelim();
     }
 
-    if (message.version !== undefined) {
-      VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
+    if (message.appHash.length !== 0) {
+      writer.uint32(42).bytes(message.appHash);
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusParams {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseFinalizeBlock {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseConsensusParams();
+    const message = createBaseResponseFinalizeBlock();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.block = BlockParams.decode(reader, reader.uint32());
+          message.events.push(Event.decode(reader, reader.uint32()));
           break;
 
         case 2:
-          message.evidence = EvidenceParams.decode(reader, reader.uint32());
+          message.txResults.push(ExecTxResult.decode(reader, reader.uint32()));
           break;
 
         case 3:
-          message.validator = ValidatorParams.decode(reader, reader.uint32());
+          message.validatorUpdates.push(ValidatorUpdate.decode(reader, reader.uint32()));
           break;
 
         case 4:
-          message.version = VersionParams.decode(reader, reader.uint32());
+          message.consensusParamUpdates = ConsensusParams.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.appHash = reader.bytes();
           break;
 
         default:
@@ -3914,70 +4500,89 @@ export const ConsensusParams = {
     return message;
   },
 
-  fromJSON(object: any): ConsensusParams {
+  fromJSON(object: any): ResponseFinalizeBlock {
     return {
-      block: isSet(object.block) ? BlockParams.fromJSON(object.block) : undefined,
-      evidence: isSet(object.evidence) ? EvidenceParams.fromJSON(object.evidence) : undefined,
-      validator: isSet(object.validator) ? ValidatorParams.fromJSON(object.validator) : undefined,
-      version: isSet(object.version) ? VersionParams.fromJSON(object.version) : undefined
+      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : [],
+      txResults: Array.isArray(object?.txResults) ? object.txResults.map((e: any) => ExecTxResult.fromJSON(e)) : [],
+      validatorUpdates: Array.isArray(object?.validatorUpdates) ? object.validatorUpdates.map((e: any) => ValidatorUpdate.fromJSON(e)) : [],
+      consensusParamUpdates: isSet(object.consensusParamUpdates) ? ConsensusParams.fromJSON(object.consensusParamUpdates) : undefined,
+      appHash: isSet(object.appHash) ? bytesFromBase64(object.appHash) : new Uint8Array()
     };
   },
 
-  toJSON(message: ConsensusParams): unknown {
+  toJSON(message: ResponseFinalizeBlock): unknown {
     const obj: any = {};
-    message.block !== undefined && (obj.block = message.block ? BlockParams.toJSON(message.block) : undefined);
-    message.evidence !== undefined && (obj.evidence = message.evidence ? EvidenceParams.toJSON(message.evidence) : undefined);
-    message.validator !== undefined && (obj.validator = message.validator ? ValidatorParams.toJSON(message.validator) : undefined);
-    message.version !== undefined && (obj.version = message.version ? VersionParams.toJSON(message.version) : undefined);
+
+    if (message.events) {
+      obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
+    } else {
+      obj.events = [];
+    }
+
+    if (message.txResults) {
+      obj.txResults = message.txResults.map(e => e ? ExecTxResult.toJSON(e) : undefined);
+    } else {
+      obj.txResults = [];
+    }
+
+    if (message.validatorUpdates) {
+      obj.validatorUpdates = message.validatorUpdates.map(e => e ? ValidatorUpdate.toJSON(e) : undefined);
+    } else {
+      obj.validatorUpdates = [];
+    }
+
+    message.consensusParamUpdates !== undefined && (obj.consensusParamUpdates = message.consensusParamUpdates ? ConsensusParams.toJSON(message.consensusParamUpdates) : undefined);
+    message.appHash !== undefined && (obj.appHash = base64FromBytes(message.appHash !== undefined ? message.appHash : new Uint8Array()));
     return obj;
   },
 
-  fromPartial(object: Partial<ConsensusParams>): ConsensusParams {
-    const message = createBaseConsensusParams();
-    message.block = object.block !== undefined && object.block !== null ? BlockParams.fromPartial(object.block) : undefined;
-    message.evidence = object.evidence !== undefined && object.evidence !== null ? EvidenceParams.fromPartial(object.evidence) : undefined;
-    message.validator = object.validator !== undefined && object.validator !== null ? ValidatorParams.fromPartial(object.validator) : undefined;
-    message.version = object.version !== undefined && object.version !== null ? VersionParams.fromPartial(object.version) : undefined;
+  fromPartial(object: Partial<ResponseFinalizeBlock>): ResponseFinalizeBlock {
+    const message = createBaseResponseFinalizeBlock();
+    message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+    message.txResults = object.txResults?.map(e => ExecTxResult.fromPartial(e)) || [];
+    message.validatorUpdates = object.validatorUpdates?.map(e => ValidatorUpdate.fromPartial(e)) || [];
+    message.consensusParamUpdates = object.consensusParamUpdates !== undefined && object.consensusParamUpdates !== null ? ConsensusParams.fromPartial(object.consensusParamUpdates) : undefined;
+    message.appHash = object.appHash ?? new Uint8Array();
     return message;
   }
 
 };
 
-function createBaseBlockParams(): BlockParams {
+function createBaseCommitInfo(): CommitInfo {
   return {
-    maxBytes: Long.ZERO,
-    maxGas: Long.ZERO
+    round: 0,
+    votes: []
   };
 }
 
-export const BlockParams = {
-  encode(message: BlockParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (!message.maxBytes.isZero()) {
-      writer.uint32(8).int64(message.maxBytes);
+export const CommitInfo = {
+  encode(message: CommitInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.round !== 0) {
+      writer.uint32(8).int32(message.round);
     }
 
-    if (!message.maxGas.isZero()) {
-      writer.uint32(16).int64(message.maxGas);
+    for (const v of message.votes) {
+      VoteInfo.encode(v!, writer.uint32(18).fork()).ldelim();
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): BlockParams {
+  decode(input: _m0.Reader | Uint8Array, length?: number): CommitInfo {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseBlockParams();
+    const message = createBaseCommitInfo();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.maxBytes = (reader.int64() as Long);
+          message.round = reader.int32();
           break;
 
         case 2:
-          message.maxGas = (reader.int64() as Long);
+          message.votes.push(VoteInfo.decode(reader, reader.uint32()));
           break;
 
         default:
@@ -3989,53 +4594,59 @@ export const BlockParams = {
     return message;
   },
 
-  fromJSON(object: any): BlockParams {
+  fromJSON(object: any): CommitInfo {
     return {
-      maxBytes: isSet(object.maxBytes) ? Long.fromValue(object.maxBytes) : Long.ZERO,
-      maxGas: isSet(object.maxGas) ? Long.fromValue(object.maxGas) : Long.ZERO
+      round: isSet(object.round) ? Number(object.round) : 0,
+      votes: Array.isArray(object?.votes) ? object.votes.map((e: any) => VoteInfo.fromJSON(e)) : []
     };
   },
 
-  toJSON(message: BlockParams): unknown {
+  toJSON(message: CommitInfo): unknown {
     const obj: any = {};
-    message.maxBytes !== undefined && (obj.maxBytes = (message.maxBytes || Long.ZERO).toString());
-    message.maxGas !== undefined && (obj.maxGas = (message.maxGas || Long.ZERO).toString());
+    message.round !== undefined && (obj.round = Math.round(message.round));
+
+    if (message.votes) {
+      obj.votes = message.votes.map(e => e ? VoteInfo.toJSON(e) : undefined);
+    } else {
+      obj.votes = [];
+    }
+
     return obj;
   },
 
-  fromPartial(object: Partial<BlockParams>): BlockParams {
-    const message = createBaseBlockParams();
-    message.maxBytes = object.maxBytes !== undefined && object.maxBytes !== null ? Long.fromValue(object.maxBytes) : Long.ZERO;
-    message.maxGas = object.maxGas !== undefined && object.maxGas !== null ? Long.fromValue(object.maxGas) : Long.ZERO;
+  fromPartial(object: Partial<CommitInfo>): CommitInfo {
+    const message = createBaseCommitInfo();
+    message.round = object.round ?? 0;
+    message.votes = object.votes?.map(e => VoteInfo.fromPartial(e)) || [];
     return message;
   }
 
 };
 
-function createBaseLastCommitInfo(): LastCommitInfo {
+function createBaseExtendedCommitInfo(): ExtendedCommitInfo {
   return {
     round: 0,
     votes: []
   };
 }
 
-export const LastCommitInfo = {
-  encode(message: LastCommitInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ExtendedCommitInfo = {
+  encode(message: ExtendedCommitInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.round !== 0) {
       writer.uint32(8).int32(message.round);
     }
 
     for (const v of message.votes) {
-      VoteInfo.encode(v!, writer.uint32(18).fork()).ldelim();
+      ExtendedVoteInfo.encode(v!, writer.uint32(18).fork()).ldelim();
     }
 
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): LastCommitInfo {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ExtendedCommitInfo {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseLastCommitInfo();
+    const message = createBaseExtendedCommitInfo();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -4046,7 +4657,7 @@ export const LastCommitInfo = {
           break;
 
         case 2:
-          message.votes.push(VoteInfo.decode(reader, reader.uint32()));
+          message.votes.push(ExtendedVoteInfo.decode(reader, reader.uint32()));
           break;
 
         default:
@@ -4058,19 +4669,19 @@ export const LastCommitInfo = {
     return message;
   },
 
-  fromJSON(object: any): LastCommitInfo {
+  fromJSON(object: any): ExtendedCommitInfo {
     return {
       round: isSet(object.round) ? Number(object.round) : 0,
-      votes: Array.isArray(object?.votes) ? object.votes.map((e: any) => VoteInfo.fromJSON(e)) : []
+      votes: Array.isArray(object?.votes) ? object.votes.map((e: any) => ExtendedVoteInfo.fromJSON(e)) : []
     };
   },
 
-  toJSON(message: LastCommitInfo): unknown {
+  toJSON(message: ExtendedCommitInfo): unknown {
     const obj: any = {};
     message.round !== undefined && (obj.round = Math.round(message.round));
 
     if (message.votes) {
-      obj.votes = message.votes.map(e => e ? VoteInfo.toJSON(e) : undefined);
+      obj.votes = message.votes.map(e => e ? ExtendedVoteInfo.toJSON(e) : undefined);
     } else {
       obj.votes = [];
     }
@@ -4078,10 +4689,10 @@ export const LastCommitInfo = {
     return obj;
   },
 
-  fromPartial(object: Partial<LastCommitInfo>): LastCommitInfo {
-    const message = createBaseLastCommitInfo();
+  fromPartial(object: Partial<ExtendedCommitInfo>): ExtendedCommitInfo {
+    const message = createBaseExtendedCommitInfo();
     message.round = object.round ?? 0;
-    message.votes = object.votes?.map(e => VoteInfo.fromPartial(e)) || [];
+    message.votes = object.votes?.map(e => ExtendedVoteInfo.fromPartial(e)) || [];
     return message;
   }
 
@@ -4164,20 +4775,20 @@ export const Event = {
 
 function createBaseEventAttribute(): EventAttribute {
   return {
-    key: new Uint8Array(),
-    value: new Uint8Array(),
+    key: "",
+    value: "",
     index: false
   };
 }
 
 export const EventAttribute = {
   encode(message: EventAttribute, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.key.length !== 0) {
-      writer.uint32(10).bytes(message.key);
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
     }
 
-    if (message.value.length !== 0) {
-      writer.uint32(18).bytes(message.value);
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
     }
 
     if (message.index === true) {
@@ -4197,11 +4808,11 @@ export const EventAttribute = {
 
       switch (tag >>> 3) {
         case 1:
-          message.key = reader.bytes();
+          message.key = reader.string();
           break;
 
         case 2:
-          message.value = reader.bytes();
+          message.value = reader.string();
           break;
 
         case 3:
@@ -4219,30 +4830,177 @@ export const EventAttribute = {
 
   fromJSON(object: any): EventAttribute {
     return {
-      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
-      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(),
+      key: isSet(object.key) ? String(object.key) : "",
+      value: isSet(object.value) ? String(object.value) : "",
       index: isSet(object.index) ? Boolean(object.index) : false
     };
   },
 
   toJSON(message: EventAttribute): unknown {
     const obj: any = {};
-    message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
-    message.value !== undefined && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
+    message.key !== undefined && (obj.key = message.key);
+    message.value !== undefined && (obj.value = message.value);
     message.index !== undefined && (obj.index = message.index);
     return obj;
   },
 
   fromPartial(object: Partial<EventAttribute>): EventAttribute {
     const message = createBaseEventAttribute();
-    message.key = object.key ?? new Uint8Array();
-    message.value = object.value ?? new Uint8Array();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     message.index = object.index ?? false;
     return message;
   }
 
 };
 
+function createBaseExecTxResult(): ExecTxResult {
+  return {
+    code: 0,
+    data: new Uint8Array(),
+    log: "",
+    info: "",
+    gasWanted: Long.ZERO,
+    gasUsed: Long.ZERO,
+    events: [],
+    codespace: ""
+  };
+}
+
+export const ExecTxResult = {
+  encode(message: ExecTxResult, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.code !== 0) {
+      writer.uint32(8).uint32(message.code);
+    }
+
+    if (message.data.length !== 0) {
+      writer.uint32(18).bytes(message.data);
+    }
+
+    if (message.log !== "") {
+      writer.uint32(26).string(message.log);
+    }
+
+    if (message.info !== "") {
+      writer.uint32(34).string(message.info);
+    }
+
+    if (!message.gasWanted.isZero()) {
+      writer.uint32(40).int64(message.gasWanted);
+    }
+
+    if (!message.gasUsed.isZero()) {
+      writer.uint32(48).int64(message.gasUsed);
+    }
+
+    for (const v of message.events) {
+      Event.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
+
+    if (message.codespace !== "") {
+      writer.uint32(66).string(message.codespace);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ExecTxResult {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExecTxResult();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.uint32();
+          break;
+
+        case 2:
+          message.data = reader.bytes();
+          break;
+
+        case 3:
+          message.log = reader.string();
+          break;
+
+        case 4:
+          message.info = reader.string();
+          break;
+
+        case 5:
+          message.gasWanted = (reader.int64() as Long);
+          break;
+
+        case 6:
+          message.gasUsed = (reader.int64() as Long);
+          break;
+
+        case 7:
+          message.events.push(Event.decode(reader, reader.uint32()));
+          break;
+
+        case 8:
+          message.codespace = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ExecTxResult {
+    return {
+      code: isSet(object.code) ? Number(object.code) : 0,
+      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+      log: isSet(object.log) ? String(object.log) : "",
+      info: isSet(object.info) ? String(object.info) : "",
+      gasWanted: isSet(object.gas_wanted) ? Long.fromValue(object.gas_wanted) : Long.ZERO,
+      gasUsed: isSet(object.gas_used) ? Long.fromValue(object.gas_used) : Long.ZERO,
+      events: Array.isArray(object?.events) ? object.events.map((e: any) => Event.fromJSON(e)) : [],
+      codespace: isSet(object.codespace) ? String(object.codespace) : ""
+    };
+  },
+
+  toJSON(message: ExecTxResult): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = Math.round(message.code));
+    message.data !== undefined && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+    message.log !== undefined && (obj.log = message.log);
+    message.info !== undefined && (obj.info = message.info);
+    message.gasWanted !== undefined && (obj.gas_wanted = (message.gasWanted || Long.ZERO).toString());
+    message.gasUsed !== undefined && (obj.gas_used = (message.gasUsed || Long.ZERO).toString());
+
+    if (message.events) {
+      obj.events = message.events.map(e => e ? Event.toJSON(e) : undefined);
+    } else {
+      obj.events = [];
+    }
+
+    message.codespace !== undefined && (obj.codespace = message.codespace);
+    return obj;
+  },
+
+  fromPartial(object: Partial<ExecTxResult>): ExecTxResult {
+    const message = createBaseExecTxResult();
+    message.code = object.code ?? 0;
+    message.data = object.data ?? new Uint8Array();
+    message.log = object.log ?? "";
+    message.info = object.info ?? "";
+    message.gasWanted = object.gasWanted !== undefined && object.gasWanted !== null ? Long.fromValue(object.gasWanted) : Long.ZERO;
+    message.gasUsed = object.gasUsed !== undefined && object.gasUsed !== null ? Long.fromValue(object.gasUsed) : Long.ZERO;
+    message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+    message.codespace = object.codespace ?? "";
+    return message;
+  }
+
+};
+
 function createBaseTxResult(): TxResult {
   return {
     height: Long.ZERO,
@@ -4267,7 +5025,7 @@ export const TxResult = {
     }
 
     if (message.result !== undefined) {
-      ResponseDeliverTx.encode(message.result, writer.uint32(34).fork()).ldelim();
+      ExecTxResult.encode(message.result, writer.uint32(34).fork()).ldelim();
     }
 
     return writer;
@@ -4295,7 +5053,7 @@ export const TxResult = {
           break;
 
         case 4:
-          message.result = ResponseDeliverTx.decode(reader, reader.uint32());
+          message.result = ExecTxResult.decode(reader, reader.uint32());
           break;
 
         default:
@@ -4312,7 +5070,7 @@ export const TxResult = {
       height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
       index: isSet(object.index) ? Number(object.index) : 0,
       tx: isSet(object.tx) ? bytesFromBase64(object.tx) : new Uint8Array(),
-      result: isSet(object.result) ? ResponseDeliverTx.fromJSON(object.result) : undefined
+      result: isSet(object.result) ? ExecTxResult.fromJSON(object.result) : undefined
     };
   },
 
@@ -4321,7 +5079,7 @@ export const TxResult = {
     message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
     message.index !== undefined && (obj.index = Math.round(message.index));
     message.tx !== undefined && (obj.tx = base64FromBytes(message.tx !== undefined ? message.tx : new Uint8Array()));
-    message.result !== undefined && (obj.result = message.result ? ResponseDeliverTx.toJSON(message.result) : undefined);
+    message.result !== undefined && (obj.result = message.result ? ExecTxResult.toJSON(message.result) : undefined);
     return obj;
   },
 
@@ -4330,7 +5088,7 @@ export const TxResult = {
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
     message.index = object.index ?? 0;
     message.tx = object.tx ?? new Uint8Array();
-    message.result = object.result !== undefined && object.result !== null ? ResponseDeliverTx.fromPartial(object.result) : undefined;
+    message.result = object.result !== undefined && object.result !== null ? ExecTxResult.fromPartial(object.result) : undefined;
     return message;
   }
 
@@ -4477,7 +5235,7 @@ export const ValidatorUpdate = {
 function createBaseVoteInfo(): VoteInfo {
   return {
     validator: undefined,
-    signedLastBlock: false
+    blockIdFlag: 0
   };
 }
 
@@ -4487,8 +5245,8 @@ export const VoteInfo = {
       Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
     }
 
-    if (message.signedLastBlock === true) {
-      writer.uint32(16).bool(message.signedLastBlock);
+    if (message.blockIdFlag !== 0) {
+      writer.uint32(24).int32(message.blockIdFlag);
     }
 
     return writer;
@@ -4507,8 +5265,8 @@ export const VoteInfo = {
           message.validator = Validator.decode(reader, reader.uint32());
           break;
 
-        case 2:
-          message.signedLastBlock = reader.bool();
+        case 3:
+          message.blockIdFlag = (reader.int32() as any);
           break;
 
         default:
@@ -4523,27 +5281,120 @@ export const VoteInfo = {
   fromJSON(object: any): VoteInfo {
     return {
       validator: isSet(object.validator) ? Validator.fromJSON(object.validator) : undefined,
-      signedLastBlock: isSet(object.signedLastBlock) ? Boolean(object.signedLastBlock) : false
+      blockIdFlag: isSet(object.blockIdFlag) ? blockIDFlagFromJSON(object.blockIdFlag) : 0
     };
   },
 
   toJSON(message: VoteInfo): unknown {
     const obj: any = {};
     message.validator !== undefined && (obj.validator = message.validator ? Validator.toJSON(message.validator) : undefined);
-    message.signedLastBlock !== undefined && (obj.signedLastBlock = message.signedLastBlock);
+    message.blockIdFlag !== undefined && (obj.blockIdFlag = blockIDFlagToJSON(message.blockIdFlag));
     return obj;
   },
 
   fromPartial(object: Partial<VoteInfo>): VoteInfo {
     const message = createBaseVoteInfo();
     message.validator = object.validator !== undefined && object.validator !== null ? Validator.fromPartial(object.validator) : undefined;
-    message.signedLastBlock = object.signedLastBlock ?? false;
+    message.blockIdFlag = object.blockIdFlag ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseExtendedVoteInfo(): ExtendedVoteInfo {
+  return {
+    validator: undefined,
+    voteExtension: new Uint8Array(),
+    extensionSignature: new Uint8Array(),
+    blockIdFlag: 0
+  };
+}
+
+export const ExtendedVoteInfo = {
+  encode(message: ExtendedVoteInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.validator !== undefined) {
+      Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.voteExtension.length !== 0) {
+      writer.uint32(26).bytes(message.voteExtension);
+    }
+
+    if (message.extensionSignature.length !== 0) {
+      writer.uint32(34).bytes(message.extensionSignature);
+    }
+
+    if (message.blockIdFlag !== 0) {
+      writer.uint32(40).int32(message.blockIdFlag);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ExtendedVoteInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExtendedVoteInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.validator = Validator.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.voteExtension = reader.bytes();
+          break;
+
+        case 4:
+          message.extensionSignature = reader.bytes();
+          break;
+
+        case 5:
+          message.blockIdFlag = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ExtendedVoteInfo {
+    return {
+      validator: isSet(object.validator) ? Validator.fromJSON(object.validator) : undefined,
+      voteExtension: isSet(object.voteExtension) ? bytesFromBase64(object.voteExtension) : new Uint8Array(),
+      extensionSignature: isSet(object.extensionSignature) ? bytesFromBase64(object.extensionSignature) : new Uint8Array(),
+      blockIdFlag: isSet(object.blockIdFlag) ? blockIDFlagFromJSON(object.blockIdFlag) : 0
+    };
+  },
+
+  toJSON(message: ExtendedVoteInfo): unknown {
+    const obj: any = {};
+    message.validator !== undefined && (obj.validator = message.validator ? Validator.toJSON(message.validator) : undefined);
+    message.voteExtension !== undefined && (obj.voteExtension = base64FromBytes(message.voteExtension !== undefined ? message.voteExtension : new Uint8Array()));
+    message.extensionSignature !== undefined && (obj.extensionSignature = base64FromBytes(message.extensionSignature !== undefined ? message.extensionSignature : new Uint8Array()));
+    message.blockIdFlag !== undefined && (obj.blockIdFlag = blockIDFlagToJSON(message.blockIdFlag));
+    return obj;
+  },
+
+  fromPartial(object: Partial<ExtendedVoteInfo>): ExtendedVoteInfo {
+    const message = createBaseExtendedVoteInfo();
+    message.validator = object.validator !== undefined && object.validator !== null ? Validator.fromPartial(object.validator) : undefined;
+    message.voteExtension = object.voteExtension ?? new Uint8Array();
+    message.extensionSignature = object.extensionSignature ?? new Uint8Array();
+    message.blockIdFlag = object.blockIdFlag ?? 0;
     return message;
   }
 
 };
 
-function createBaseEvidence(): Evidence {
+function createBaseMisbehavior(): Misbehavior {
   return {
     type: 0,
     validator: undefined,
@@ -4553,8 +5404,8 @@ function createBaseEvidence(): Evidence {
   };
 }
 
-export const Evidence = {
-  encode(message: Evidence, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const Misbehavior = {
+  encode(message: Misbehavior, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.type !== 0) {
       writer.uint32(8).int32(message.type);
     }
@@ -4578,10 +5429,10 @@ export const Evidence = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Evidence {
+  decode(input: _m0.Reader | Uint8Array, length?: number): Misbehavior {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseEvidence();
+    const message = createBaseMisbehavior();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -4616,9 +5467,9 @@ export const Evidence = {
     return message;
   },
 
-  fromJSON(object: any): Evidence {
+  fromJSON(object: any): Misbehavior {
     return {
-      type: isSet(object.type) ? evidenceTypeFromJSON(object.type) : 0,
+      type: isSet(object.type) ? misbehaviorTypeFromJSON(object.type) : 0,
       validator: isSet(object.validator) ? Validator.fromJSON(object.validator) : undefined,
       height: isSet(object.height) ? Long.fromValue(object.height) : Long.ZERO,
       time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
@@ -4626,9 +5477,9 @@ export const Evidence = {
     };
   },
 
-  toJSON(message: Evidence): unknown {
+  toJSON(message: Misbehavior): unknown {
     const obj: any = {};
-    message.type !== undefined && (obj.type = evidenceTypeToJSON(message.type));
+    message.type !== undefined && (obj.type = misbehaviorTypeToJSON(message.type));
     message.validator !== undefined && (obj.validator = message.validator ? Validator.toJSON(message.validator) : undefined);
     message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString());
     message.time !== undefined && (obj.time = fromTimestamp(message.time).toISOString());
@@ -4636,8 +5487,8 @@ export const Evidence = {
     return obj;
   },
 
-  fromPartial(object: Partial<Evidence>): Evidence {
-    const message = createBaseEvidence();
+  fromPartial(object: Partial<Misbehavior>): Misbehavior {
+    const message = createBaseMisbehavior();
     message.type = object.type ?? 0;
     message.validator = object.validator !== undefined && object.validator !== null ? Validator.fromPartial(object.validator) : undefined;
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;