npm - juno-network - Versions diffs - 0.6.0 → 0.8.0 - Mend

juno-network 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1039) hide show

package/module/codegen/tendermint/abci/types.js CHANGED Viewed

@@ -4,33 +4,27 @@ import { ProofOps } from "../crypto/proof";
 import { EvidenceParams, ValidatorParams, VersionParams } from "../types/params";
 import { PublicKey } from "../crypto/keys";
 import * as _m0 from "protobufjs/minimal";
-import { Long, toTimestamp, fromTimestamp } from "@osmonauts/helpers";
+import { Long, toTimestamp, fromTimestamp } from "../../helpers";
 export let CheckTxType;
 (function (CheckTxType) {
   CheckTxType[CheckTxType["NEW"] = 0] = "NEW";
   CheckTxType[CheckTxType["RECHECK"] = 1] = "RECHECK";
   CheckTxType[CheckTxType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(CheckTxType || (CheckTxType = {}));
 export let CheckTxTypeSDKType;
 (function (CheckTxTypeSDKType) {
   CheckTxTypeSDKType[CheckTxTypeSDKType["NEW"] = 0] = "NEW";
   CheckTxTypeSDKType[CheckTxTypeSDKType["RECHECK"] = 1] = "RECHECK";
   CheckTxTypeSDKType[CheckTxTypeSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(CheckTxTypeSDKType || (CheckTxTypeSDKType = {}));
 export function checkTxTypeFromJSON(object) {
   switch (object) {
     case 0:
     case "NEW":
       return CheckTxType.NEW;
     case 1:
     case "RECHECK":
       return CheckTxType.RECHECK;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -41,16 +35,14 @@ export function checkTxTypeToJSON(object) {
   switch (object) {
     case CheckTxType.NEW:
       return "NEW";
     case CheckTxType.RECHECK:
       return "RECHECK";
+    case CheckTxType.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 export let ResponseOfferSnapshot_Result;
 (function (ResponseOfferSnapshot_Result) {
   ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["UNKNOWN"] = 0] = "UNKNOWN";
   ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["ACCEPT"] = 1] = "ACCEPT";
@@ -60,9 +52,7 @@ export let ResponseOfferSnapshot_Result;
   ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["REJECT_SENDER"] = 5] = "REJECT_SENDER";
   ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ResponseOfferSnapshot_Result || (ResponseOfferSnapshot_Result = {}));
 export let ResponseOfferSnapshot_ResultSDKType;
 (function (ResponseOfferSnapshot_ResultSDKType) {
   ResponseOfferSnapshot_ResultSDKType[ResponseOfferSnapshot_ResultSDKType["UNKNOWN"] = 0] = "UNKNOWN";
   ResponseOfferSnapshot_ResultSDKType[ResponseOfferSnapshot_ResultSDKType["ACCEPT"] = 1] = "ACCEPT";
@@ -72,33 +62,26 @@ export let ResponseOfferSnapshot_ResultSDKType;
   ResponseOfferSnapshot_ResultSDKType[ResponseOfferSnapshot_ResultSDKType["REJECT_SENDER"] = 5] = "REJECT_SENDER";
   ResponseOfferSnapshot_ResultSDKType[ResponseOfferSnapshot_ResultSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ResponseOfferSnapshot_ResultSDKType || (ResponseOfferSnapshot_ResultSDKType = {}));
 export function responseOfferSnapshot_ResultFromJSON(object) {
   switch (object) {
     case 0:
     case "UNKNOWN":
       return ResponseOfferSnapshot_Result.UNKNOWN;
     case 1:
     case "ACCEPT":
       return ResponseOfferSnapshot_Result.ACCEPT;
     case 2:
     case "ABORT":
       return ResponseOfferSnapshot_Result.ABORT;
     case 3:
     case "REJECT":
       return ResponseOfferSnapshot_Result.REJECT;
     case 4:
     case "REJECT_FORMAT":
       return ResponseOfferSnapshot_Result.REJECT_FORMAT;
     case 5:
     case "REJECT_SENDER":
       return ResponseOfferSnapshot_Result.REJECT_SENDER;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -109,28 +92,22 @@ export function responseOfferSnapshot_ResultToJSON(object) {
   switch (object) {
     case ResponseOfferSnapshot_Result.UNKNOWN:
       return "UNKNOWN";
     case ResponseOfferSnapshot_Result.ACCEPT:
       return "ACCEPT";
     case ResponseOfferSnapshot_Result.ABORT:
       return "ABORT";
     case ResponseOfferSnapshot_Result.REJECT:
       return "REJECT";
     case ResponseOfferSnapshot_Result.REJECT_FORMAT:
       return "REJECT_FORMAT";
     case ResponseOfferSnapshot_Result.REJECT_SENDER:
       return "REJECT_SENDER";
+    case ResponseOfferSnapshot_Result.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 export let ResponseApplySnapshotChunk_Result;
 (function (ResponseApplySnapshotChunk_Result) {
   ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["UNKNOWN"] = 0] = "UNKNOWN";
   ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["ACCEPT"] = 1] = "ACCEPT";
@@ -140,9 +117,7 @@ export let ResponseApplySnapshotChunk_Result;
   ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["REJECT_SNAPSHOT"] = 5] = "REJECT_SNAPSHOT";
   ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ResponseApplySnapshotChunk_Result || (ResponseApplySnapshotChunk_Result = {}));
 export let ResponseApplySnapshotChunk_ResultSDKType;
 (function (ResponseApplySnapshotChunk_ResultSDKType) {
   ResponseApplySnapshotChunk_ResultSDKType[ResponseApplySnapshotChunk_ResultSDKType["UNKNOWN"] = 0] = "UNKNOWN";
   ResponseApplySnapshotChunk_ResultSDKType[ResponseApplySnapshotChunk_ResultSDKType["ACCEPT"] = 1] = "ACCEPT";
@@ -152,33 +127,26 @@ export let ResponseApplySnapshotChunk_ResultSDKType;
   ResponseApplySnapshotChunk_ResultSDKType[ResponseApplySnapshotChunk_ResultSDKType["REJECT_SNAPSHOT"] = 5] = "REJECT_SNAPSHOT";
   ResponseApplySnapshotChunk_ResultSDKType[ResponseApplySnapshotChunk_ResultSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ResponseApplySnapshotChunk_ResultSDKType || (ResponseApplySnapshotChunk_ResultSDKType = {}));
 export function responseApplySnapshotChunk_ResultFromJSON(object) {
   switch (object) {
     case 0:
     case "UNKNOWN":
       return ResponseApplySnapshotChunk_Result.UNKNOWN;
     case 1:
     case "ACCEPT":
       return ResponseApplySnapshotChunk_Result.ACCEPT;
     case 2:
     case "ABORT":
       return ResponseApplySnapshotChunk_Result.ABORT;
     case 3:
     case "RETRY":
       return ResponseApplySnapshotChunk_Result.RETRY;
     case 4:
     case "RETRY_SNAPSHOT":
       return ResponseApplySnapshotChunk_Result.RETRY_SNAPSHOT;
     case 5:
     case "REJECT_SNAPSHOT":
       return ResponseApplySnapshotChunk_Result.REJECT_SNAPSHOT;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -189,58 +157,46 @@ export function responseApplySnapshotChunk_ResultToJSON(object) {
   switch (object) {
     case ResponseApplySnapshotChunk_Result.UNKNOWN:
       return "UNKNOWN";
     case ResponseApplySnapshotChunk_Result.ACCEPT:
       return "ACCEPT";
     case ResponseApplySnapshotChunk_Result.ABORT:
       return "ABORT";
     case ResponseApplySnapshotChunk_Result.RETRY:
       return "RETRY";
     case ResponseApplySnapshotChunk_Result.RETRY_SNAPSHOT:
       return "RETRY_SNAPSHOT";
     case ResponseApplySnapshotChunk_Result.REJECT_SNAPSHOT:
       return "REJECT_SNAPSHOT";
+    case ResponseApplySnapshotChunk_Result.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 export let EvidenceType;
 (function (EvidenceType) {
   EvidenceType[EvidenceType["UNKNOWN"] = 0] = "UNKNOWN";
   EvidenceType[EvidenceType["DUPLICATE_VOTE"] = 1] = "DUPLICATE_VOTE";
   EvidenceType[EvidenceType["LIGHT_CLIENT_ATTACK"] = 2] = "LIGHT_CLIENT_ATTACK";
   EvidenceType[EvidenceType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(EvidenceType || (EvidenceType = {}));
 export let EvidenceTypeSDKType;
 (function (EvidenceTypeSDKType) {
   EvidenceTypeSDKType[EvidenceTypeSDKType["UNKNOWN"] = 0] = "UNKNOWN";
   EvidenceTypeSDKType[EvidenceTypeSDKType["DUPLICATE_VOTE"] = 1] = "DUPLICATE_VOTE";
   EvidenceTypeSDKType[EvidenceTypeSDKType["LIGHT_CLIENT_ATTACK"] = 2] = "LIGHT_CLIENT_ATTACK";
   EvidenceTypeSDKType[EvidenceTypeSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(EvidenceTypeSDKType || (EvidenceTypeSDKType = {}));
 export function evidenceTypeFromJSON(object) {
   switch (object) {
     case 0:
     case "UNKNOWN":
       return EvidenceType.UNKNOWN;
     case 1:
     case "DUPLICATE_VOTE":
       return EvidenceType.DUPLICATE_VOTE;
     case 2:
     case "LIGHT_CLIENT_ATTACK":
       return EvidenceType.LIGHT_CLIENT_ATTACK;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -251,18 +207,15 @@ export function evidenceTypeToJSON(object) {
   switch (object) {
     case EvidenceType.UNKNOWN:
       return "UNKNOWN";
     case EvidenceType.DUPLICATE_VOTE:
       return "DUPLICATE_VOTE";
     case EvidenceType.LIGHT_CLIENT_ATTACK:
       return "LIGHT_CLIENT_ATTACK";
+    case EvidenceType.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 function createBaseRequest() {
   return {
     echo: undefined,
@@ -282,150 +235,114 @@ function createBaseRequest() {
     applySnapshotChunk: undefined
   };
 }
 export const Request = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.echo !== undefined) {
       RequestEcho.encode(message.echo, writer.uint32(10).fork()).ldelim();
     }
     if (message.flush !== undefined) {
       RequestFlush.encode(message.flush, writer.uint32(18).fork()).ldelim();
     }
     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();
     }
     if (message.query !== undefined) {
       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();
     }
     if (message.listSnapshots !== undefined) {
       RequestListSnapshots.encode(message.listSnapshots, writer.uint32(98).fork()).ldelim();
     }
     if (message.offerSnapshot !== undefined) {
       RequestOfferSnapshot.encode(message.offerSnapshot, writer.uint32(106).fork()).ldelim();
     }
     if (message.loadSnapshotChunk !== undefined) {
       RequestLoadSnapshotChunk.encode(message.loadSnapshotChunk, writer.uint32(114).fork()).ldelim();
     }
     if (message.applySnapshotChunk !== undefined) {
       RequestApplySnapshotChunk.encode(message.applySnapshotChunk, writer.uint32(122).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.echo = RequestEcho.decode(reader, reader.uint32());
           break;
         case 2:
           message.flush = RequestFlush.decode(reader, reader.uint32());
           break;
         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;
         case 6:
           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;
         case 12:
           message.listSnapshots = RequestListSnapshots.decode(reader, reader.uint32());
           break;
         case 13:
           message.offerSnapshot = RequestOfferSnapshot.decode(reader, reader.uint32());
           break;
         case 14:
           message.loadSnapshotChunk = RequestLoadSnapshotChunk.decode(reader, reader.uint32());
           break;
         case 15:
           message.applySnapshotChunk = RequestApplySnapshotChunk.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseRequest();
     message.echo = object.echo !== undefined && object.echo !== null ? RequestEcho.fromPartial(object.echo) : undefined;
@@ -445,90 +362,69 @@ export const Request = {
     message.applySnapshotChunk = object.applySnapshotChunk !== undefined && object.applySnapshotChunk !== null ? RequestApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : undefined;
     return message;
   }
 };
 function createBaseRequestEcho() {
   return {
     message: ""
   };
 }
 export const RequestEcho = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.message !== "") {
       writer.uint32(10).string(message.message);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestEcho();
     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;
   },
   fromPartial(object) {
     var _object$message;
     const message = createBaseRequestEcho();
     message.message = (_object$message = object.message) !== null && _object$message !== void 0 ? _object$message : "";
     return message;
   }
 };
 function createBaseRequestFlush() {
   return {};
 }
 export const RequestFlush = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestFlush();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseRequestFlush();
     return message;
   }
 };
 function createBaseRequestInfo() {
   return {
     version: "",
@@ -536,123 +432,95 @@ function createBaseRequestInfo() {
     p2pVersion: Long.UZERO
   };
 }
 export const RequestInfo = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.version !== "") {
       writer.uint32(10).string(message.version);
     }
     if (!message.blockVersion.isZero()) {
       writer.uint32(16).uint64(message.blockVersion);
     }
     if (!message.p2pVersion.isZero()) {
       writer.uint32(24).uint64(message.p2pVersion);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestInfo();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.version = reader.string();
           break;
         case 2:
           message.blockVersion = reader.uint64();
           break;
         case 3:
           message.p2pVersion = reader.uint64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$version;
     const message = createBaseRequestInfo();
     message.version = (_object$version = object.version) !== null && _object$version !== void 0 ? _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() {
   return {
     key: "",
     value: ""
   };
 }
 export const RequestSetOption = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.key !== "") {
       writer.uint32(10).string(message.key);
     }
     if (message.value !== "") {
       writer.uint32(18).string(message.value);
     }
     return writer;
   },
   decode(input, length) {
     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;
   },
   fromPartial(object) {
     var _object$key, _object$value;
     const message = createBaseRequestSetOption();
     message.key = (_object$key = object.key) !== null && _object$key !== void 0 ? _object$key : "";
     message.value = (_object$value = object.value) !== null && _object$value !== void 0 ? _object$value : "";
     return message;
   }
 };
 function createBaseRequestInitChain() {
   return {
     time: undefined,
@@ -663,81 +531,62 @@ function createBaseRequestInitChain() {
     initialHeight: Long.ZERO
   };
 }
 export const RequestInitChain = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.time !== undefined) {
       Timestamp.encode(toTimestamp(message.time), writer.uint32(10).fork()).ldelim();
     }
     if (message.chainId !== "") {
       writer.uint32(18).string(message.chainId);
     }
     if (message.consensusParams !== undefined) {
       ConsensusParams.encode(message.consensusParams, writer.uint32(26).fork()).ldelim();
     }
     for (const v of message.validators) {
       ValidatorUpdate.encode(v, writer.uint32(34).fork()).ldelim();
     }
     if (message.appStateBytes.length !== 0) {
       writer.uint32(42).bytes(message.appStateBytes);
     }
     if (!message.initialHeight.isZero()) {
       writer.uint32(48).int64(message.initialHeight);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestInitChain();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 2:
           message.chainId = reader.string();
           break;
         case 3:
           message.consensusParams = ConsensusParams.decode(reader, reader.uint32());
           break;
         case 4:
           message.validators.push(ValidatorUpdate.decode(reader, reader.uint32()));
           break;
         case 5:
           message.appStateBytes = reader.bytes();
           break;
         case 6:
           message.initialHeight = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$time, _object$chainId, _object$validators, _object$appStateBytes;
     const message = createBaseRequestInitChain();
     message.time = (_object$time = object.time) !== null && _object$time !== void 0 ? _object$time : undefined;
     message.chainId = (_object$chainId = object.chainId) !== null && _object$chainId !== void 0 ? _object$chainId : "";
@@ -747,9 +596,7 @@ export const RequestInitChain = {
     message.initialHeight = object.initialHeight !== undefined && object.initialHeight !== null ? Long.fromValue(object.initialHeight) : Long.ZERO;
     return message;
   }
 };
 function createBaseRequestQuery() {
   return {
     data: new Uint8Array(),
@@ -758,65 +605,50 @@ function createBaseRequestQuery() {
     prove: false
   };
 }
 export const RequestQuery = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.data.length !== 0) {
       writer.uint32(10).bytes(message.data);
     }
     if (message.path !== "") {
       writer.uint32(18).string(message.path);
     }
     if (!message.height.isZero()) {
       writer.uint32(24).int64(message.height);
     }
     if (message.prove === true) {
       writer.uint32(32).bool(message.prove);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestQuery();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.data = reader.bytes();
           break;
         case 2:
           message.path = reader.string();
           break;
         case 3:
           message.height = reader.int64();
           break;
         case 4:
           message.prove = reader.bool();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$data, _object$path, _object$prove;
     const message = createBaseRequestQuery();
     message.data = (_object$data = object.data) !== null && _object$data !== void 0 ? _object$data : new Uint8Array();
     message.path = (_object$path = object.path) !== null && _object$path !== void 0 ? _object$path : "";
@@ -824,9 +656,7 @@ export const RequestQuery = {
     message.prove = (_object$prove = object.prove) !== null && _object$prove !== void 0 ? _object$prove : false;
     return message;
   }
 };
 function createBaseRequestBeginBlock() {
   return {
     hash: new Uint8Array(),
@@ -835,65 +665,50 @@ function createBaseRequestBeginBlock() {
     byzantineValidators: []
   };
 }
 export const RequestBeginBlock = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     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;
   },
   fromPartial(object) {
     var _object$hash, _object$byzantineVali;
     const message = createBaseRequestBeginBlock();
     message.hash = (_object$hash = object.hash) !== null && _object$hash !== void 0 ? _object$hash : new Uint8Array();
     message.header = object.header !== undefined && object.header !== null ? Header.fromPartial(object.header) : undefined;
@@ -901,283 +716,218 @@ export const RequestBeginBlock = {
     message.byzantineValidators = ((_object$byzantineVali = object.byzantineValidators) === null || _object$byzantineVali === void 0 ? void 0 : _object$byzantineVali.map(e => Evidence.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseRequestCheckTx() {
   return {
     tx: new Uint8Array(),
     type: 0
   };
 }
 export const RequestCheckTx = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.tx.length !== 0) {
       writer.uint32(10).bytes(message.tx);
     }
     if (message.type !== 0) {
       writer.uint32(16).int32(message.type);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestCheckTx();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.tx = reader.bytes();
           break;
         case 2:
           message.type = reader.int32();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$tx, _object$type;
     const message = createBaseRequestCheckTx();
     message.tx = (_object$tx = object.tx) !== null && _object$tx !== void 0 ? _object$tx : new Uint8Array();
     message.type = (_object$type = object.type) !== null && _object$type !== void 0 ? _object$type : 0;
     return message;
   }
 };
 function createBaseRequestDeliverTx() {
   return {
     tx: new Uint8Array()
   };
 }
 export const RequestDeliverTx = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.tx.length !== 0) {
       writer.uint32(10).bytes(message.tx);
     }
     return writer;
   },
   decode(input, length) {
     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;
   },
   fromPartial(object) {
     var _object$tx2;
     const message = createBaseRequestDeliverTx();
     message.tx = (_object$tx2 = object.tx) !== null && _object$tx2 !== void 0 ? _object$tx2 : new Uint8Array();
     return message;
   }
 };
 function createBaseRequestEndBlock() {
   return {
     height: Long.ZERO
   };
 }
 export const RequestEndBlock = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.height.isZero()) {
       writer.uint32(8).int64(message.height);
     }
     return writer;
   },
   decode(input, length) {
     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();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseRequestEndBlock();
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
     return message;
   }
 };
 function createBaseRequestCommit() {
   return {};
 }
 export const RequestCommit = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestCommit();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseRequestCommit();
     return message;
   }
 };
 function createBaseRequestListSnapshots() {
   return {};
 }
 export const RequestListSnapshots = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestListSnapshots();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseRequestListSnapshots();
     return message;
   }
 };
 function createBaseRequestOfferSnapshot() {
   return {
     snapshot: undefined,
     appHash: new Uint8Array()
   };
 }
 export const RequestOfferSnapshot = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.snapshot !== undefined) {
       Snapshot.encode(message.snapshot, writer.uint32(10).fork()).ldelim();
     }
     if (message.appHash.length !== 0) {
       writer.uint32(18).bytes(message.appHash);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestOfferSnapshot();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.snapshot = Snapshot.decode(reader, reader.uint32());
           break;
         case 2:
           message.appHash = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$appHash;
     const message = createBaseRequestOfferSnapshot();
     message.snapshot = object.snapshot !== undefined && object.snapshot !== null ? Snapshot.fromPartial(object.snapshot) : undefined;
     message.appHash = (_object$appHash = object.appHash) !== null && _object$appHash !== void 0 ? _object$appHash : new Uint8Array();
     return message;
   }
 };
 function createBaseRequestLoadSnapshotChunk() {
   return {
     height: Long.UZERO,
@@ -1185,66 +935,51 @@ function createBaseRequestLoadSnapshotChunk() {
     chunk: 0
   };
 }
 export const RequestLoadSnapshotChunk = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.height.isZero()) {
       writer.uint32(8).uint64(message.height);
     }
     if (message.format !== 0) {
       writer.uint32(16).uint32(message.format);
     }
     if (message.chunk !== 0) {
       writer.uint32(24).uint32(message.chunk);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestLoadSnapshotChunk();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.height = reader.uint64();
           break;
         case 2:
           message.format = reader.uint32();
           break;
         case 3:
           message.chunk = reader.uint32();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$format, _object$chunk;
     const message = createBaseRequestLoadSnapshotChunk();
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.UZERO;
     message.format = (_object$format = object.format) !== null && _object$format !== void 0 ? _object$format : 0;
     message.chunk = (_object$chunk = object.chunk) !== null && _object$chunk !== void 0 ? _object$chunk : 0;
     return message;
   }
 };
 function createBaseRequestApplySnapshotChunk() {
   return {
     index: 0,
@@ -1252,66 +987,51 @@ function createBaseRequestApplySnapshotChunk() {
     sender: ""
   };
 }
 export const RequestApplySnapshotChunk = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.index !== 0) {
       writer.uint32(8).uint32(message.index);
     }
     if (message.chunk.length !== 0) {
       writer.uint32(18).bytes(message.chunk);
     }
     if (message.sender !== "") {
       writer.uint32(26).string(message.sender);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseRequestApplySnapshotChunk();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.index = reader.uint32();
           break;
         case 2:
           message.chunk = reader.bytes();
           break;
         case 3:
           message.sender = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$index, _object$chunk2, _object$sender;
     const message = createBaseRequestApplySnapshotChunk();
     message.index = (_object$index = object.index) !== null && _object$index !== void 0 ? _object$index : 0;
     message.chunk = (_object$chunk2 = object.chunk) !== null && _object$chunk2 !== void 0 ? _object$chunk2 : new Uint8Array();
     message.sender = (_object$sender = object.sender) !== null && _object$sender !== void 0 ? _object$sender : "";
     return message;
   }
 };
 function createBaseResponse() {
   return {
     exception: undefined,
@@ -1332,158 +1052,120 @@ function createBaseResponse() {
     applySnapshotChunk: undefined
   };
 }
 export const Response = {
   encode(message, writer = _m0.Writer.create()) {
     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();
     }
     if (message.deliverTx !== undefined) {
       ResponseDeliverTx.encode(message.deliverTx, writer.uint32(82).fork()).ldelim();
     }
     if (message.endBlock !== undefined) {
       ResponseEndBlock.encode(message.endBlock, writer.uint32(90).fork()).ldelim();
     }
     if (message.commit !== undefined) {
       ResponseCommit.encode(message.commit, writer.uint32(98).fork()).ldelim();
     }
     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();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.exception = ResponseException.decode(reader, reader.uint32());
           break;
         case 2:
           message.echo = ResponseEcho.decode(reader, reader.uint32());
           break;
         case 3:
           message.flush = ResponseFlush.decode(reader, reader.uint32());
           break;
         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;
         case 7:
           message.query = ResponseQuery.decode(reader, reader.uint32());
           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());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseResponse();
     message.exception = object.exception !== undefined && object.exception !== null ? ResponseException.fromPartial(object.exception) : undefined;
@@ -1504,137 +1186,105 @@ export const Response = {
     message.applySnapshotChunk = object.applySnapshotChunk !== undefined && object.applySnapshotChunk !== null ? ResponseApplySnapshotChunk.fromPartial(object.applySnapshotChunk) : undefined;
     return message;
   }
 };
 function createBaseResponseException() {
   return {
     error: ""
   };
 }
 export const ResponseException = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.error !== "") {
       writer.uint32(10).string(message.error);
     }
     return writer;
   },
   decode(input, length) {
     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;
   },
   fromPartial(object) {
     var _object$error;
     const message = createBaseResponseException();
     message.error = (_object$error = object.error) !== null && _object$error !== void 0 ? _object$error : "";
     return message;
   }
 };
 function createBaseResponseEcho() {
   return {
     message: ""
   };
 }
 export const ResponseEcho = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.message !== "") {
       writer.uint32(10).string(message.message);
     }
     return writer;
   },
   decode(input, length) {
     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;
   },
   fromPartial(object) {
     var _object$message2;
     const message = createBaseResponseEcho();
     message.message = (_object$message2 = object.message) !== null && _object$message2 !== void 0 ? _object$message2 : "";
     return message;
   }
 };
 function createBaseResponseFlush() {
   return {};
 }
 export const ResponseFlush = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     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;
   },
   fromPartial(_) {
     const message = createBaseResponseFlush();
     return message;
   }
 };
 function createBaseResponseInfo() {
   return {
     data: "",
@@ -1644,73 +1294,56 @@ function createBaseResponseInfo() {
     lastBlockAppHash: new Uint8Array()
   };
 }
 export const ResponseInfo = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     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();
           break;
         case 4:
           message.lastBlockHeight = reader.int64();
           break;
         case 5:
           message.lastBlockAppHash = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$data2, _object$version2, _object$lastBlockAppH;
     const message = createBaseResponseInfo();
     message.data = (_object$data2 = object.data) !== null && _object$data2 !== void 0 ? _object$data2 : "";
     message.version = (_object$version2 = object.version) !== null && _object$version2 !== void 0 ? _object$version2 : "";
@@ -1719,9 +1352,7 @@ export const ResponseInfo = {
     message.lastBlockAppHash = (_object$lastBlockAppH = object.lastBlockAppHash) !== null && _object$lastBlockAppH !== void 0 ? _object$lastBlockAppH : new Uint8Array();
     return message;
   }
 };
 function createBaseResponseSetOption() {
   return {
     code: 0,
@@ -1729,66 +1360,51 @@ function createBaseResponseSetOption() {
     info: ""
   };
 }
 export const ResponseSetOption = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     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;
   },
   fromPartial(object) {
     var _object$code, _object$log, _object$info;
     const message = createBaseResponseSetOption();
     message.code = (_object$code = object.code) !== null && _object$code !== void 0 ? _object$code : 0;
     message.log = (_object$log = object.log) !== null && _object$log !== void 0 ? _object$log : "";
     message.info = (_object$info = object.info) !== null && _object$info !== void 0 ? _object$info : "";
     return message;
   }
 };
 function createBaseResponseInitChain() {
   return {
     consensusParams: undefined,
@@ -1796,66 +1412,51 @@ function createBaseResponseInitChain() {
     appHash: new Uint8Array()
   };
 }
 export const ResponseInitChain = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseInitChain();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           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:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$validators2, _object$appHash2;
     const message = createBaseResponseInitChain();
     message.consensusParams = object.consensusParams !== undefined && object.consensusParams !== null ? ConsensusParams.fromPartial(object.consensusParams) : undefined;
     message.validators = ((_object$validators2 = object.validators) === null || _object$validators2 === void 0 ? void 0 : _object$validators2.map(e => ValidatorUpdate.fromPartial(e))) || [];
     message.appHash = (_object$appHash2 = object.appHash) !== null && _object$appHash2 !== void 0 ? _object$appHash2 : new Uint8Array();
     return message;
   }
 };
 function createBaseResponseQuery() {
   return {
     code: 0,
@@ -1869,105 +1470,80 @@ function createBaseResponseQuery() {
     codespace: ""
   };
 }
 export const ResponseQuery = {
   encode(message, writer = _m0.Writer.create()) {
     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);
     }
     if (!message.index.isZero()) {
       writer.uint32(40).int64(message.index);
     }
     if (message.key.length !== 0) {
       writer.uint32(50).bytes(message.key);
     }
     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(82).string(message.codespace);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseQuery();
     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;
         case 5:
           message.index = reader.int64();
           break;
         case 6:
           message.key = reader.bytes();
           break;
         case 7:
           message.value = reader.bytes();
           break;
         case 8:
           message.proofOps = ProofOps.decode(reader, reader.uint32());
           break;
         case 9:
           message.height = reader.int64();
           break;
         case 10:
           message.codespace = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$code2, _object$log2, _object$info2, _object$key2, _object$value2, _object$codespace;
     const message = createBaseResponseQuery();
     message.code = (_object$code2 = object.code) !== null && _object$code2 !== void 0 ? _object$code2 : 0;
     message.log = (_object$log2 = object.log) !== null && _object$log2 !== void 0 ? _object$log2 : "";
@@ -1980,56 +1556,43 @@ export const ResponseQuery = {
     message.codespace = (_object$codespace = object.codespace) !== null && _object$codespace !== void 0 ? _object$codespace : "";
     return message;
   }
 };
 function createBaseResponseBeginBlock() {
   return {
     events: []
   };
 }
 export const ResponseBeginBlock = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.events) {
       Event.encode(v, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseBeginBlock();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.events.push(Event.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$events;
     const message = createBaseResponseBeginBlock();
     message.events = ((_object$events = object.events) === null || _object$events === void 0 ? void 0 : _object$events.map(e => Event.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseResponseCheckTx() {
   return {
     code: 0,
@@ -2042,97 +1605,74 @@ function createBaseResponseCheckTx() {
     codespace: ""
   };
 }
 export const ResponseCheckTx = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseCheckTx();
     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();
           break;
         case 6:
           message.gasUsed = reader.int64();
           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;
   },
   fromPartial(object) {
     var _object$code3, _object$data3, _object$log3, _object$info3, _object$events2, _object$codespace2;
     const message = createBaseResponseCheckTx();
     message.code = (_object$code3 = object.code) !== null && _object$code3 !== void 0 ? _object$code3 : 0;
     message.data = (_object$data3 = object.data) !== null && _object$data3 !== void 0 ? _object$data3 : new Uint8Array();
@@ -2144,9 +1684,7 @@ export const ResponseCheckTx = {
     message.codespace = (_object$codespace2 = object.codespace) !== null && _object$codespace2 !== void 0 ? _object$codespace2 : "";
     return message;
   }
 };
 function createBaseResponseDeliverTx() {
   return {
     code: 0,
@@ -2159,97 +1697,74 @@ function createBaseResponseDeliverTx() {
     codespace: ""
   };
 }
 export const ResponseDeliverTx = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseDeliverTx();
     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();
           break;
         case 6:
           message.gasUsed = reader.int64();
           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;
   },
   fromPartial(object) {
     var _object$code4, _object$data4, _object$log4, _object$info4, _object$events3, _object$codespace3;
     const message = createBaseResponseDeliverTx();
     message.code = (_object$code4 = object.code) !== null && _object$code4 !== void 0 ? _object$code4 : 0;
     message.data = (_object$data4 = object.data) !== null && _object$data4 !== void 0 ? _object$data4 : new Uint8Array();
@@ -2261,9 +1776,7 @@ export const ResponseDeliverTx = {
     message.codespace = (_object$codespace3 = object.codespace) !== null && _object$codespace3 !== void 0 ? _object$codespace3 : "";
     return message;
   }
 };
 function createBaseResponseEndBlock() {
   return {
     validatorUpdates: [],
@@ -2271,264 +1784,203 @@ function createBaseResponseEndBlock() {
     events: []
   };
 }
 export const ResponseEndBlock = {
   encode(message, writer = _m0.Writer.create()) {
     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, length) {
     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;
   },
   fromPartial(object) {
     var _object$validatorUpda, _object$events4;
     const message = createBaseResponseEndBlock();
     message.validatorUpdates = ((_object$validatorUpda = object.validatorUpdates) === null || _object$validatorUpda === void 0 ? void 0 : _object$validatorUpda.map(e => ValidatorUpdate.fromPartial(e))) || [];
     message.consensusParamUpdates = object.consensusParamUpdates !== undefined && object.consensusParamUpdates !== null ? ConsensusParams.fromPartial(object.consensusParamUpdates) : undefined;
     message.events = ((_object$events4 = object.events) === null || _object$events4 === void 0 ? void 0 : _object$events4.map(e => Event.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseResponseCommit() {
   return {
     data: new Uint8Array(),
     retainHeight: Long.ZERO
   };
 }
 export const ResponseCommit = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.data.length !== 0) {
       writer.uint32(18).bytes(message.data);
     }
     if (!message.retainHeight.isZero()) {
       writer.uint32(24).int64(message.retainHeight);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseCommit();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 2:
           message.data = reader.bytes();
           break;
         case 3:
           message.retainHeight = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$data5;
     const message = createBaseResponseCommit();
     message.data = (_object$data5 = object.data) !== null && _object$data5 !== void 0 ? _object$data5 : new Uint8Array();
     message.retainHeight = object.retainHeight !== undefined && object.retainHeight !== null ? Long.fromValue(object.retainHeight) : Long.ZERO;
     return message;
   }
 };
 function createBaseResponseListSnapshots() {
   return {
     snapshots: []
   };
 }
 export const ResponseListSnapshots = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.snapshots) {
       Snapshot.encode(v, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseListSnapshots();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.snapshots.push(Snapshot.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$snapshots;
     const message = createBaseResponseListSnapshots();
     message.snapshots = ((_object$snapshots = object.snapshots) === null || _object$snapshots === void 0 ? void 0 : _object$snapshots.map(e => Snapshot.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseResponseOfferSnapshot() {
   return {
     result: 0
   };
 }
 export const ResponseOfferSnapshot = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.result !== 0) {
       writer.uint32(8).int32(message.result);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseOfferSnapshot();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.result = reader.int32();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$result;
     const message = createBaseResponseOfferSnapshot();
     message.result = (_object$result = object.result) !== null && _object$result !== void 0 ? _object$result : 0;
     return message;
   }
 };
 function createBaseResponseLoadSnapshotChunk() {
   return {
     chunk: new Uint8Array()
   };
 }
 export const ResponseLoadSnapshotChunk = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.chunk.length !== 0) {
       writer.uint32(10).bytes(message.chunk);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseLoadSnapshotChunk();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.chunk = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$chunk3;
     const message = createBaseResponseLoadSnapshotChunk();
     message.chunk = (_object$chunk3 = object.chunk) !== null && _object$chunk3 !== void 0 ? _object$chunk3 : new Uint8Array();
     return message;
   }
 };
 function createBaseResponseApplySnapshotChunk() {
   return {
     result: 0,
@@ -2536,79 +1988,60 @@ function createBaseResponseApplySnapshotChunk() {
     rejectSenders: []
   };
 }
 export const ResponseApplySnapshotChunk = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.result !== 0) {
       writer.uint32(8).int32(message.result);
     }
     writer.uint32(18).fork();
     for (const v of message.refetchChunks) {
       writer.uint32(v);
     }
     writer.ldelim();
     for (const v of message.rejectSenders) {
       writer.uint32(26).string(v);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponseApplySnapshotChunk();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.result = reader.int32();
           break;
         case 2:
           if ((tag & 7) === 2) {
             const end2 = reader.uint32() + reader.pos;
             while (reader.pos < end2) {
               message.refetchChunks.push(reader.uint32());
             }
           } else {
             message.refetchChunks.push(reader.uint32());
           }
           break;
         case 3:
           message.rejectSenders.push(reader.string());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$result2, _object$refetchChunks, _object$rejectSenders;
     const message = createBaseResponseApplySnapshotChunk();
     message.result = (_object$result2 = object.result) !== null && _object$result2 !== void 0 ? _object$result2 : 0;
     message.refetchChunks = ((_object$refetchChunks = object.refetchChunks) === null || _object$refetchChunks === void 0 ? void 0 : _object$refetchChunks.map(e => e)) || [];
     message.rejectSenders = ((_object$rejectSenders = object.rejectSenders) === null || _object$rejectSenders === void 0 ? void 0 : _object$rejectSenders.map(e => e)) || [];
     return message;
   }
 };
 function createBaseConsensusParams() {
   return {
     block: undefined,
@@ -2617,62 +2050,48 @@ function createBaseConsensusParams() {
     version: undefined
   };
 }
 export const ConsensusParams = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.block !== undefined) {
       BlockParams.encode(message.block, writer.uint32(10).fork()).ldelim();
     }
     if (message.evidence !== undefined) {
       EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
     }
     if (message.validator !== undefined) {
       ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
     }
     if (message.version !== undefined) {
       VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseConsensusParams();
     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());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseConsensusParams();
     message.block = object.block !== undefined && object.block !== null ? BlockParams.fromPartial(object.block) : undefined;
@@ -2681,178 +2100,138 @@ export const ConsensusParams = {
     message.version = object.version !== undefined && object.version !== null ? VersionParams.fromPartial(object.version) : undefined;
     return message;
   }
 };
 function createBaseBlockParams() {
   return {
     maxBytes: Long.ZERO,
     maxGas: Long.ZERO
   };
 }
 export const BlockParams = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.maxBytes.isZero()) {
       writer.uint32(8).int64(message.maxBytes);
     }
     if (!message.maxGas.isZero()) {
       writer.uint32(16).int64(message.maxGas);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseBlockParams();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.maxBytes = reader.int64();
           break;
         case 2:
           message.maxGas = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     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;
     return message;
   }
 };
 function createBaseLastCommitInfo() {
   return {
     round: 0,
     votes: []
   };
 }
 export const LastCommitInfo = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.round !== 0) {
       writer.uint32(8).int32(message.round);
     }
     for (const v of message.votes) {
       VoteInfo.encode(v, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseLastCommitInfo();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.round = reader.int32();
           break;
         case 2:
           message.votes.push(VoteInfo.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$round, _object$votes;
     const message = createBaseLastCommitInfo();
     message.round = (_object$round = object.round) !== null && _object$round !== void 0 ? _object$round : 0;
     message.votes = ((_object$votes = object.votes) === null || _object$votes === void 0 ? void 0 : _object$votes.map(e => VoteInfo.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseEvent() {
   return {
     type: "",
     attributes: []
   };
 }
 export const Event = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.type !== "") {
       writer.uint32(10).string(message.type);
     }
     for (const v of message.attributes) {
       EventAttribute.encode(v, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEvent();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.type = reader.string();
           break;
         case 2:
           message.attributes.push(EventAttribute.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$type2, _object$attributes;
     const message = createBaseEvent();
     message.type = (_object$type2 = object.type) !== null && _object$type2 !== void 0 ? _object$type2 : "";
     message.attributes = ((_object$attributes = object.attributes) === null || _object$attributes === void 0 ? void 0 : _object$attributes.map(e => EventAttribute.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseEventAttribute() {
   return {
     key: new Uint8Array(),
@@ -2860,66 +2239,51 @@ function createBaseEventAttribute() {
     index: false
   };
 }
 export const EventAttribute = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
     if (message.value.length !== 0) {
       writer.uint32(18).bytes(message.value);
     }
     if (message.index === true) {
       writer.uint32(24).bool(message.index);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEventAttribute();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.key = reader.bytes();
           break;
         case 2:
           message.value = reader.bytes();
           break;
         case 3:
           message.index = reader.bool();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$key3, _object$value3, _object$index2;
     const message = createBaseEventAttribute();
     message.key = (_object$key3 = object.key) !== null && _object$key3 !== void 0 ? _object$key3 : new Uint8Array();
     message.value = (_object$value3 = object.value) !== null && _object$value3 !== void 0 ? _object$value3 : new Uint8Array();
     message.index = (_object$index2 = object.index) !== null && _object$index2 !== void 0 ? _object$index2 : false;
     return message;
   }
 };
 function createBaseTxResult() {
   return {
     height: Long.ZERO,
@@ -2928,65 +2292,50 @@ function createBaseTxResult() {
     result: undefined
   };
 }
 export const TxResult = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.height.isZero()) {
       writer.uint32(8).int64(message.height);
     }
     if (message.index !== 0) {
       writer.uint32(16).uint32(message.index);
     }
     if (message.tx.length !== 0) {
       writer.uint32(26).bytes(message.tx);
     }
     if (message.result !== undefined) {
       ResponseDeliverTx.encode(message.result, writer.uint32(34).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTxResult();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.height = reader.int64();
           break;
         case 2:
           message.index = reader.uint32();
           break;
         case 3:
           message.tx = reader.bytes();
           break;
         case 4:
           message.result = ResponseDeliverTx.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$index3, _object$tx3;
     const message = createBaseTxResult();
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
     message.index = (_object$index3 = object.index) !== null && _object$index3 !== void 0 ? _object$index3 : 0;
@@ -2994,178 +2343,138 @@ export const TxResult = {
     message.result = object.result !== undefined && object.result !== null ? ResponseDeliverTx.fromPartial(object.result) : undefined;
     return message;
   }
 };
 function createBaseValidator() {
   return {
     address: new Uint8Array(),
     power: Long.ZERO
   };
 }
 export const Validator = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.address.length !== 0) {
       writer.uint32(10).bytes(message.address);
     }
     if (!message.power.isZero()) {
       writer.uint32(24).int64(message.power);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseValidator();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.address = reader.bytes();
           break;
         case 3:
           message.power = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$address;
     const message = createBaseValidator();
     message.address = (_object$address = object.address) !== null && _object$address !== void 0 ? _object$address : new Uint8Array();
     message.power = object.power !== undefined && object.power !== null ? Long.fromValue(object.power) : Long.ZERO;
     return message;
   }
 };
 function createBaseValidatorUpdate() {
   return {
     pubKey: undefined,
     power: Long.ZERO
   };
 }
 export const ValidatorUpdate = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.pubKey !== undefined) {
       PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
     }
     if (!message.power.isZero()) {
       writer.uint32(16).int64(message.power);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseValidatorUpdate();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.pubKey = PublicKey.decode(reader, reader.uint32());
           break;
         case 2:
           message.power = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseValidatorUpdate();
     message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? PublicKey.fromPartial(object.pubKey) : undefined;
     message.power = object.power !== undefined && object.power !== null ? Long.fromValue(object.power) : Long.ZERO;
     return message;
   }
 };
 function createBaseVoteInfo() {
   return {
     validator: undefined,
     signedLastBlock: false
   };
 }
 export const VoteInfo = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.validator !== undefined) {
       Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
     }
     if (message.signedLastBlock === true) {
       writer.uint32(16).bool(message.signedLastBlock);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseVoteInfo();
     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;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$signedLastBlo;
     const message = createBaseVoteInfo();
     message.validator = object.validator !== undefined && object.validator !== null ? Validator.fromPartial(object.validator) : undefined;
     message.signedLastBlock = (_object$signedLastBlo = object.signedLastBlock) !== null && _object$signedLastBlo !== void 0 ? _object$signedLastBlo : false;
     return message;
   }
 };
 function createBaseEvidence() {
   return {
     type: 0,
@@ -3175,73 +2484,56 @@ function createBaseEvidence() {
     totalVotingPower: Long.ZERO
   };
 }
 export const Evidence = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.type !== 0) {
       writer.uint32(8).int32(message.type);
     }
     if (message.validator !== undefined) {
       Validator.encode(message.validator, writer.uint32(18).fork()).ldelim();
     }
     if (!message.height.isZero()) {
       writer.uint32(24).int64(message.height);
     }
     if (message.time !== undefined) {
       Timestamp.encode(toTimestamp(message.time), writer.uint32(34).fork()).ldelim();
     }
     if (!message.totalVotingPower.isZero()) {
       writer.uint32(40).int64(message.totalVotingPower);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEvidence();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.type = reader.int32();
           break;
         case 2:
           message.validator = Validator.decode(reader, reader.uint32());
           break;
         case 3:
           message.height = reader.int64();
           break;
         case 4:
           message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 5:
           message.totalVotingPower = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$type3, _object$time2;
     const message = createBaseEvidence();
     message.type = (_object$type3 = object.type) !== null && _object$type3 !== void 0 ? _object$type3 : 0;
     message.validator = object.validator !== undefined && object.validator !== null ? Validator.fromPartial(object.validator) : undefined;
@@ -3250,9 +2542,7 @@ export const Evidence = {
     message.totalVotingPower = object.totalVotingPower !== undefined && object.totalVotingPower !== null ? Long.fromValue(object.totalVotingPower) : Long.ZERO;
     return message;
   }
 };
 function createBaseSnapshot() {
   return {
     height: Long.UZERO,
@@ -3262,73 +2552,56 @@ function createBaseSnapshot() {
     metadata: new Uint8Array()
   };
 }
 export const Snapshot = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.height.isZero()) {
       writer.uint32(8).uint64(message.height);
     }
     if (message.format !== 0) {
       writer.uint32(16).uint32(message.format);
     }
     if (message.chunks !== 0) {
       writer.uint32(24).uint32(message.chunks);
     }
     if (message.hash.length !== 0) {
       writer.uint32(34).bytes(message.hash);
     }
     if (message.metadata.length !== 0) {
       writer.uint32(42).bytes(message.metadata);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSnapshot();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.height = reader.uint64();
           break;
         case 2:
           message.format = reader.uint32();
           break;
         case 3:
           message.chunks = reader.uint32();
           break;
         case 4:
           message.hash = reader.bytes();
           break;
         case 5:
           message.metadata = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$format2, _object$chunks, _object$hash2, _object$metadata;
     const message = createBaseSnapshot();
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.UZERO;
     message.format = (_object$format2 = object.format) !== null && _object$format2 !== void 0 ? _object$format2 : 0;
@@ -3337,5 +2610,4 @@ export const Snapshot = {
     message.metadata = (_object$metadata = object.metadata) !== null && _object$metadata !== void 0 ? _object$metadata : new Uint8Array();
     return message;
   }
 };