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/types/types.js CHANGED Viewed

@@ -3,12 +3,11 @@ import { Consensus } from "../version/types";
 import { Timestamp } from "../../google/protobuf/timestamp";
 import { ValidatorSet } from "./validator";
 import * as _m0 from "protobufjs/minimal";
-import { toTimestamp, Long, fromTimestamp } from "@osmonauts/helpers";
+import { toTimestamp, Long, fromTimestamp } from "../../helpers";
 /** BlockIdFlag indicates which BlcokID the signature is for */
 export let BlockIDFlag;
 /** BlockIdFlag indicates which BlcokID the signature is for */
 (function (BlockIDFlag) {
   BlockIDFlag[BlockIDFlag["BLOCK_ID_FLAG_UNKNOWN"] = 0] = "BLOCK_ID_FLAG_UNKNOWN";
   BlockIDFlag[BlockIDFlag["BLOCK_ID_FLAG_ABSENT"] = 1] = "BLOCK_ID_FLAG_ABSENT";
@@ -16,9 +15,7 @@ export let BlockIDFlag;
   BlockIDFlag[BlockIDFlag["BLOCK_ID_FLAG_NIL"] = 3] = "BLOCK_ID_FLAG_NIL";
   BlockIDFlag[BlockIDFlag["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(BlockIDFlag || (BlockIDFlag = {}));
 export let BlockIDFlagSDKType;
 (function (BlockIDFlagSDKType) {
   BlockIDFlagSDKType[BlockIDFlagSDKType["BLOCK_ID_FLAG_UNKNOWN"] = 0] = "BLOCK_ID_FLAG_UNKNOWN";
   BlockIDFlagSDKType[BlockIDFlagSDKType["BLOCK_ID_FLAG_ABSENT"] = 1] = "BLOCK_ID_FLAG_ABSENT";
@@ -26,25 +23,20 @@ export let BlockIDFlagSDKType;
   BlockIDFlagSDKType[BlockIDFlagSDKType["BLOCK_ID_FLAG_NIL"] = 3] = "BLOCK_ID_FLAG_NIL";
   BlockIDFlagSDKType[BlockIDFlagSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(BlockIDFlagSDKType || (BlockIDFlagSDKType = {}));
 export function blockIDFlagFromJSON(object) {
   switch (object) {
     case 0:
     case "BLOCK_ID_FLAG_UNKNOWN":
       return BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN;
     case 1:
     case "BLOCK_ID_FLAG_ABSENT":
       return BlockIDFlag.BLOCK_ID_FLAG_ABSENT;
     case 2:
     case "BLOCK_ID_FLAG_COMMIT":
       return BlockIDFlag.BLOCK_ID_FLAG_COMMIT;
     case 3:
     case "BLOCK_ID_FLAG_NIL":
       return BlockIDFlag.BLOCK_ID_FLAG_NIL;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -55,25 +47,21 @@ export function blockIDFlagToJSON(object) {
   switch (object) {
     case BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN:
       return "BLOCK_ID_FLAG_UNKNOWN";
     case BlockIDFlag.BLOCK_ID_FLAG_ABSENT:
       return "BLOCK_ID_FLAG_ABSENT";
     case BlockIDFlag.BLOCK_ID_FLAG_COMMIT:
       return "BLOCK_ID_FLAG_COMMIT";
     case BlockIDFlag.BLOCK_ID_FLAG_NIL:
       return "BLOCK_ID_FLAG_NIL";
+    case BlockIDFlag.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 /** SignedMsgType is a type of signed message in the consensus. */
 export let SignedMsgType;
 /** SignedMsgType is a type of signed message in the consensus. */
 (function (SignedMsgType) {
   SignedMsgType[SignedMsgType["SIGNED_MSG_TYPE_UNKNOWN"] = 0] = "SIGNED_MSG_TYPE_UNKNOWN";
   SignedMsgType[SignedMsgType["SIGNED_MSG_TYPE_PREVOTE"] = 1] = "SIGNED_MSG_TYPE_PREVOTE";
@@ -81,9 +69,7 @@ export let SignedMsgType;
   SignedMsgType[SignedMsgType["SIGNED_MSG_TYPE_PROPOSAL"] = 32] = "SIGNED_MSG_TYPE_PROPOSAL";
   SignedMsgType[SignedMsgType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(SignedMsgType || (SignedMsgType = {}));
 export let SignedMsgTypeSDKType;
 (function (SignedMsgTypeSDKType) {
   SignedMsgTypeSDKType[SignedMsgTypeSDKType["SIGNED_MSG_TYPE_UNKNOWN"] = 0] = "SIGNED_MSG_TYPE_UNKNOWN";
   SignedMsgTypeSDKType[SignedMsgTypeSDKType["SIGNED_MSG_TYPE_PREVOTE"] = 1] = "SIGNED_MSG_TYPE_PREVOTE";
@@ -91,25 +77,20 @@ export let SignedMsgTypeSDKType;
   SignedMsgTypeSDKType[SignedMsgTypeSDKType["SIGNED_MSG_TYPE_PROPOSAL"] = 32] = "SIGNED_MSG_TYPE_PROPOSAL";
   SignedMsgTypeSDKType[SignedMsgTypeSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(SignedMsgTypeSDKType || (SignedMsgTypeSDKType = {}));
 export function signedMsgTypeFromJSON(object) {
   switch (object) {
     case 0:
     case "SIGNED_MSG_TYPE_UNKNOWN":
       return SignedMsgType.SIGNED_MSG_TYPE_UNKNOWN;
     case 1:
     case "SIGNED_MSG_TYPE_PREVOTE":
       return SignedMsgType.SIGNED_MSG_TYPE_PREVOTE;
     case 2:
     case "SIGNED_MSG_TYPE_PRECOMMIT":
       return SignedMsgType.SIGNED_MSG_TYPE_PRECOMMIT;
     case 32:
     case "SIGNED_MSG_TYPE_PROPOSAL":
       return SignedMsgType.SIGNED_MSG_TYPE_PROPOSAL;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -120,18 +101,15 @@ export function signedMsgTypeToJSON(object) {
   switch (object) {
     case SignedMsgType.SIGNED_MSG_TYPE_UNKNOWN:
       return "SIGNED_MSG_TYPE_UNKNOWN";
     case SignedMsgType.SIGNED_MSG_TYPE_PREVOTE:
       return "SIGNED_MSG_TYPE_PREVOTE";
     case SignedMsgType.SIGNED_MSG_TYPE_PRECOMMIT:
       return "SIGNED_MSG_TYPE_PRECOMMIT";
     case SignedMsgType.SIGNED_MSG_TYPE_PROPOSAL:
       return "SIGNED_MSG_TYPE_PROPOSAL";
+    case SignedMsgType.UNRECOGNIZED:
     default:
-      return "UNKNOWN";
+      return "UNRECOGNIZED";
   }
 }
 /** PartsetHeader */
@@ -142,57 +120,44 @@ function createBasePartSetHeader() {
     hash: new Uint8Array()
   };
 }
 export const PartSetHeader = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.total !== 0) {
       writer.uint32(8).uint32(message.total);
     }
     if (message.hash.length !== 0) {
       writer.uint32(18).bytes(message.hash);
     }
     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 = createBasePartSetHeader();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.total = reader.uint32();
           break;
         case 2:
           message.hash = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$total, _object$hash;
     const message = createBasePartSetHeader();
     message.total = (_object$total = object.total) !== null && _object$total !== void 0 ? _object$total : 0;
     message.hash = (_object$hash = object.hash) !== null && _object$hash !== void 0 ? _object$hash : new Uint8Array();
     return message;
   }
 };
 function createBasePart() {
   return {
     index: 0,
@@ -200,123 +165,95 @@ function createBasePart() {
     proof: undefined
   };
 }
 export const Part = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.index !== 0) {
       writer.uint32(8).uint32(message.index);
     }
     if (message.bytes.length !== 0) {
       writer.uint32(18).bytes(message.bytes);
     }
     if (message.proof !== undefined) {
       Proof.encode(message.proof, 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 = createBasePart();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.index = reader.uint32();
           break;
         case 2:
           message.bytes = reader.bytes();
           break;
         case 3:
           message.proof = Proof.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$index, _object$bytes;
     const message = createBasePart();
     message.index = (_object$index = object.index) !== null && _object$index !== void 0 ? _object$index : 0;
     message.bytes = (_object$bytes = object.bytes) !== null && _object$bytes !== void 0 ? _object$bytes : new Uint8Array();
     message.proof = object.proof !== undefined && object.proof !== null ? Proof.fromPartial(object.proof) : undefined;
     return message;
   }
 };
 function createBaseBlockID() {
   return {
     hash: new Uint8Array(),
     partSetHeader: undefined
   };
 }
 export const BlockID = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.hash.length !== 0) {
       writer.uint32(10).bytes(message.hash);
     }
     if (message.partSetHeader !== undefined) {
       PartSetHeader.encode(message.partSetHeader, 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 = createBaseBlockID();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.hash = reader.bytes();
           break;
         case 2:
           message.partSetHeader = PartSetHeader.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$hash2;
     const message = createBaseBlockID();
     message.hash = (_object$hash2 = object.hash) !== null && _object$hash2 !== void 0 ? _object$hash2 : new Uint8Array();
     message.partSetHeader = object.partSetHeader !== undefined && object.partSetHeader !== null ? PartSetHeader.fromPartial(object.partSetHeader) : undefined;
     return message;
   }
 };
 function createBaseHeader() {
   return {
     version: undefined,
@@ -335,145 +272,110 @@ function createBaseHeader() {
     proposerAddress: new Uint8Array()
   };
 }
 export const Header = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.version !== undefined) {
       Consensus.encode(message.version, writer.uint32(10).fork()).ldelim();
     }
     if (message.chainId !== "") {
       writer.uint32(18).string(message.chainId);
     }
     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.lastBlockId !== undefined) {
       BlockID.encode(message.lastBlockId, writer.uint32(42).fork()).ldelim();
     }
     if (message.lastCommitHash.length !== 0) {
       writer.uint32(50).bytes(message.lastCommitHash);
     }
     if (message.dataHash.length !== 0) {
       writer.uint32(58).bytes(message.dataHash);
     }
     if (message.validatorsHash.length !== 0) {
       writer.uint32(66).bytes(message.validatorsHash);
     }
     if (message.nextValidatorsHash.length !== 0) {
       writer.uint32(74).bytes(message.nextValidatorsHash);
     }
     if (message.consensusHash.length !== 0) {
       writer.uint32(82).bytes(message.consensusHash);
     }
     if (message.appHash.length !== 0) {
       writer.uint32(90).bytes(message.appHash);
     }
     if (message.lastResultsHash.length !== 0) {
       writer.uint32(98).bytes(message.lastResultsHash);
     }
     if (message.evidenceHash.length !== 0) {
       writer.uint32(106).bytes(message.evidenceHash);
     }
     if (message.proposerAddress.length !== 0) {
       writer.uint32(114).bytes(message.proposerAddress);
     }
     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 = createBaseHeader();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.version = Consensus.decode(reader, reader.uint32());
           break;
         case 2:
           message.chainId = reader.string();
           break;
         case 3:
           message.height = reader.int64();
           break;
         case 4:
           message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 5:
           message.lastBlockId = BlockID.decode(reader, reader.uint32());
           break;
         case 6:
           message.lastCommitHash = reader.bytes();
           break;
         case 7:
           message.dataHash = reader.bytes();
           break;
         case 8:
           message.validatorsHash = reader.bytes();
           break;
         case 9:
           message.nextValidatorsHash = reader.bytes();
           break;
         case 10:
           message.consensusHash = reader.bytes();
           break;
         case 11:
           message.appHash = reader.bytes();
           break;
         case 12:
           message.lastResultsHash = reader.bytes();
           break;
         case 13:
           message.evidenceHash = reader.bytes();
           break;
         case 14:
           message.proposerAddress = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$chainId, _object$time, _object$lastCommitHas, _object$dataHash, _object$validatorsHas, _object$nextValidator, _object$consensusHash, _object$appHash, _object$lastResultsHa, _object$evidenceHash, _object$proposerAddre;
     const message = createBaseHeader();
     message.version = object.version !== undefined && object.version !== null ? Consensus.fromPartial(object.version) : undefined;
     message.chainId = (_object$chainId = object.chainId) !== null && _object$chainId !== void 0 ? _object$chainId : "";
@@ -491,56 +393,43 @@ export const Header = {
     message.proposerAddress = (_object$proposerAddre = object.proposerAddress) !== null && _object$proposerAddre !== void 0 ? _object$proposerAddre : new Uint8Array();
     return message;
   }
 };
 function createBaseData() {
   return {
     txs: []
   };
 }
 export const Data = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.txs) {
       writer.uint32(10).bytes(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 = createBaseData();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.txs.push(reader.bytes());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$txs;
     const message = createBaseData();
     message.txs = ((_object$txs = object.txs) === null || _object$txs === void 0 ? void 0 : _object$txs.map(e => e)) || [];
     return message;
   }
 };
 function createBaseVote() {
   return {
     type: 0,
@@ -553,97 +442,74 @@ function createBaseVote() {
     signature: new Uint8Array()
   };
 }
 export const Vote = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.type !== 0) {
       writer.uint32(8).int32(message.type);
     }
     if (!message.height.isZero()) {
       writer.uint32(16).int64(message.height);
     }
     if (message.round !== 0) {
       writer.uint32(24).int32(message.round);
     }
     if (message.blockId !== undefined) {
       BlockID.encode(message.blockId, writer.uint32(34).fork()).ldelim();
     }
     if (message.timestamp !== undefined) {
       Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(42).fork()).ldelim();
     }
     if (message.validatorAddress.length !== 0) {
       writer.uint32(50).bytes(message.validatorAddress);
     }
     if (message.validatorIndex !== 0) {
       writer.uint32(56).int32(message.validatorIndex);
     }
     if (message.signature.length !== 0) {
       writer.uint32(66).bytes(message.signature);
     }
     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 = createBaseVote();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.type = reader.int32();
           break;
         case 2:
           message.height = reader.int64();
           break;
         case 3:
           message.round = reader.int32();
           break;
         case 4:
           message.blockId = BlockID.decode(reader, reader.uint32());
           break;
         case 5:
           message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 6:
           message.validatorAddress = reader.bytes();
           break;
         case 7:
           message.validatorIndex = reader.int32();
           break;
         case 8:
           message.signature = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$type, _object$round, _object$timestamp, _object$validatorAddr, _object$validatorInde, _object$signature;
     const message = createBaseVote();
     message.type = (_object$type = object.type) !== null && _object$type !== void 0 ? _object$type : 0;
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
@@ -655,9 +521,7 @@ export const Vote = {
     message.signature = (_object$signature = object.signature) !== null && _object$signature !== void 0 ? _object$signature : new Uint8Array();
     return message;
   }
 };
 function createBaseCommit() {
   return {
     height: Long.ZERO,
@@ -666,65 +530,50 @@ function createBaseCommit() {
     signatures: []
   };
 }
 export const Commit = {
   encode(message, writer = _m0.Writer.create()) {
     if (!message.height.isZero()) {
       writer.uint32(8).int64(message.height);
     }
     if (message.round !== 0) {
       writer.uint32(16).int32(message.round);
     }
     if (message.blockId !== undefined) {
       BlockID.encode(message.blockId, writer.uint32(26).fork()).ldelim();
     }
     for (const v of message.signatures) {
       CommitSig.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 = createBaseCommit();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.height = reader.int64();
           break;
         case 2:
           message.round = reader.int32();
           break;
         case 3:
           message.blockId = BlockID.decode(reader, reader.uint32());
           break;
         case 4:
           message.signatures.push(CommitSig.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$round2, _object$signatures;
     const message = createBaseCommit();
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
     message.round = (_object$round2 = object.round) !== null && _object$round2 !== void 0 ? _object$round2 : 0;
@@ -732,9 +581,7 @@ export const Commit = {
     message.signatures = ((_object$signatures = object.signatures) === null || _object$signatures === void 0 ? void 0 : _object$signatures.map(e => CommitSig.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseCommitSig() {
   return {
     blockIdFlag: 0,
@@ -743,65 +590,50 @@ function createBaseCommitSig() {
     signature: new Uint8Array()
   };
 }
 export const CommitSig = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.blockIdFlag !== 0) {
       writer.uint32(8).int32(message.blockIdFlag);
     }
     if (message.validatorAddress.length !== 0) {
       writer.uint32(18).bytes(message.validatorAddress);
     }
     if (message.timestamp !== undefined) {
       Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(26).fork()).ldelim();
     }
     if (message.signature.length !== 0) {
       writer.uint32(34).bytes(message.signature);
     }
     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 = createBaseCommitSig();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.blockIdFlag = reader.int32();
           break;
         case 2:
           message.validatorAddress = reader.bytes();
           break;
         case 3:
           message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 4:
           message.signature = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$blockIdFlag, _object$validatorAddr2, _object$timestamp2, _object$signature2;
     const message = createBaseCommitSig();
     message.blockIdFlag = (_object$blockIdFlag = object.blockIdFlag) !== null && _object$blockIdFlag !== void 0 ? _object$blockIdFlag : 0;
     message.validatorAddress = (_object$validatorAddr2 = object.validatorAddress) !== null && _object$validatorAddr2 !== void 0 ? _object$validatorAddr2 : new Uint8Array();
@@ -809,9 +641,7 @@ export const CommitSig = {
     message.signature = (_object$signature2 = object.signature) !== null && _object$signature2 !== void 0 ? _object$signature2 : new Uint8Array();
     return message;
   }
 };
 function createBaseProposal() {
   return {
     type: 0,
@@ -823,89 +653,68 @@ function createBaseProposal() {
     signature: new Uint8Array()
   };
 }
 export const Proposal = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.type !== 0) {
       writer.uint32(8).int32(message.type);
     }
     if (!message.height.isZero()) {
       writer.uint32(16).int64(message.height);
     }
     if (message.round !== 0) {
       writer.uint32(24).int32(message.round);
     }
     if (message.polRound !== 0) {
       writer.uint32(32).int32(message.polRound);
     }
     if (message.blockId !== undefined) {
       BlockID.encode(message.blockId, writer.uint32(42).fork()).ldelim();
     }
     if (message.timestamp !== undefined) {
       Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(50).fork()).ldelim();
     }
     if (message.signature.length !== 0) {
       writer.uint32(58).bytes(message.signature);
     }
     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 = createBaseProposal();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.type = reader.int32();
           break;
         case 2:
           message.height = reader.int64();
           break;
         case 3:
           message.round = reader.int32();
           break;
         case 4:
           message.polRound = reader.int32();
           break;
         case 5:
           message.blockId = BlockID.decode(reader, reader.uint32());
           break;
         case 6:
           message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 7:
           message.signature = reader.bytes();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$type2, _object$round3, _object$polRound, _object$timestamp3, _object$signature3;
     const message = createBaseProposal();
     message.type = (_object$type2 = object.type) !== null && _object$type2 !== void 0 ? _object$type2 : 0;
     message.height = object.height !== undefined && object.height !== null ? Long.fromValue(object.height) : Long.ZERO;
@@ -916,119 +725,93 @@ export const Proposal = {
     message.signature = (_object$signature3 = object.signature) !== null && _object$signature3 !== void 0 ? _object$signature3 : new Uint8Array();
     return message;
   }
 };
 function createBaseSignedHeader() {
   return {
     header: undefined,
     commit: undefined
   };
 }
 export const SignedHeader = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.header !== undefined) {
       Header.encode(message.header, writer.uint32(10).fork()).ldelim();
     }
     if (message.commit !== undefined) {
       Commit.encode(message.commit, 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 = createBaseSignedHeader();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.header = Header.decode(reader, reader.uint32());
           break;
         case 2:
           message.commit = Commit.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseSignedHeader();
     message.header = object.header !== undefined && object.header !== null ? Header.fromPartial(object.header) : undefined;
     message.commit = object.commit !== undefined && object.commit !== null ? Commit.fromPartial(object.commit) : undefined;
     return message;
   }
 };
 function createBaseLightBlock() {
   return {
     signedHeader: undefined,
     validatorSet: undefined
   };
 }
 export const LightBlock = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.signedHeader !== undefined) {
       SignedHeader.encode(message.signedHeader, writer.uint32(10).fork()).ldelim();
     }
     if (message.validatorSet !== undefined) {
       ValidatorSet.encode(message.validatorSet, 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 = createBaseLightBlock();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.signedHeader = SignedHeader.decode(reader, reader.uint32());
           break;
         case 2:
           message.validatorSet = ValidatorSet.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseLightBlock();
     message.signedHeader = object.signedHeader !== undefined && object.signedHeader !== null ? SignedHeader.fromPartial(object.signedHeader) : undefined;
     message.validatorSet = object.validatorSet !== undefined && object.validatorSet !== null ? ValidatorSet.fromPartial(object.validatorSet) : undefined;
     return message;
   }
 };
 function createBaseBlockMeta() {
   return {
     blockId: undefined,
@@ -1037,62 +820,48 @@ function createBaseBlockMeta() {
     numTxs: Long.ZERO
   };
 }
 export const BlockMeta = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.blockId !== undefined) {
       BlockID.encode(message.blockId, writer.uint32(10).fork()).ldelim();
     }
     if (!message.blockSize.isZero()) {
       writer.uint32(16).int64(message.blockSize);
     }
     if (message.header !== undefined) {
       Header.encode(message.header, writer.uint32(26).fork()).ldelim();
     }
     if (!message.numTxs.isZero()) {
       writer.uint32(32).int64(message.numTxs);
     }
     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 = createBaseBlockMeta();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.blockId = BlockID.decode(reader, reader.uint32());
           break;
         case 2:
           message.blockSize = reader.int64();
           break;
         case 3:
           message.header = Header.decode(reader, reader.uint32());
           break;
         case 4:
           message.numTxs = reader.int64();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseBlockMeta();
     message.blockId = object.blockId !== undefined && object.blockId !== null ? BlockID.fromPartial(object.blockId) : undefined;
@@ -1101,9 +870,7 @@ export const BlockMeta = {
     message.numTxs = object.numTxs !== undefined && object.numTxs !== null ? Long.fromValue(object.numTxs) : Long.ZERO;
     return message;
   }
 };
 function createBaseTxProof() {
   return {
     rootHash: new Uint8Array(),
@@ -1111,62 +878,48 @@ function createBaseTxProof() {
     proof: undefined
   };
 }
 export const TxProof = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.rootHash.length !== 0) {
       writer.uint32(10).bytes(message.rootHash);
     }
     if (message.data.length !== 0) {
       writer.uint32(18).bytes(message.data);
     }
     if (message.proof !== undefined) {
       Proof.encode(message.proof, 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 = createBaseTxProof();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.rootHash = reader.bytes();
           break;
         case 2:
           message.data = reader.bytes();
           break;
         case 3:
           message.proof = Proof.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$rootHash, _object$data;
     const message = createBaseTxProof();
     message.rootHash = (_object$rootHash = object.rootHash) !== null && _object$rootHash !== void 0 ? _object$rootHash : new Uint8Array();
     message.data = (_object$data = object.data) !== null && _object$data !== void 0 ? _object$data : new Uint8Array();
     message.proof = object.proof !== undefined && object.proof !== null ? Proof.fromPartial(object.proof) : undefined;
     return message;
   }
 };