@iconlake/client 0.0.2 → 0.1.0

package/cosmos.tx.v1beta1/types/tendermint/abci/types.ts

@@ -4,7 +4,7 @@ import _m0 from "protobufjs/minimal";
 import { Timestamp } from "../../google/protobuf/timestamp";
 import { PublicKey } from "../crypto/keys";
 import { ProofOps } from "../crypto/proof";
-import { EvidenceParams, ValidatorParams, VersionParams } from "../types/params";
+import { ConsensusParams } from "../types/params";
 import { Header } from "../types/types";
 
 export const protobufPackage = "tendermint.abci";
@@ -42,40 +42,40 @@ export function checkTxTypeToJSON(object: CheckTxType): string {
   }
 }
 
-export enum EvidenceType {
+export enum MisbehaviorType {
   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";
   }
@@ -85,7 +85,6 @@ export interface Request {
   echo: RequestEcho | undefined;
   flush: RequestFlush | undefined;
   info: RequestInfo | undefined;
-  setOption: RequestSetOption | undefined;
   initChain: RequestInitChain | undefined;
   query: RequestQuery | undefined;
   beginBlock: RequestBeginBlock | undefined;
@@ -97,6 +96,8 @@ export interface Request {
   offerSnapshot: RequestOfferSnapshot | undefined;
   loadSnapshotChunk: RequestLoadSnapshotChunk | undefined;
   applySnapshotChunk: RequestApplySnapshotChunk | undefined;
+  prepareProposal: RequestPrepareProposal | undefined;
+  processProposal: RequestProcessProposal | undefined;
 }
 
 export interface RequestEcho {
@@ -110,12 +111,7 @@ export interface RequestInfo {
   version: string;
   blockVersion: number;
   p2pVersion: number;
-}
-
-/** nondeterministic */
-export interface RequestSetOption {
-  key: string;
-  value: string;
+  abciVersion: string;
 }
 
 export interface RequestInitChain {
@@ -137,8 +133,8 @@ export interface RequestQuery {
 export interface RequestBeginBlock {
   hash: Uint8Array;
   header: Header | undefined;
-  lastCommitInfo: LastCommitInfo | undefined;
-  byzantineValidators: Evidence[];
+  lastCommitInfo: CommitInfo | undefined;
+  byzantineValidators: Misbehavior[];
 }
 
 export interface RequestCheckTx {
@@ -185,12 +181,41 @@ export interface RequestApplySnapshotChunk {
   sender: string;
 }
 
+export interface RequestPrepareProposal {
+  /** the modified transactions cannot exceed this size. */
+  maxTxBytes: number;
+  /**
+   * txs is an array of transactions that will be included in a block,
+   * sent to the app for possible modifications.
+   */
+  txs: Uint8Array[];
+  localLastCommit: ExtendedCommitInfo | undefined;
+  misbehavior: Misbehavior[];
+  height: number;
+  time: Date | undefined;
+  nextValidatorsHash: Uint8Array;
+  /** address of the public key of the validator proposing the block. */
+  proposerAddress: Uint8Array;
+}
+
+export interface RequestProcessProposal {
+  txs: Uint8Array[];
+  proposedLastCommit: CommitInfo | undefined;
+  misbehavior: Misbehavior[];
+  /** hash is the merkle root hash of the fields of the proposed block. */
+  hash: Uint8Array;
+  height: number;
+  time: Date | undefined;
+  nextValidatorsHash: Uint8Array;
+  /** address of the public key of the original proposer of the block. */
+  proposerAddress: Uint8Array;
+}
+
 export interface Response {
   exception: ResponseException | undefined;
   echo: ResponseEcho | undefined;
   flush: ResponseFlush | undefined;
   info: ResponseInfo | undefined;
-  setOption: ResponseSetOption | undefined;
   initChain: ResponseInitChain | undefined;
   query: ResponseQuery | undefined;
   beginBlock: ResponseBeginBlock | undefined;
@@ -202,6 +227,8 @@ export interface Response {
   offerSnapshot: ResponseOfferSnapshot | undefined;
   loadSnapshotChunk: ResponseLoadSnapshotChunk | undefined;
   applySnapshotChunk: ResponseApplySnapshotChunk | undefined;
+  prepareProposal: ResponsePrepareProposal | undefined;
+  processProposal: ResponseProcessProposal | undefined;
 }
 
 /** nondeterministic */
@@ -224,14 +251,6 @@ export interface ResponseInfo {
   lastBlockAppHash: Uint8Array;
 }
 
-/** nondeterministic */
-export interface ResponseSetOption {
-  code: number;
-  /** bytes data = 2; */
-  log: string;
-  info: string;
-}
-
 export interface ResponseInitChain {
   consensusParams: ConsensusParams | undefined;
   validators: ValidatorUpdate[];
@@ -270,7 +289,7 @@ export interface ResponseCheckTx {
   sender: string;
   priority: number;
   /**
-   * mempool_error is set by Tendermint.
+   * mempool_error is set by CometBFT.
    * ABCI applictions creating a ResponseCheckTX should not set mempool_error.
    */
   mempoolError: string;
@@ -448,30 +467,68 @@ export function responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySna
   }
 }
 
-/**
- * ConsensusParams contains all consensus-relevant parameters
- * that can be adjusted by the abci app
- */
-export interface ConsensusParams {
-  block: BlockParams | undefined;
-  evidence: EvidenceParams | undefined;
-  validator: ValidatorParams | undefined;
-  version: VersionParams | undefined;
+export interface ResponsePrepareProposal {
+  txs: Uint8Array[];
+}
+
+export interface ResponseProcessProposal {
+  status: ResponseProcessProposal_ProposalStatus;
+}
+
+export enum ResponseProcessProposal_ProposalStatus {
+  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;
+  }
 }
 
-/** BlockParams contains limits on the block size. */
-export interface BlockParams {
-  /** Note: must be greater than 0 */
-  maxBytes: number;
-  /** Note: must be greater or equal to -1 */
-  maxGas: number;
+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 interface LastCommitInfo {
+export interface CommitInfo {
   round: number;
   votes: VoteInfo[];
 }
 
+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[];
+}
+
 /**
  * Event allows application developers to attach additional information to
  * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
@@ -484,8 +541,8 @@ export interface Event {
 
 /** 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;
 }
@@ -522,8 +579,15 @@ export interface VoteInfo {
   signedLastBlock: boolean;
 }
 
-export interface Evidence {
-  type: EvidenceType;
+export interface ExtendedVoteInfo {
+  validator: Validator | undefined;
+  signedLastBlock: boolean;
+  /** Reserved for future use */
+  voteExtension: Uint8Array;
+}
+
+export interface Misbehavior {
+  type: MisbehaviorType;
   /** The offending validator */
   validator:
     | Validator
@@ -560,7 +624,6 @@ function createBaseRequest(): Request {
     echo: undefined,
     flush: undefined,
     info: undefined,
-    setOption: undefined,
     initChain: undefined,
     query: undefined,
     beginBlock: undefined,
@@ -572,6 +635,8 @@ function createBaseRequest(): Request {
     offerSnapshot: undefined,
     loadSnapshotChunk: undefined,
     applySnapshotChunk: undefined,
+    prepareProposal: undefined,
+    processProposal: undefined,
   };
 }
 
@@ -586,9 +651,6 @@ export const Request = {
     if (message.info !== undefined) {
       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();
     }
@@ -622,6 +684,12 @@ export const Request = {
     if (message.applySnapshotChunk !== undefined) {
       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();
+    }
     return writer;
   },
 
@@ -641,9 +709,6 @@ export const Request = {
         case 3:
           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;
@@ -677,6 +742,12 @@ export const Request = {
         case 15:
           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;
         default:
           reader.skipType(tag & 7);
           break;
@@ -690,7 +761,6 @@ 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,
@@ -706,6 +776,12 @@ export const Request = {
       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,
     };
   },
 
@@ -714,8 +790,6 @@ 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);
@@ -738,6 +812,12 @@ export const Request = {
     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);
     return obj;
   },
 
@@ -752,9 +832,6 @@ export const Request = {
     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;
@@ -788,6 +865,12 @@ export const Request = {
     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;
     return message;
   },
 };
@@ -879,7 +962,7 @@ export const RequestFlush = {
 };
 
 function createBaseRequestInfo(): RequestInfo {
-  return { version: "", blockVersion: 0, p2pVersion: 0 };
+  return { version: "", blockVersion: 0, p2pVersion: 0, abciVersion: "" };
 }
 
 export const RequestInfo = {
@@ -893,6 +976,9 @@ export const RequestInfo = {
     if (message.p2pVersion !== 0) {
       writer.uint32(24).uint64(message.p2pVersion);
     }
+    if (message.abciVersion !== "") {
+      writer.uint32(34).string(message.abciVersion);
+    }
     return writer;
   },
 
@@ -912,6 +998,9 @@ export const RequestInfo = {
         case 3:
           message.p2pVersion = longToNumber(reader.uint64() as Long);
           break;
+        case 4:
+          message.abciVersion = reader.string();
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -925,6 +1014,7 @@ export const RequestInfo = {
       version: isSet(object.version) ? String(object.version) : "",
       blockVersion: isSet(object.blockVersion) ? Number(object.blockVersion) : 0,
       p2pVersion: isSet(object.p2pVersion) ? Number(object.p2pVersion) : 0,
+      abciVersion: isSet(object.abciVersion) ? String(object.abciVersion) : "",
     };
   },
 
@@ -933,6 +1023,7 @@ export const RequestInfo = {
     message.version !== undefined && (obj.version = message.version);
     message.blockVersion !== undefined && (obj.blockVersion = Math.round(message.blockVersion));
     message.p2pVersion !== undefined && (obj.p2pVersion = Math.round(message.p2pVersion));
+    message.abciVersion !== undefined && (obj.abciVersion = message.abciVersion);
     return obj;
   },
 
@@ -941,61 +1032,7 @@ export const RequestInfo = {
     message.version = object.version ?? "";
     message.blockVersion = object.blockVersion ?? 0;
     message.p2pVersion = object.p2pVersion ?? 0;
-    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<I extends Exact<DeepPartial<RequestSetOption>, I>>(object: I): RequestSetOption {
-    const message = createBaseRequestSetOption();
-    message.key = object.key ?? "";
-    message.value = object.value ?? "";
+    message.abciVersion = object.abciVersion ?? "";
     return message;
   },
 };
@@ -1203,10 +1240,10 @@ export const RequestBeginBlock = {
       Header.encode(message.header, writer.uint32(18).fork()).ldelim();
     }
     if (message.lastCommitInfo !== undefined) {
-      LastCommitInfo.encode(message.lastCommitInfo, writer.uint32(26).fork()).ldelim();
+      CommitInfo.encode(message.lastCommitInfo, writer.uint32(26).fork()).ldelim();
     }
     for (const v of message.byzantineValidators) {
-      Evidence.encode(v!, writer.uint32(34).fork()).ldelim();
+      Misbehavior.encode(v!, writer.uint32(34).fork()).ldelim();
     }
     return writer;
   },
@@ -1225,10 +1262,10 @@ export const RequestBeginBlock = {
           message.header = Header.decode(reader, reader.uint32());
           break;
         case 3:
-          message.lastCommitInfo = LastCommitInfo.decode(reader, reader.uint32());
+          message.lastCommitInfo = CommitInfo.decode(reader, reader.uint32());
           break;
         case 4:
-          message.byzantineValidators.push(Evidence.decode(reader, reader.uint32()));
+          message.byzantineValidators.push(Misbehavior.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
@@ -1242,9 +1279,9 @@ export const 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,
+      lastCommitInfo: isSet(object.lastCommitInfo) ? CommitInfo.fromJSON(object.lastCommitInfo) : undefined,
       byzantineValidators: Array.isArray(object?.byzantineValidators)
-        ? object.byzantineValidators.map((e: any) => Evidence.fromJSON(e))
+        ? object.byzantineValidators.map((e: any) => Misbehavior.fromJSON(e))
         : [],
     };
   },
@@ -1255,9 +1292,9 @@ export const RequestBeginBlock = {
       && (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);
+      && (obj.lastCommitInfo = message.lastCommitInfo ? CommitInfo.toJSON(message.lastCommitInfo) : undefined);
     if (message.byzantineValidators) {
-      obj.byzantineValidators = message.byzantineValidators.map((e) => e ? Evidence.toJSON(e) : undefined);
+      obj.byzantineValidators = message.byzantineValidators.map((e) => e ? Misbehavior.toJSON(e) : undefined);
     } else {
       obj.byzantineValidators = [];
     }
@@ -1271,9 +1308,9 @@ export const RequestBeginBlock = {
       ? Header.fromPartial(object.header)
       : undefined;
     message.lastCommitInfo = (object.lastCommitInfo !== undefined && object.lastCommitInfo !== null)
-      ? LastCommitInfo.fromPartial(object.lastCommitInfo)
+      ? CommitInfo.fromPartial(object.lastCommitInfo)
       : undefined;
-    message.byzantineValidators = object.byzantineValidators?.map((e) => Evidence.fromPartial(e)) || [];
+    message.byzantineValidators = object.byzantineValidators?.map((e) => Misbehavior.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1704,13 +1741,300 @@ export const RequestApplySnapshotChunk = {
   },
 };
 
+function createBaseRequestPrepareProposal(): RequestPrepareProposal {
+  return {
+    maxTxBytes: 0,
+    txs: [],
+    localLastCommit: undefined,
+    misbehavior: [],
+    height: 0,
+    time: undefined,
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array(),
+  };
+}
+
+export const RequestPrepareProposal = {
+  encode(message: RequestPrepareProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.maxTxBytes !== 0) {
+      writer.uint32(8).int64(message.maxTxBytes);
+    }
+    for (const v of message.txs) {
+      writer.uint32(18).bytes(v!);
+    }
+    if (message.localLastCommit !== undefined) {
+      ExtendedCommitInfo.encode(message.localLastCommit, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.misbehavior) {
+      Misbehavior.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.height !== 0) {
+      writer.uint32(40).int64(message.height);
+    }
+    if (message.time !== undefined) {
+      Timestamp.encode(toTimestamp(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): RequestPrepareProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestPrepareProposal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.maxTxBytes = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.txs.push(reader.bytes());
+          break;
+        case 3:
+          message.localLastCommit = ExtendedCommitInfo.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.height = longToNumber(reader.int64() as Long);
+          break;
+        case 6:
+          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 7:
+          message.nextValidatorsHash = reader.bytes();
+          break;
+        case 8:
+          message.proposerAddress = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RequestPrepareProposal {
+    return {
+      maxTxBytes: isSet(object.maxTxBytes) ? Number(object.maxTxBytes) : 0,
+      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) ? Number(object.height) : 0,
+      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: RequestPrepareProposal): unknown {
+    const obj: any = {};
+    message.maxTxBytes !== undefined && (obj.maxTxBytes = Math.round(message.maxTxBytes));
+    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 = Math.round(message.height));
+    message.time !== undefined && (obj.time = 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<I extends Exact<DeepPartial<RequestPrepareProposal>, I>>(object: I): RequestPrepareProposal {
+    const message = createBaseRequestPrepareProposal();
+    message.maxTxBytes = object.maxTxBytes ?? 0;
+    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 ?? 0;
+    message.time = object.time ?? undefined;
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseRequestProcessProposal(): RequestProcessProposal {
+  return {
+    txs: [],
+    proposedLastCommit: undefined,
+    misbehavior: [],
+    hash: new Uint8Array(),
+    height: 0,
+    time: undefined,
+    nextValidatorsHash: new Uint8Array(),
+    proposerAddress: new Uint8Array(),
+  };
+}
+
+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!);
+    }
+    if (message.proposedLastCommit !== undefined) {
+      CommitInfo.encode(message.proposedLastCommit, writer.uint32(18).fork()).ldelim();
+    }
+    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 !== 0) {
+      writer.uint32(40).int64(message.height);
+    }
+    if (message.time !== undefined) {
+      Timestamp.encode(toTimestamp(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): RequestProcessProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestProcessProposal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.txs.push(reader.bytes());
+          break;
+        case 2:
+          message.proposedLastCommit = CommitInfo.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.misbehavior.push(Misbehavior.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.hash = reader.bytes();
+          break;
+        case 5:
+          message.height = longToNumber(reader.int64() as Long);
+          break;
+        case 6:
+          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 7:
+          message.nextValidatorsHash = reader.bytes();
+          break;
+        case 8:
+          message.proposerAddress = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  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) ? Number(object.height) : 0,
+      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: 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 = Math.round(message.height));
+    message.time !== undefined && (obj.time = 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<I extends Exact<DeepPartial<RequestProcessProposal>, I>>(object: I): 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 ?? 0;
+    message.time = object.time ?? undefined;
+    message.nextValidatorsHash = object.nextValidatorsHash ?? new Uint8Array();
+    message.proposerAddress = object.proposerAddress ?? new Uint8Array();
+    return message;
+  },
+};
+
 function createBaseResponse(): Response {
   return {
     exception: undefined,
     echo: undefined,
     flush: undefined,
     info: undefined,
-    setOption: undefined,
     initChain: undefined,
     query: undefined,
     beginBlock: undefined,
@@ -1722,6 +2046,8 @@ function createBaseResponse(): Response {
     offerSnapshot: undefined,
     loadSnapshotChunk: undefined,
     applySnapshotChunk: undefined,
+    prepareProposal: undefined,
+    processProposal: undefined,
   };
 }
 
@@ -1739,9 +2065,6 @@ export const Response = {
     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();
     }
@@ -1775,6 +2098,12 @@ export const Response = {
     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();
+    }
     return writer;
   },
 
@@ -1797,9 +2126,6 @@ export const Response = {
         case 4:
           message.info = ResponseInfo.decode(reader, reader.uint32());
           break;
-        case 5:
-          message.setOption = ResponseSetOption.decode(reader, reader.uint32());
-          break;
         case 6:
           message.initChain = ResponseInitChain.decode(reader, reader.uint32());
           break;
@@ -1833,6 +2159,12 @@ export const Response = {
         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;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1847,7 +2179,6 @@ export const Response = {
       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,
@@ -1863,6 +2194,12 @@ export const Response = {
       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,
     };
   },
 
@@ -1873,8 +2210,6 @@ export const Response = {
     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);
@@ -1897,6 +2232,12 @@ export const Response = {
     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);
     return obj;
   },
 
@@ -1914,9 +2255,6 @@ export const Response = {
     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;
@@ -1950,6 +2288,12 @@ export const Response = {
     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;
     return message;
   },
 };
@@ -2175,73 +2519,6 @@ export const ResponseInfo = {
   },
 };
 
-function createBaseResponseSetOption(): ResponseSetOption {
-  return { code: 0, log: "", info: "" };
-}
-
-export const ResponseSetOption = {
-  encode(message: ResponseSetOption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.code !== 0) {
-      writer.uint32(8).uint32(message.code);
-    }
-    if (message.log !== "") {
-      writer.uint32(26).string(message.log);
-    }
-    if (message.info !== "") {
-      writer.uint32(34).string(message.info);
-    }
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseSetOption {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseResponseSetOption();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.code = reader.uint32();
-          break;
-        case 3:
-          message.log = reader.string();
-          break;
-        case 4:
-          message.info = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ResponseSetOption {
-    return {
-      code: isSet(object.code) ? Number(object.code) : 0,
-      log: isSet(object.log) ? String(object.log) : "",
-      info: isSet(object.info) ? String(object.info) : "",
-    };
-  },
-
-  toJSON(message: ResponseSetOption): 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);
-    return obj;
-  },
-
-  fromPartial<I extends Exact<DeepPartial<ResponseSetOption>, I>>(object: I): ResponseSetOption {
-    const message = createBaseResponseSetOption();
-    message.code = object.code ?? 0;
-    message.log = object.log ?? "";
-    message.info = object.info ?? "";
-    return message;
-  },
-};
-
 function createBaseResponseInitChain(): ResponseInitChain {
   return { consensusParams: undefined, validators: [], appHash: new Uint8Array() };
 }
@@ -3153,45 +3430,78 @@ export const ResponseApplySnapshotChunk = {
   },
 };
 
-function createBaseConsensusParams(): ConsensusParams {
-  return { block: undefined, evidence: undefined, validator: undefined, version: undefined };
+function createBaseResponsePrepareProposal(): ResponsePrepareProposal {
+  return { txs: [] };
 }
 
-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 ResponsePrepareProposal = {
+  encode(message: ResponsePrepareProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.txs) {
+      writer.uint32(10).bytes(v!);
     }
-    if (message.evidence !== undefined) {
-      EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
+    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;
+      }
     }
-    if (message.validator !== undefined) {
-      ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
+    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 = [];
     }
-    if (message.version !== undefined) {
-      VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ResponsePrepareProposal>, I>>(object: I): ResponsePrepareProposal {
+    const message = createBaseResponsePrepareProposal();
+    message.txs = object.txs?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseResponseProcessProposal(): ResponseProcessProposal {
+  return { status: 0 };
+}
+
+export const ResponseProcessProposal = {
+  encode(message: ResponseProcessProposal, 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): ConsensusParams {
+  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 = createBaseConsensusParams();
+    const message = createBaseResponseProcessProposal();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.block = BlockParams.decode(reader, reader.uint32());
-          break;
-        case 2:
-          message.evidence = EvidenceParams.decode(reader, reader.uint32());
-          break;
-        case 3:
-          message.validator = ValidatorParams.decode(reader, reader.uint32());
-          break;
-        case 4:
-          message.version = VersionParams.decode(reader, reader.uint32());
+          message.status = reader.int32() as any;
           break;
         default:
           reader.skipType(tag & 7);
@@ -3201,72 +3511,50 @@ export const ConsensusParams = {
     return message;
   },
 
-  fromJSON(object: any): ConsensusParams {
-    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,
-    };
+  fromJSON(object: any): ResponseProcessProposal {
+    return { status: isSet(object.status) ? responseProcessProposal_ProposalStatusFromJSON(object.status) : 0 };
   },
 
-  toJSON(message: ConsensusParams): unknown {
+  toJSON(message: ResponseProcessProposal): 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);
+    message.status !== undefined && (obj.status = responseProcessProposal_ProposalStatusToJSON(message.status));
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<ConsensusParams>, I>>(object: I): 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<I extends Exact<DeepPartial<ResponseProcessProposal>, I>>(object: I): ResponseProcessProposal {
+    const message = createBaseResponseProcessProposal();
+    message.status = object.status ?? 0;
     return message;
   },
 };
 
-function createBaseBlockParams(): BlockParams {
-  return { maxBytes: 0, maxGas: 0 };
+function createBaseCommitInfo(): CommitInfo {
+  return { round: 0, votes: [] };
 }
 
-export const BlockParams = {
-  encode(message: BlockParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.maxBytes !== 0) {
-      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 !== 0) {
-      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 = longToNumber(reader.int64() as Long);
+          message.round = reader.int32();
           break;
         case 2:
-          message.maxGas = longToNumber(reader.int64() as Long);
+          message.votes.push(VoteInfo.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
@@ -3276,47 +3564,51 @@ export const BlockParams = {
     return message;
   },
 
-  fromJSON(object: any): BlockParams {
+  fromJSON(object: any): CommitInfo {
     return {
-      maxBytes: isSet(object.maxBytes) ? Number(object.maxBytes) : 0,
-      maxGas: isSet(object.maxGas) ? Number(object.maxGas) : 0,
+      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 = Math.round(message.maxBytes));
-    message.maxGas !== undefined && (obj.maxGas = Math.round(message.maxGas));
+    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<I extends Exact<DeepPartial<BlockParams>, I>>(object: I): BlockParams {
-    const message = createBaseBlockParams();
-    message.maxBytes = object.maxBytes ?? 0;
-    message.maxGas = object.maxGas ?? 0;
+  fromPartial<I extends Exact<DeepPartial<CommitInfo>, I>>(object: I): 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();
       switch (tag >>> 3) {
@@ -3324,7 +3616,7 @@ export const LastCommitInfo = {
           message.round = reader.int32();
           break;
         case 2:
-          message.votes.push(VoteInfo.decode(reader, reader.uint32()));
+          message.votes.push(ExtendedVoteInfo.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
@@ -3334,28 +3626,28 @@ 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 = [];
     }
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<LastCommitInfo>, I>>(object: I): LastCommitInfo {
-    const message = createBaseLastCommitInfo();
+  fromPartial<I extends Exact<DeepPartial<ExtendedCommitInfo>, I>>(object: I): 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;
   },
 };
@@ -3425,16 +3717,16 @@ export const Event = {
 };
 
 function createBaseEventAttribute(): EventAttribute {
-  return { key: new Uint8Array(), value: new Uint8Array(), index: false };
+  return { 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) {
       writer.uint32(24).bool(message.index);
@@ -3450,10 +3742,10 @@ export const EventAttribute = {
       const tag = reader.uint32();
       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:
           message.index = reader.bool();
@@ -3468,26 +3760,24 @@ 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<I extends Exact<DeepPartial<EventAttribute>, I>>(object: I): 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;
   },
@@ -3752,12 +4042,85 @@ export const VoteInfo = {
   },
 };
 
-function createBaseEvidence(): Evidence {
+function createBaseExtendedVoteInfo(): ExtendedVoteInfo {
+  return { validator: undefined, signedLastBlock: false, voteExtension: new Uint8Array() };
+}
+
+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.signedLastBlock === true) {
+      writer.uint32(16).bool(message.signedLastBlock);
+    }
+    if (message.voteExtension.length !== 0) {
+      writer.uint32(26).bytes(message.voteExtension);
+    }
+    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 2:
+          message.signedLastBlock = reader.bool();
+          break;
+        case 3:
+          message.voteExtension = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ExtendedVoteInfo {
+    return {
+      validator: isSet(object.validator) ? Validator.fromJSON(object.validator) : undefined,
+      signedLastBlock: isSet(object.signedLastBlock) ? Boolean(object.signedLastBlock) : false,
+      voteExtension: isSet(object.voteExtension) ? bytesFromBase64(object.voteExtension) : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: ExtendedVoteInfo): unknown {
+    const obj: any = {};
+    message.validator !== undefined
+      && (obj.validator = message.validator ? Validator.toJSON(message.validator) : undefined);
+    message.signedLastBlock !== undefined && (obj.signedLastBlock = message.signedLastBlock);
+    message.voteExtension !== undefined
+      && (obj.voteExtension = base64FromBytes(
+        message.voteExtension !== undefined ? message.voteExtension : new Uint8Array(),
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ExtendedVoteInfo>, I>>(object: I): ExtendedVoteInfo {
+    const message = createBaseExtendedVoteInfo();
+    message.validator = (object.validator !== undefined && object.validator !== null)
+      ? Validator.fromPartial(object.validator)
+      : undefined;
+    message.signedLastBlock = object.signedLastBlock ?? false;
+    message.voteExtension = object.voteExtension ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseMisbehavior(): Misbehavior {
   return { type: 0, validator: undefined, height: 0, time: undefined, totalVotingPower: 0 };
 }
 
-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);
     }
@@ -3776,10 +4139,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();
       switch (tag >>> 3) {
@@ -3806,9 +4169,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) ? Number(object.height) : 0,
       time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
@@ -3816,9 +4179,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 = Math.round(message.height));
@@ -3827,8 +4190,8 @@ export const Evidence = {
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<Evidence>, I>>(object: I): Evidence {
-    const message = createBaseEvidence();
+  fromPartial<I extends Exact<DeepPartial<Misbehavior>, I>>(object: I): Misbehavior {
+    const message = createBaseMisbehavior();
     message.type = object.type ?? 0;
     message.validator = (object.validator !== undefined && object.validator !== null)
       ? Validator.fromPartial(object.validator)
@@ -3931,7 +4294,6 @@ export interface ABCIApplication {
   Echo(request: RequestEcho): Promise<ResponseEcho>;
   Flush(request: RequestFlush): Promise<ResponseFlush>;
   Info(request: RequestInfo): Promise<ResponseInfo>;
-  SetOption(request: RequestSetOption): Promise<ResponseSetOption>;
   DeliverTx(request: RequestDeliverTx): Promise<ResponseDeliverTx>;
   CheckTx(request: RequestCheckTx): Promise<ResponseCheckTx>;
   Query(request: RequestQuery): Promise<ResponseQuery>;
@@ -3943,6 +4305,8 @@ export interface ABCIApplication {
   OfferSnapshot(request: RequestOfferSnapshot): Promise<ResponseOfferSnapshot>;
   LoadSnapshotChunk(request: RequestLoadSnapshotChunk): Promise<ResponseLoadSnapshotChunk>;
   ApplySnapshotChunk(request: RequestApplySnapshotChunk): Promise<ResponseApplySnapshotChunk>;
+  PrepareProposal(request: RequestPrepareProposal): Promise<ResponsePrepareProposal>;
+  ProcessProposal(request: RequestProcessProposal): Promise<ResponseProcessProposal>;
 }
 
 export class ABCIApplicationClientImpl implements ABCIApplication {
@@ -3952,7 +4316,6 @@ export class ABCIApplicationClientImpl implements ABCIApplication {
     this.Echo = this.Echo.bind(this);
     this.Flush = this.Flush.bind(this);
     this.Info = this.Info.bind(this);
-    this.SetOption = this.SetOption.bind(this);
     this.DeliverTx = this.DeliverTx.bind(this);
     this.CheckTx = this.CheckTx.bind(this);
     this.Query = this.Query.bind(this);
@@ -3964,6 +4327,8 @@ export class ABCIApplicationClientImpl implements ABCIApplication {
     this.OfferSnapshot = this.OfferSnapshot.bind(this);
     this.LoadSnapshotChunk = this.LoadSnapshotChunk.bind(this);
     this.ApplySnapshotChunk = this.ApplySnapshotChunk.bind(this);
+    this.PrepareProposal = this.PrepareProposal.bind(this);
+    this.ProcessProposal = this.ProcessProposal.bind(this);
   }
   Echo(request: RequestEcho): Promise<ResponseEcho> {
     const data = RequestEcho.encode(request).finish();
@@ -3983,12 +4348,6 @@ export class ABCIApplicationClientImpl implements ABCIApplication {
     return promise.then((data) => ResponseInfo.decode(new _m0.Reader(data)));
   }
 
-  SetOption(request: RequestSetOption): Promise<ResponseSetOption> {
-    const data = RequestSetOption.encode(request).finish();
-    const promise = this.rpc.request("tendermint.abci.ABCIApplication", "SetOption", data);
-    return promise.then((data) => ResponseSetOption.decode(new _m0.Reader(data)));
-  }
-
   DeliverTx(request: RequestDeliverTx): Promise<ResponseDeliverTx> {
     const data = RequestDeliverTx.encode(request).finish();
     const promise = this.rpc.request("tendermint.abci.ABCIApplication", "DeliverTx", data);
@@ -4054,6 +4413,18 @@ export class ABCIApplicationClientImpl implements ABCIApplication {
     const promise = this.rpc.request("tendermint.abci.ABCIApplication", "ApplySnapshotChunk", data);
     return promise.then((data) => ResponseApplySnapshotChunk.decode(new _m0.Reader(data)));
   }
+
+  PrepareProposal(request: RequestPrepareProposal): Promise<ResponsePrepareProposal> {
+    const data = RequestPrepareProposal.encode(request).finish();
+    const promise = this.rpc.request("tendermint.abci.ABCIApplication", "PrepareProposal", data);
+    return promise.then((data) => ResponsePrepareProposal.decode(new _m0.Reader(data)));
+  }
+
+  ProcessProposal(request: RequestProcessProposal): Promise<ResponseProcessProposal> {
+    const data = RequestProcessProposal.encode(request).finish();
+    const promise = this.rpc.request("tendermint.abci.ABCIApplication", "ProcessProposal", data);
+    return promise.then((data) => ResponseProcessProposal.decode(new _m0.Reader(data)));
+  }
 }
 
 interface Rpc {