@mainsail/consensus 0.0.1-evm.5 → 0.0.1-evm.50

package/distribution/consensus.js

@@ -7,104 +7,120 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Consensus_instances, _Consensus_height, _Consensus_round, _Consensus_step, _Consensus_lockedValue, _Consensus_validValue, _Consensus_didMajorityPrevote, _Consensus_didMajorityPrecommit, _Consensus_isDisposed, _Consensus_pendingJobs, _Consensus_proposalPromise, _Consensus_roundStartTime, _Consensus_handlerLock, _Consensus_isInvalidRoundState, _Consensus_makeProposal, _Consensus_bootstrap, _Consensus_processProposal;
+import { Enums, Events, Identifiers, Locale } from "@mainsail/constants";
 import { inject, injectable } from "@mainsail/container";
-import { Contracts, Events, Identifiers } from "@mainsail/contracts";
-import { Utils } from "@mainsail/kernel";
+import { assert, ensureError, Lock } from "@mainsail/utils";
 import dayjs from "dayjs";
+const FAILED_PROCESSOR_RESULT = {
+    feeUsed: 0n,
+    gasUsed: 0,
+    receipts: new Map(),
+    success: false,
+};
 let Consensus = class Consensus {
-    constructor() {
-        _Consensus_instances.add(this);
-        _Consensus_height.set(this, 1);
-        _Consensus_round.set(this, 0);
-        _Consensus_step.set(this, Contracts.Consensus.Step.Propose);
-        _Consensus_lockedValue.set(this, void 0);
-        _Consensus_validValue.set(this, void 0);
-        _Consensus_didMajorityPrevote.set(this, false);
-        _Consensus_didMajorityPrecommit.set(this, false);
-        _Consensus_isDisposed.set(this, false);
-        _Consensus_pendingJobs.set(this, new Set());
-        _Consensus_proposalPromise.set(this, void 0);
-        _Consensus_roundStartTime.set(this, 0);
-        // Handler lock is different than commit lock. It is used to prevent parallel processing and it is similar to queue.
-        _Consensus_handlerLock.set(this, new Utils.Lock());
-    }
-    getHeight() {
-        return __classPrivateFieldGet(this, _Consensus_height, "f");
+    app;
+    bootstrapper;
+    configuration;
+    processor;
+    stateStore;
+    proposalProcessor;
+    messageProcessor;
+    scheduler;
+    validatorsRepository;
+    roundStateRepository;
+    commitLock;
+    validatorSet;
+    blockForger;
+    eventDispatcher;
+    logger;
+    statisticService;
+    #blockNumber = 1;
+    #round = 0;
+    #step = Enums.Consensus.Step.Propose;
+    #lockedValue;
+    #validValue;
+    #didMajorityPrevote = false;
+    #didMajorityPrecommit = false;
+    #didMajorityPrecommitAndProposalIsMissing = false;
+    #isDisposed = false;
+    #pendingJobs = new Set();
+    #proposedBlock;
+    #proposalPromise;
+    #roundStartTime = 0;
+    // Handler lock is different than commit lock. It is used to prevent parallel processing and it is similar to queue.
+    #handlerLock = new Lock();
+    getBlockNumber() {
+        return this.#blockNumber;
     }
     getRound() {
-        return __classPrivateFieldGet(this, _Consensus_round, "f");
+        return this.#round;
     }
     // TODO: Only for tests
     setRound(round) {
-        __classPrivateFieldSet(this, _Consensus_round, round, "f");
+        this.#round = round;
     }
     getStep() {
-        return __classPrivateFieldGet(this, _Consensus_step, "f");
+        return this.#step;
     }
     // TODO: Only for tests
     setStep(step) {
-        __classPrivateFieldSet(this, _Consensus_step, step, "f");
+        this.#step = step;
     }
     getLockedRound() {
-        return __classPrivateFieldGet(this, _Consensus_lockedValue, "f") ? __classPrivateFieldGet(this, _Consensus_lockedValue, "f").round : undefined;
+        return this.#lockedValue ? this.#lockedValue.round : undefined;
     }
     getValidRound() {
-        return __classPrivateFieldGet(this, _Consensus_validValue, "f") ? __classPrivateFieldGet(this, _Consensus_validValue, "f").round : undefined;
+        return this.#validValue ? this.#validValue.round : undefined;
     }
-    // TODO: Only for tests
+    // Only for tests
     setValidRound(round) {
-        __classPrivateFieldSet(this, _Consensus_validValue, round, "f");
+        this.#validValue = round;
     }
-    // TODO: Only for tests
-    setProposal(proposalPromise) {
-        __classPrivateFieldSet(this, _Consensus_proposalPromise, proposalPromise, "f");
+    // Only for tests
+    setProposal(proposalPromise, block) {
+        this.#proposalPromise = proposalPromise;
+        this.#proposedBlock = block;
     }
     getState() {
         return {
-            height: __classPrivateFieldGet(this, _Consensus_height, "f"),
+            blockNumber: this.#blockNumber,
             lockedRound: this.getLockedRound(),
-            round: __classPrivateFieldGet(this, _Consensus_round, "f"),
-            step: __classPrivateFieldGet(this, _Consensus_step, "f"),
+            round: this.#round,
+            step: this.#step,
             validRound: this.getValidRound(),
         };
     }
     async run() {
-        await __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_bootstrap).call(this);
-        await this.startRound(__classPrivateFieldGet(this, _Consensus_round, "f"));
-        await this.handle(this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f")));
-        // Rerun previous rounds, in case proposal & +2/3 precommits were received
-        for (let index = 0; index < __classPrivateFieldGet(this, _Consensus_round, "f"); index++) {
-            await this.handle(this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), index));
+        try {
+            await this.#bootstrap();
+            await this.startRound(this.#round);
+            await this.handle(this.roundStateRepository.getRoundState(this.#blockNumber, this.#round));
+            // Rerun previous rounds, in case proposal & +2/3 precommits were received
+            for (let index = 0; index < this.#round; index++) {
+                await this.handle(this.roundStateRepository.getRoundState(this.#blockNumber, index));
+            }
+        }
+        catch (rawError) {
+            const error = ensureError(rawError);
+            await this.app.terminate("Consensus bootstrap error", error);
         }
     }
     async dispose() {
         this.scheduler.clear();
-        __classPrivateFieldSet(this, _Consensus_isDisposed, true, "f");
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => { });
+        this.#isDisposed = true;
+        await this.#handlerLock.runExclusive(async () => { });
     }
     async handle(roundState) {
-        if (__classPrivateFieldGet(this, _Consensus_pendingJobs, "f").has(roundState)) {
+        if (this.#pendingJobs.has(roundState)) {
             return;
         }
-        __classPrivateFieldGet(this, _Consensus_pendingJobs, "f").add(roundState);
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => {
-            __classPrivateFieldGet(this, _Consensus_pendingJobs, "f").delete(roundState);
-            if (__classPrivateFieldGet(this, _Consensus_isDisposed, "f")) {
+        this.#pendingJobs.add(roundState);
+        await this.#handlerLock.runExclusive(async () => {
+            this.#pendingJobs.delete(roundState);
+            if (this.#isDisposed) {
                 return;
             }
-            await __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_processProposal).call(this, roundState);
+            await this.#processProposal(roundState);
             await this.onProposal(roundState);
             await this.onProposalLocked(roundState);
             if (roundState.hasMajorityPrevotes()) {
@@ -128,69 +144,72 @@ let Consensus = class Consensus {
         });
     }
     async handleCommitState(commitState) {
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => {
-            if (__classPrivateFieldGet(this, _Consensus_isDisposed, "f")) {
+        await this.#handlerLock.runExclusive(async () => {
+            if (this.#isDisposed) {
                 return;
             }
-            await this.onMajorityPrecommit(commitState);
+            await this.#processBlock(commitState);
+            await this.onMajorityPrecommit(commitState, false);
         });
     }
     async startRound(round) {
-        __classPrivateFieldSet(this, _Consensus_round, round, "f");
-        __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Propose, "f");
-        __classPrivateFieldSet(this, _Consensus_didMajorityPrevote, false, "f");
-        __classPrivateFieldSet(this, _Consensus_didMajorityPrecommit, false, "f");
-        __classPrivateFieldSet(this, _Consensus_roundStartTime, dayjs().valueOf(), "f");
+        this.#round = round;
+        this.#step = Enums.Consensus.Step.Propose;
+        this.#didMajorityPrevote = false;
+        this.#didMajorityPrecommit = false;
+        this.#roundStartTime = dayjs().valueOf();
         this.scheduler.clear();
-        if (__classPrivateFieldGet(this, _Consensus_isDisposed, "f")) {
+        this.statisticService.newRound(this.#blockNumber, round);
+        if (this.#isDisposed) {
             return;
         }
-        const roundState = this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"));
-        this.logger.info(`>> Starting new round: ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} with proposer: ${roundState.proposer.address}`);
+        const roundState = this.roundStateRepository.getRoundState(this.#blockNumber, this.#round);
+        this.logger.info(`>> Starting new round: ${this.#getHeightRoundString()} with proposer: ${roundState.proposer.address}`, "consensus");
         await this.eventDispatcher.dispatch(Events.ConsensusEvent.RoundStarted, this.getState());
-        this.scheduler.scheduleTimeoutBlockPrepare(this.scheduler.getNextBlockTimestamp(__classPrivateFieldGet(this, _Consensus_roundStartTime, "f")));
+        this.scheduler.scheduleTimeoutBlockPrepare(this.scheduler.getNextBlockTimestamp(this.#roundStartTime));
         // TODO: Skip on sync
         await this.propose(roundState);
     }
     async onTimeoutStartRound() {
-        this.scheduler.scheduleTimeoutPropose(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"));
-        if (__classPrivateFieldGet(this, _Consensus_proposalPromise, "f")) {
-            const proposal = await __classPrivateFieldGet(this, _Consensus_proposalPromise, "f");
-            __classPrivateFieldSet(this, _Consensus_proposalPromise, undefined, "f");
+        this.scheduler.scheduleTimeoutPropose(this.#blockNumber, this.#round);
+        if (this.#proposalPromise) {
+            const proposal = await this.#proposalPromise;
+            assert.defined(this.#proposedBlock);
+            this.logger.info(`Proposing block ${this.#getBlockString(this.#proposedBlock)}`, "consensus");
+            this.#proposalPromise = undefined;
+            this.#proposedBlock = undefined;
             await this.proposalProcessor.process(proposal);
         }
     }
     async onProposal(roundState) {
         const proposal = roundState.getProposal();
-        if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Propose ||
-            __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState) ||
+        if (this.#step !== Enums.Consensus.Step.Propose ||
+            this.#isInvalidRoundState(roundState) ||
             !proposal ||
             proposal.validRound !== undefined) {
             return;
         }
-        __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Prevote, "f");
-        const { block } = proposal.getData();
-        this.logger.info(`Received proposal ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} blockId: ${block.data.id}`);
+        this.#step = Enums.Consensus.Step.Prevote;
+        this.logger.info(`Received proposal ${this.#getBlockString(proposal.blockHeader)}`, "consensus");
         await this.eventDispatcher.dispatch(Events.ConsensusEvent.ProposalAccepted, this.getState());
-        await this.prevote(roundState.getProcessorResult() ? block.data.id : undefined);
+        await this.prevote(roundState.getProcessorResult().success ? proposal.blockHeader.hash : undefined);
     }
     async onProposalLocked(roundState) {
         const proposal = roundState.getProposal();
-        if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Propose ||
-            __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState) ||
+        if (this.#step !== Enums.Consensus.Step.Propose ||
+            this.#isInvalidRoundState(roundState) ||
             !proposal ||
-            !proposal.getData().lockProof ||
+            !proposal.lockProof ||
             proposal.validRound === undefined ||
-            proposal.validRound >= __classPrivateFieldGet(this, _Consensus_round, "f")) {
+            proposal.validRound >= this.#round) {
             return;
         }
-        const { block } = proposal.getData();
-        __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Prevote, "f");
-        this.logger.info(`Received proposal ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} with locked blockId: ${block.data.id}`);
+        this.#step = Enums.Consensus.Step.Prevote;
+        this.logger.info(`Received locked proposal ${this.#getBlockString(proposal.blockHeader)}`, "consensus");
         await this.eventDispatcher.dispatch(Events.ConsensusEvent.ProposalAccepted, this.getState());
         const lockedRound = this.getLockedRound();
-        if ((!lockedRound || lockedRound <= proposal.validRound) && roundState.getProcessorResult()) {
-            await this.prevote(block.data.id);
+        if ((!lockedRound || lockedRound <= proposal.validRound) && roundState.getProcessorResult().success) {
+            await this.prevote(proposal.blockHeader.hash);
         }
         else {
             await this.prevote();
@@ -198,119 +217,142 @@ let Consensus = class Consensus {
     }
     async onMajorityPrevote(roundState) {
         const proposal = roundState.getProposal();
-        if (__classPrivateFieldGet(this, _Consensus_didMajorityPrevote, "f") ||
-            __classPrivateFieldGet(this, _Consensus_step, "f") === Contracts.Consensus.Step.Propose ||
-            __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState) ||
+        if (this.#didMajorityPrevote ||
+            this.#step === Enums.Consensus.Step.Propose ||
+            this.#isInvalidRoundState(roundState) ||
             !proposal ||
             !roundState.getProcessorResult().success) {
             return;
         }
-        const { block } = proposal.getData();
-        this.logger.info(`Received +2/3 prevotes for ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} blockId: ${block.data.id}`);
-        __classPrivateFieldSet(this, _Consensus_didMajorityPrevote, true, "f");
-        if (__classPrivateFieldGet(this, _Consensus_step, "f") === Contracts.Consensus.Step.Prevote) {
-            __classPrivateFieldSet(this, _Consensus_lockedValue, roundState, "f");
-            __classPrivateFieldSet(this, _Consensus_validValue, roundState, "f");
-            __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Precommit, "f");
+        this.logger.info(`Received +2/3 prevotes for ${this.#getBlockString(proposal.blockHeader)}`, "consensus");
+        this.#didMajorityPrevote = true;
+        if (this.#step === Enums.Consensus.Step.Prevote) {
+            this.#lockedValue = roundState;
+            this.#validValue = roundState;
+            this.#step = Enums.Consensus.Step.Precommit;
             await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrevotedProposal, this.getState());
-            await this.precommit(block.data.id);
+            await this.precommit(proposal.blockHeader.hash);
         }
         else {
-            __classPrivateFieldSet(this, _Consensus_validValue, roundState, "f");
+            this.#validValue = roundState;
             await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrevotedProposal, this.getState());
         }
     }
     async onMajorityPrevoteAny(roundState) {
-        if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Prevote || __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState)) {
+        if (this.#step !== Enums.Consensus.Step.Prevote || this.#isInvalidRoundState(roundState)) {
             return;
         }
-        if (this.scheduler.scheduleTimeoutPrevote(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"))) {
+        if (this.scheduler.scheduleTimeoutPrevote(this.#blockNumber, this.#round)) {
             await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrevotedAny, this.getState());
         }
     }
     async onMajorityPrevoteNull(roundState) {
-        if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Prevote || __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState)) {
+        if (this.#step !== Enums.Consensus.Step.Prevote || this.#isInvalidRoundState(roundState)) {
             return;
         }
-        this.logger.info(`Received +2/3 prevotes for ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} blockId: null`);
-        __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Precommit, "f");
+        this.logger.info(`Received +2/3 prevotes for ${this.#getHeightRoundString()}/null`, "consensus");
+        this.#step = Enums.Consensus.Step.Precommit;
         await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrevotedNull, this.getState());
         await this.precommit();
     }
     async onMajorityPrecommitAny(roundState) {
-        if (__classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_isInvalidRoundState).call(this, roundState)) {
+        if (this.#isInvalidRoundState(roundState)) {
             return;
         }
-        if (this.scheduler.scheduleTimeoutPrecommit(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"))) {
+        if (this.scheduler.scheduleTimeoutPrecommit(this.#blockNumber, this.#round)) {
             await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrecommitedAny, this.getState());
         }
     }
-    async onMajorityPrecommit(roundState) {
-        // TODO: Only height must match. Round can be any. Add tests
-        if (__classPrivateFieldGet(this, _Consensus_didMajorityPrecommit, "f") || roundState.height !== __classPrivateFieldGet(this, _Consensus_height, "f")) {
+    async onMajorityPrecommit(processState, isRoundState = true) {
+        // TODO: Only block number must match. Round can be any. Add tests
+        if ((isRoundState && this.#didMajorityPrecommit) || processState.blockNumber !== this.#blockNumber) {
             return;
         }
-        __classPrivateFieldSet(this, _Consensus_didMajorityPrecommit, true, "f");
-        const block = roundState.getBlock();
-        if (!roundState.getProcessorResult().success) {
-            this.logger.info(`Block ${block.data.id} on height ${__classPrivateFieldGet(this, _Consensus_height, "f")} received +2/3 precommits but is invalid`);
+        if (processState.hasProcessorResult() === false) {
+            if (this.#didMajorityPrecommitAndProposalIsMissing) {
+                return;
+            }
+            this.logger.info(`Received +2/3 precommits for ${this.#getHeightRoundString()}, but proposal is missing`, "consensus");
+            this.#didMajorityPrecommitAndProposalIsMissing = true;
+            return;
+        }
+        if (isRoundState) {
+            // Sets it only once for round state
+            this.#didMajorityPrecommit = true;
+        }
+        const block = processState.getBlock();
+        this.logger.info(`Received +2/3 precommits for ${this.#getBlockString(block)}`, "consensus");
+        if (!processState.getProcessorResult().success) {
+            this.logger.info(`Block ${this.#getBlockString(block)} is invalid`, "consensus");
             return;
         }
-        this.logger.info(`Received +2/3 precommits for ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${roundState.round} blockId: ${block.data.id}`);
         await this.eventDispatcher.dispatch(Events.ConsensusEvent.PrecommitedProposal, this.getState());
         await this.commitLock.runExclusive(async () => {
-            var _a;
             try {
-                await this.processor.commit(roundState);
+                await this.processor.commit(processState);
             }
-            catch (error) {
+            catch (rawError) {
+                const error = ensureError(rawError);
                 await this.app.terminate("Failed to commit block", error);
             }
             this.roundStateRepository.clear();
-            __classPrivateFieldSet(this, _Consensus_height, (_a = __classPrivateFieldGet(this, _Consensus_height, "f"), _a++, _a), "f");
-            __classPrivateFieldSet(this, _Consensus_lockedValue, undefined, "f");
-            __classPrivateFieldSet(this, _Consensus_validValue, undefined, "f");
+            this.#blockNumber++;
+            this.#lockedValue = undefined;
+            this.#validValue = undefined;
             await this.startRound(0);
         });
     }
     async onMinorityWithHigherRound(roundState) {
-        if (roundState.height !== __classPrivateFieldGet(this, _Consensus_height, "f") || roundState.round <= __classPrivateFieldGet(this, _Consensus_round, "f")) {
+        if (roundState.blockNumber !== this.#blockNumber || roundState.round <= this.#round) {
             return;
         }
         await this.startRound(roundState.round);
     }
-    async onTimeoutPropose(height, round) {
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => {
-            if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Propose || __classPrivateFieldGet(this, _Consensus_height, "f") !== height || __classPrivateFieldGet(this, _Consensus_round, "f") !== round) {
+    async onTimeoutPropose(blockNumber, round) {
+        await this.#handlerLock.runExclusive(async () => {
+            if (this.#step !== Enums.Consensus.Step.Propose ||
+                this.#blockNumber !== blockNumber ||
+                this.#round !== round) {
                 return;
             }
-            this.logger.info(`Timeout to propose ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} expired`);
-            __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Prevote, "f");
+            this.logger.info(`Timeout to propose ${this.#getHeightRoundString()} expired`, "consensus");
+            this.#step = Enums.Consensus.Step.Prevote;
             await this.prevote();
         });
     }
-    async onTimeoutPrevote(height, round) {
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => {
-            if (__classPrivateFieldGet(this, _Consensus_step, "f") !== Contracts.Consensus.Step.Prevote || __classPrivateFieldGet(this, _Consensus_height, "f") !== height || __classPrivateFieldGet(this, _Consensus_round, "f") !== round) {
+    async onTimeoutPrevote(blockNumber, round) {
+        await this.#handlerLock.runExclusive(async () => {
+            if (this.#step !== Enums.Consensus.Step.Prevote ||
+                this.#blockNumber !== blockNumber ||
+                this.#round !== round) {
                 return;
             }
-            this.logger.info(`Timeout to prevote ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} expired`);
-            this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f")).logPrevotes();
-            __classPrivateFieldSet(this, _Consensus_step, Contracts.Consensus.Step.Precommit, "f");
+            this.logger.info(`Timeout to prevote ${this.#getHeightRoundString()} expired`, "consensus");
+            this.roundStateRepository.getRoundState(this.#blockNumber, this.#round).logPrevotes();
+            this.#step = Enums.Consensus.Step.Precommit;
             await this.precommit();
         });
     }
-    async onTimeoutPrecommit(height, round) {
-        await __classPrivateFieldGet(this, _Consensus_handlerLock, "f").runExclusive(async () => {
-            if (__classPrivateFieldGet(this, _Consensus_height, "f") !== height || __classPrivateFieldGet(this, _Consensus_round, "f") !== round) {
+    async onTimeoutPrecommit(blockNumber, round) {
+        await this.#handlerLock.runExclusive(async () => {
+            if (this.#blockNumber !== blockNumber || this.#round !== round) {
                 return;
             }
-            this.logger.info(`Timeout to precommit ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} expired`);
-            this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f")).logPrevotes();
-            this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f")).logPrecommits();
-            await this.startRound(__classPrivateFieldGet(this, _Consensus_round, "f") + 1);
+            this.logger.info(`Timeout to precommit ${this.#getHeightRoundString()} expired`, "consensus");
+            this.roundStateRepository.getRoundState(this.#blockNumber, this.#round).logPrevotes();
+            this.roundStateRepository.getRoundState(this.#blockNumber, this.#round).logPrecommits();
+            await this.startRound(this.#round + 1);
         });
     }
+    #isInvalidRoundState(roundState) {
+        if (roundState.blockNumber !== this.#blockNumber) {
+            return true;
+        }
+        if (roundState.round !== this.#round) {
+            return true;
+        }
+        return false;
+    }
     async propose(roundState) {
         if (roundState.hasProposal()) {
             return;
@@ -319,12 +361,24 @@ let Consensus = class Consensus {
         if (registeredProposer === undefined) {
             return;
         }
-        this.logger.info(`Found registered proposer: ${roundState.proposer.address}`);
-        __classPrivateFieldSet(this, _Consensus_proposalPromise, __classPrivateFieldGet(this, _Consensus_instances, "m", _Consensus_makeProposal).call(this, roundState, registeredProposer), "f");
+        this.logger.info(`Found registered proposer: ${roundState.proposer.address}`, "consensus");
+        this.#proposalPromise = this.#makeProposal(roundState, registeredProposer);
+    }
+    async #makeProposal(roundState, registeredProposer) {
+        if (this.#validValue) {
+            this.#proposedBlock = this.#validValue.getBlock();
+            const lockProof = await this.#validValue.aggregatePrevotes();
+            this.logger.info(`Created proposal with existing block ${this.#getBlockString(this.#proposedBlock)}`, "consensus");
+            return await registeredProposer.propose(this.validatorSet.getValidatorIndexByWalletAddress(roundState.proposer.address), this.#round, this.#validValue.round, this.#proposedBlock, lockProof);
+        }
+        this.#proposedBlock = this.#proposedBlock = await this.blockForger.forgeBlock(roundState.proposer.address, this.#round, this.scheduler.getNextBlockTimestamp(this.#roundStartTime));
+        this.logger.info(`Created proposal with new block ${this.#getBlockString(this.#proposedBlock)}`, "consensus");
+        void this.eventDispatcher.dispatch(Events.BlockEvent.Forged, this.#proposedBlock);
+        return registeredProposer.propose(this.validatorSet.getValidatorIndexByWalletAddress(roundState.proposer.address), this.#round, undefined, this.#proposedBlock);
     }
     async prevote(value) {
-        const roundState = this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"));
-        for (const validator of this.validatorSet.getActiveValidators()) {
+        const roundState = this.roundStateRepository.getRoundState(this.#blockNumber, this.#round);
+        for (const validator of this.validatorSet.getRoundValidators()) {
             const localValidator = this.validatorsRepository.getValidator(validator.blsPublicKey);
             if (localValidator === undefined) {
                 continue;
@@ -333,13 +387,13 @@ let Consensus = class Consensus {
             if (roundState.hasPrevote(validatorIndex)) {
                 continue;
             }
-            const prevote = await localValidator.prevote(validatorIndex, __classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"), value);
-            void this.prevoteProcessor.process(prevote);
+            const prevote = await localValidator.prevote(validatorIndex, this.#blockNumber, this.#round, value);
+            void this.messageProcessor.process(prevote);
         }
     }
     async precommit(value) {
-        const roundState = this.roundStateRepository.getRoundState(__classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"));
-        for (const validator of this.validatorSet.getActiveValidators()) {
+        const roundState = this.roundStateRepository.getRoundState(this.#blockNumber, this.#round);
+        for (const validator of this.validatorSet.getRoundValidators()) {
             const localValidator = this.validatorsRepository.getValidator(validator.blsPublicKey);
             if (localValidator === undefined) {
                 continue;
@@ -348,82 +402,74 @@ let Consensus = class Consensus {
             if (roundState.hasPrecommit(validatorIndex)) {
                 continue;
             }
-            const precommit = await localValidator.precommit(validatorIndex, __classPrivateFieldGet(this, _Consensus_height, "f"), __classPrivateFieldGet(this, _Consensus_round, "f"), value);
-            void this.precommitProcessor.process(precommit);
+            const precommit = await localValidator.precommit(validatorIndex, this.#blockNumber, this.#round, value);
+            void this.messageProcessor.process(precommit);
         }
     }
-};
-_Consensus_height = new WeakMap();
-_Consensus_round = new WeakMap();
-_Consensus_step = new WeakMap();
-_Consensus_lockedValue = new WeakMap();
-_Consensus_validValue = new WeakMap();
-_Consensus_didMajorityPrevote = new WeakMap();
-_Consensus_didMajorityPrecommit = new WeakMap();
-_Consensus_isDisposed = new WeakMap();
-_Consensus_pendingJobs = new WeakMap();
-_Consensus_proposalPromise = new WeakMap();
-_Consensus_roundStartTime = new WeakMap();
-_Consensus_handlerLock = new WeakMap();
-_Consensus_instances = new WeakSet();
-_Consensus_isInvalidRoundState = function _Consensus_isInvalidRoundState(roundState) {
-    if (roundState.height !== __classPrivateFieldGet(this, _Consensus_height, "f")) {
-        return true;
-    }
-    if (roundState.round !== __classPrivateFieldGet(this, _Consensus_round, "f")) {
-        return true;
-    }
-    return false;
-};
-_Consensus_makeProposal = async function _Consensus_makeProposal(roundState, registeredProposer) {
-    if (__classPrivateFieldGet(this, _Consensus_validValue, "f")) {
-        const block = __classPrivateFieldGet(this, _Consensus_validValue, "f").getBlock();
-        const lockProof = await __classPrivateFieldGet(this, _Consensus_validValue, "f").aggregatePrevotes();
-        this.logger.info(`Proposing valid block ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} from round ${this.getValidRound()} with blockId: ${block.data.id}`);
-        return await registeredProposer.propose(this.validatorSet.getValidatorIndexByWalletAddress(roundState.proposer.address), __classPrivateFieldGet(this, _Consensus_round, "f"), __classPrivateFieldGet(this, _Consensus_validValue, "f").round, block, lockProof);
-    }
-    const block = await registeredProposer.prepareBlock(roundState.proposer.address, __classPrivateFieldGet(this, _Consensus_round, "f"), this.scheduler.getNextBlockTimestamp(__classPrivateFieldGet(this, _Consensus_roundStartTime, "f")));
-    this.logger.info(`Proposing new block ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")} with blockId: ${block.data.id}`);
-    void this.eventDispatcher.dispatch(Events.BlockEvent.Forged, block.data);
-    return registeredProposer.propose(this.validatorSet.getValidatorIndexByWalletAddress(roundState.proposer.address), __classPrivateFieldGet(this, _Consensus_round, "f"), undefined, block);
-};
-_Consensus_bootstrap = async function _Consensus_bootstrap() {
-    const state = await this.bootstrapper.run();
-    if (state && state.height === this.stateStore.getLastBlock().data.height + 1) {
-        __classPrivateFieldSet(this, _Consensus_step, state.step, "f");
-        __classPrivateFieldSet(this, _Consensus_height, state.height, "f");
-        __classPrivateFieldSet(this, _Consensus_round, state.round, "f");
-        __classPrivateFieldSet(this, _Consensus_lockedValue, state.lockedValue, "f");
-        __classPrivateFieldSet(this, _Consensus_validValue, state.validValue, "f");
-    }
-    else {
+    async #bootstrap() {
+        this.#blockNumber = this.stateStore.getLastBlock().number + 1;
+        const state = await this.bootstrapper.run();
         if (state) {
-            this.logger.warning(`Skipping state restore, because stored height is ${state.height}, but should be ${this.stateStore.getLastBlock().data.height + 1}`);
-            this.roundStateRepository.clear();
+            if (state.blockNumber === this.#blockNumber) {
+                this.#step = state.step;
+                this.#round = state.round;
+                this.#lockedValue = state.lockedValue;
+                this.#validValue = state.validValue;
+            }
+            else {
+                const storedBlockNumber = state.blockNumber.toLocaleString(Locale);
+                const currentBlockNumber = this.#blockNumber.toLocaleString(Locale);
+                this.logger.warn(`Skipping state restore, because stored block number is ${storedBlockNumber}, but should be ${currentBlockNumber}`, "consensus");
+                this.roundStateRepository.clear();
+            }
+        }
+        if (this.#blockNumber !== this.configuration.getHeight()) {
+            throw new Error(`bootstrapped block number ${this.#blockNumber} does not match configuration block number ${this.configuration.getHeight()}`);
         }
-        const lastBlock = this.stateStore.getLastBlock();
-        __classPrivateFieldSet(this, _Consensus_height, lastBlock.data.height + 1, "f");
+        this.logger.info(`Completed consensus bootstrap for ${this.#getHeightRoundString()} with total round ${this.stateStore.getTotalRound()}`, "consensus");
+        await this.eventDispatcher.dispatch(Events.ConsensusEvent.Bootstrapped, this.getState());
     }
-    if (__classPrivateFieldGet(this, _Consensus_height, "f") !== this.configuration.getHeight()) {
-        throw new Error(`bootstrapped height ${__classPrivateFieldGet(this, _Consensus_height, "f")} does not match configuration height ${this.configuration.getHeight()}`);
+    async #processProposal(roundState) {
+        const proposal = roundState.getProposal();
+        if (!roundState.hasProcessorResult() && proposal) {
+            try {
+                await proposal.deserializePayload();
+                if (!(await this.proposalProcessor.hasValidLockProof(proposal))) {
+                    roundState.setProcessorResult(FAILED_PROCESSOR_RESULT);
+                    return;
+                }
+                roundState.setProcessorResult(await this.processor.process(roundState));
+            }
+            catch (rawError) {
+                const error = ensureError(rawError);
+                this.logger.error(`Failed to process proposal ${this.#getHeightRoundString()}: ${error.message}`, "consensus");
+                roundState.setProcessorResult(FAILED_PROCESSOR_RESULT);
+            }
+        }
     }
-    this.logger.info(`Completed consensus bootstrap for ${__classPrivateFieldGet(this, _Consensus_height, "f")}/${__classPrivateFieldGet(this, _Consensus_round, "f")}/${this.stateStore.getTotalRound()}`);
-    await this.eventDispatcher.dispatch(Events.ConsensusEvent.Bootstrapped, this.getState());
-};
-_Consensus_processProposal = async function _Consensus_processProposal(roundState) {
-    const proposal = roundState.getProposal();
-    if (!roundState.hasProcessorResult() && proposal) {
-        try {
-            await proposal.deserializeData();
-            if (!(await this.proposalProcessor.hasValidLockProof(proposal))) {
-                roundState.setProcessorResult({ gasUsed: 0, receipts: new Map(), success: false });
-                return;
+    async #processBlock(commitState) {
+        if (!commitState.hasProcessorResult()) {
+            try {
+                commitState.setProcessorResult(await this.processor.process(commitState));
+            }
+            catch {
+                commitState.setProcessorResult(FAILED_PROCESSOR_RESULT);
             }
-            roundState.setProcessorResult(await this.processor.process(roundState));
         }
-        catch {
-            roundState.setProcessorResult({ gasUsed: 0, receipts: new Map(), success: false });
+    }
+    #getHeightRoundString() {
+        const number = this.#blockNumber.toLocaleString(Locale);
+        const consensusRound = this.#round.toLocaleString(Locale);
+        return `${number}/${consensusRound}`;
+    }
+    #getBlockString(block) {
+        const number = this.#blockNumber.toLocaleString(Locale);
+        const consensusRound = this.#round.toLocaleString(Locale);
+        const blockRound = block.round.toLocaleString(Locale);
+        if (block.round !== this.#round) {
+            return `${number}/${consensusRound}(${blockRound})/${block.hash}`;
         }
+        return `${number}/${consensusRound}/${block.hash}`;
     }
 };
 __decorate([
@@ -451,13 +497,9 @@ __decorate([
     __metadata("design:type", Object)
 ], Consensus.prototype, "proposalProcessor", void 0);
 __decorate([
-    inject(Identifiers.Consensus.Processor.PreVote),
-    __metadata("design:type", Object)
-], Consensus.prototype, "prevoteProcessor", void 0);
-__decorate([
-    inject(Identifiers.Consensus.Processor.PreCommit),
+    inject(Identifiers.Consensus.Processor.Message),
     __metadata("design:type", Object)
-], Consensus.prototype, "precommitProcessor", void 0);
+], Consensus.prototype, "messageProcessor", void 0);
 __decorate([
     inject(Identifiers.Consensus.Scheduler),
     __metadata("design:type", Object)
@@ -478,6 +520,10 @@ __decorate([
     inject(Identifiers.ValidatorSet.Service),
     __metadata("design:type", Object)
 ], Consensus.prototype, "validatorSet", void 0);
+__decorate([
+    inject(Identifiers.Forger.Block),
+    __metadata("design:type", Object)
+], Consensus.prototype, "blockForger", void 0);
 __decorate([
     inject(Identifiers.Services.EventDispatcher.Service),
     __metadata("design:type", Object)
@@ -486,6 +532,10 @@ __decorate([
     inject(Identifiers.Services.Log.Service),
     __metadata("design:type", Object)
 ], Consensus.prototype, "logger", void 0);
+__decorate([
+    inject(Identifiers.P2P.Statistic.Service),
+    __metadata("design:type", Object)
+], Consensus.prototype, "statisticService", void 0);
 Consensus = __decorate([
     injectable()
 ], Consensus);