trac-msb 0.2.24 → 0.3.0-beta.1

package/src/core/consensus/services/EpochCoordinatorOperations.js

@@ -0,0 +1,211 @@
+/**
+ * @typedef {object} EpochVdfProof
+ * @property {Buffer} solution Encoded Wesolowski proof.
+ * @property {number} difficulty VDF iteration count from the signed consensus config.
+ * @property {number} discriminantSizeBits Discriminant size used for this calculation.
+ *
+ * @typedef {object} EpochProofApproval
+ * @property {Buffer} signature Verified proof signature from another indexer.
+ * @property {Buffer} approver Signer address stored as a buffer.
+ *
+ * @typedef {object} EpochApprovalCollection
+ * @property {Array<{key: Buffer}>} approvers Other indexers that can approve this proof.
+ * @property {EpochProofApproval[]} approvals Accepted proof signatures from this attempt.
+ * @property {Array<{member: {key: Buffer}, error: Error}>} rejections Failed requests from this attempt.
+ * @property {boolean} closed True when enough signatures are collected or this attempt ends.
+ */
+import tracCryptoApi from "trac-crypto-api";
+import { generateUUID } from '../../../utils/helpers.js';
+import { consensusMessageFactory } from '../../../messages/consensus/v1/consensusMessageFactory.js';
+import addressUtils from '../../state/utils/address.js';
+import b4a from "b4a";
+import { encodeProofProposal, encodeProofProposalApproval } from '../../../codecs/consensus/v1/consensusV1OperationCodec.js';
+import { applyStateMessageFactory } from '../../../messages/state/applyStateMessageFactory.js';
+import { toHex, uint16ToBuffer, uint32ToBuffer } from '../../../utils/buffer.js';
+import { encodeApplyOperation } from '../../../codecs/apply/applyOperationCodec.js';
+import { ConsensusResultCode } from '../../../utils/constants.js';
+
+/**
+ * Builds proof messages and SET_EPOCH payloads, requests signatures and starts appends. The round uses
+ * these methods and controls the FSM. The selector decides whether this node may append.
+ */
+export class EpochCoordinatorOperations {
+    #state;
+    #wallet;
+    #vdfService;
+    #config;
+
+    /**
+     * Sets up ledger access, the signing wallet, the VDF worker and message config.
+     *
+     * @param {import('../../state/State.js').default} state Signed ledger reads and the write queue that checks append authorization.
+     * @param {import('./VDFService.js').VDFService} vdfService VDF service ready to calculate proofs.
+     * @param {object} wallet Local signing wallet.
+     * @param {object} config Network ID and address encoding config.
+     */
+    constructor(state, vdfService, wallet, config) {
+        this.#state = state;
+        this.#vdfService = vdfService;
+        this.#wallet = wallet;
+        this.#config = config;
+    }
+
+    /**
+     * Calculates a proof using the challenge and signed VDF parameters from the round.
+     *
+     * @param {Buffer} challenge Encoded network, parent, proposer and VDF parameters.
+     * @param {number} difficulty VDF iteration count.
+     * @param {number} discriminantSizeBits Discriminant size in bits.
+     * @returns {Promise<EpochVdfProof>} Calculated proof and the parameters used to create it.
+     * @throws {Error} When the worker fails or closes.
+     */
+    async calculateVDF(challenge, difficulty, discriminantSizeBits) {
+        const { result: vdfProof, error } = await this.#vdfService.calculateVDF(
+            challenge,
+            difficulty,
+            discriminantSizeBits,
+        );
+        if (error) throw new Error(error);
+        return { solution: vdfProof.solution, difficulty, discriminantSizeBits };
+    }  
+
+    /**
+     * Builds and signs a proposal for the epoch after parentEpoch. Each message gets a new session ID.
+     *
+     * @param {bigint} parentEpoch Signed parent epoch number.
+     * @param {Buffer} parentEpochHash Hash of the signed parent epoch.
+     * @param {EpochVdfProof} vdfProof Local calculation result.
+     * @returns {Promise<object>} Consensus message containing proof_proposal.
+     */
+    async createProofProposal(parentEpoch, parentEpochHash, vdfProof) {
+        const targetEpoch = parentEpoch + 1n;
+        const encodedDifficulty = uint32ToBuffer(vdfProof.difficulty);
+        const encodedDiscriminantSize = uint16ToBuffer(vdfProof.discriminantSizeBits);
+        return consensusMessageFactory(this.#wallet, this.#config)
+            .buildProofProposal(
+                generateUUID(),
+                this.#config.networkId,
+                targetEpoch,
+                parentEpochHash,
+                this.#wallet.address,
+                encodedDifficulty,
+                encodedDiscriminantSize,
+                vdfProof.solution
+            );
+    }
+
+    /**
+     * Sends a proof approval request through an authenticated consensus connection.
+     *
+     * @param {string} approverPublicKeyHex Remote wallet public key, encoded as hex.
+     * @param {object} proofProposalMessage Signed proof proposal message.
+     * @param {import('../../network/services/IndexerConnectionManager.js').default} indexerConnectionManager Peer session manager.
+     * @returns {Promise<{resultCode: number|undefined, signature: Buffer|undefined}>} Result code and signature from the protocol reply.
+     */
+    async sendProofApprovalRequest(approverPublicKeyHex, proofProposalMessage, indexerConnectionManager) {
+        if (!indexerConnectionManager.connected(approverPublicKeyHex)) throw new Error('Indexer not in the manager');
+
+        const approvalResponse = await indexerConnectionManager.send(approverPublicKeyHex, proofProposalMessage);
+        return {
+            resultCode: approvalResponse?.resultCode,
+            signature: approvalResponse?.approval?.approval_sig,
+        };
+    }
+
+    /**
+     * Finds the wallet identity for an indexer and requests its proof signature. Checks whether the
+     * collection is closed before sending. The round checks the collection again when the reply
+     * arrives.
+     *
+     * @param {{key: Buffer}} approverIndexer External indexer from the attempt membership.
+     * @param {{currentEpoch: bigint, currentEpochHash: Buffer, vdf: EpochVdfProof}} proofContext Parent and local proof.
+     * @param {import('../../network/services/IndexerConnectionManager.js').default} indexerConnectionManager Authenticated consensus sessions.
+     * @param {EpochApprovalCollection|null} [approvalCollection=null] Approval collection. A closed collection stops the request before sending.
+     * @returns {Promise<EpochProofApproval>} Approval data to be added by the round.
+     * @throws {Error} If identity lookup, request delivery or approval validation fails.
+     */
+    async requestProofApproval(approverIndexer, {currentEpoch, currentEpochHash, vdf: vdfProof}, indexerConnectionManager, approvalCollection = null) {
+        // Each peer request needs its own RPC session ID; the signed proposal content stays the same.
+        const proofProposalMessage = await this.createProofProposal(currentEpoch, currentEpochHash, vdfProof);
+        const writerKeyHex = toHex(approverIndexer.key);
+        const approverAddressBuffer = await this.#state.getRegisteredWriterKey(writerKeyHex);
+        if (!approverAddressBuffer) throw new Error('Registered writer key not found');
+
+        const approverAddress = addressUtils.bufferToAddress(approverAddressBuffer, this.#config.addressPrefix);
+        if (!approverAddress) throw new Error('Writer address could not be decoded');
+
+        const approverPublicKey = tracCryptoApi.address.decode(approverAddress);
+        if (!approverPublicKey) throw new Error('Writer public key could not be decoded');
+
+        const approverPublicKeyHex = toHex(approverPublicKey);
+        if (approvalCollection?.closed) throw new Error('Epoch approval request was cancelled');
+
+        const { resultCode, signature: approvalSignature } = await this.sendProofApprovalRequest(approverPublicKeyHex, proofProposalMessage, indexerConnectionManager);
+
+        if (resultCode !== ConsensusResultCode.OK) {
+            const approvalError = new Error(`Approval rejected with result code ${resultCode}`);
+            approvalError.resultCode = resultCode;
+            throw approvalError;
+        }
+
+        if (!approvalSignature) throw new Error('Approval signature not received');
+
+        return {
+            signature: approvalSignature,
+            approver: approverAddressBuffer
+        };
+    }
+
+    /**
+     * Encodes a SET_EPOCH operation from the local proposal and external approvals.
+     *
+     * @param {object} proofProposal Signed protocol proof fields.
+     * @param {EpochProofApproval[]} proofApprovals Signatures from other indexers. proofProposal contains the proposer signature.
+     * @returns {Promise<Buffer>} Encoded SET_EPOCH operation ready for appender selection.
+     */
+    async buildSetEpochPayload(proofProposal, proofApprovals) {
+        const encodedProofProposal = encodeProofProposal({
+            network_id: proofProposal.network_id,
+            epoch: proofProposal.epoch,
+            previous_epoch_record_hash: proofProposal.previous_epoch_record_hash,
+            proposer: proofProposal.proposer,
+            difficulty: proofProposal.difficulty,
+            discriminant_bit_size: proofProposal.discriminant_bit_size,
+            proof: proofProposal.proof,
+            signature: proofProposal.signature,
+        });
+        const encodedApprovals = proofApprovals.map(({ signature, approver }) =>
+            encodeProofProposalApproval({
+                approver,
+                approval_sig: signature,
+            })
+        );
+        const message = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteSetEpochMessage(this.#wallet.address, encodedProofProposal, encodedApprovals);
+        return encodeApplyOperation(message);
+    }
+
+    /**
+     * Queues the epoch append. Calls authorizeEpochAppend just before Autobase.append. Completing the
+     * local write does not confirm the epoch. The round still checks its signed result.
+     *
+     * @param {Buffer} epochPayload Exact bytes reserved by the appender selection.
+     * @param {function({writerKey: string, from: number}): Promise<void>} authorizeEpochAppend Checks the selection and saves the append details locally.
+     * @returns {Promise<void>} Result returned by the write queue.
+     */
+    appendSetEpoch(epochPayload, authorizeEpochAppend) {
+        return this.#state.appendEpoch(epochPayload, authorizeEpochAppend);
+    }
+
+    /**
+     * Returns all indexers except the local writer. An admin who is also an indexer can approve the
+     * proof.
+     *
+     * @param {Array<{key: Buffer}>} indexers Indexer list read for this attempt.
+     * @returns {Array<{key: Buffer}>} Other indexers that can approve the proof.
+     */
+    getProofApprovers(indexers) {
+        const writingKey = this.#state.writingKey;
+        return indexers.filter(({ key: writerKey }) => !b4a.equals(writerKey, writingKey));
+    }
+}

package/src/core/consensus/services/EpochCoordinatorService.js

@@ -0,0 +1,335 @@
+import SchedulableService from '../../../utils/scheduler/SchedulableService.js';
+import { Logger } from '../../../utils/logger.js';
+import { CustomEventType } from '../../../utils/constants.js';
+import { EpochCoordinationRound } from './EpochCoordinationRound.js';
+import { VDFServiceManager } from './VDFServiceManager.js';
+
+/**
+ * Schedules epoch rounds on this indexer. When consensus config changes, cancels the current round,
+ * replaces the VDF worker and resumes scheduling. All rounds use the same appender selector.
+ */
+class EpochCoordinatorService extends SchedulableService {
+    #state;
+    #wallet;
+    #config;
+    #indexerConnectionManager;
+    #roundIntervalMs;
+    #logger;
+    #vdfServiceManager;
+    #coordinationEnabled = false;
+    #currentRound = null;
+    #pendingRoundExecutions = new Set();
+    #configReloadPromise = null;
+    #cancelReloadDelay = null;
+    #consensusConfigChangeListener;
+    #appenderSelector;
+
+    /**
+     * Creates the scheduler and VDF service manager. Call start() to enable epoch rounds.
+     *
+     * @param {import('../../state/State.js').default} state Signed ledger access and consensus events.
+     * @param {object} wallet Wallet used to sign local proofs.
+     * @param {object} config Round intervals, timeouts and network configuration.
+     * @param {import('../../network/services/IndexerConnectionManager.js').default} indexerConnectionManager Authenticated peer sessions.
+     * @param {import('../epochAppenderSelection/EpochAppenderSelector.js').EpochAppenderSelector|null} [appenderSelector=null] Shared selector required once genesis is initialized.
+     */
+    constructor(state, wallet, config, indexerConnectionManager, appenderSelector = null) {
+        super();
+        this.#state = state;
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#indexerConnectionManager = indexerConnectionManager;
+        this.#appenderSelector = appenderSelector;
+        this.#roundIntervalMs = config.epochInterval;
+        this.#logger = new Logger(config);
+        this.#vdfServiceManager = new VDFServiceManager(state, wallet, config);
+        this.#consensusConfigChangeListener = this.#handleConfigChange.bind(this);
+    }
+
+    /**
+     * Opens the VDF service and starts listening for consensus config changes.
+     *
+     * @returns {Promise<void>}
+     */
+    async _open() {
+        await this.#vdfServiceManager.open();
+        this.#state.on(CustomEventType.CONSENSUS_CONFIG_CHANGED, this.#consensusConfigChangeListener);
+    }
+
+    /**
+     * Removes the config listener, cancels the current round and closes the VDF service. Does not wait
+     * for network operations that cannot be cancelled.
+     *
+     * @returns {Promise<void>}
+     */
+    async _close() {
+        this.#state.off(CustomEventType.CONSENSUS_CONFIG_CHANGED, this.#consensusConfigChangeListener);
+        this.#coordinationEnabled = false;
+        this.#cancelReloadDelay?.();
+
+        const roundCancelled = this.#cancelCurrentRound();
+        const schedulerStopped = super.stop(false);
+        const vdfClosed = this.#vdfServiceManager.close();
+
+        await Promise.all([
+            roundCancelled,
+            schedulerStopped,
+            this.#configReloadPromise,
+            vdfClosed,
+        ]);
+    }
+
+    /**
+     * Opens the VDF service if needed and starts the scheduler.
+     *
+     * @param {number} initialDelayMs delay before the first coordination round
+     * @returns {Promise<boolean>} true when the scheduler was started
+     */
+    async start(initialDelayMs = this.#roundIntervalMs) {
+        if (this.isSchedulerRunning || this.closing !== null || this.closed) return false;
+
+        this.#coordinationEnabled = true;
+
+        try {
+            await this.#openVdf();
+        } catch (error) {
+            this.#logger.error(`[EpochCoordinatorService] failed to initialize VDF service: ${error.message}`);
+            return false;
+        }
+
+        if (!this.#canStart()) return false;
+        return super.start(initialDelayMs);
+    }
+
+    /**
+     * Stops the scheduler and cancels the current round.
+     *
+     * @param {boolean} waitForCurrent wait for operations which have already started
+     * @returns {Promise<boolean>} true when a running scheduler was stopped
+     */
+    async stop(waitForCurrent = true) {
+        this.#coordinationEnabled = false;
+        this.#cancelReloadDelay?.();
+        const roundCancelled = this.#cancelCurrentRound();
+        const schedulerStopped = await super.stop(false);
+
+        await roundCancelled;
+        if (waitForCurrent) {
+            await Promise.allSettled([...this.#pendingRoundExecutions]);
+        }
+
+        return schedulerStopped;
+    }
+
+    /** @returns {number} delay between coordination rounds */
+    getScheduleInterval() {
+        return this.#roundIntervalMs;
+    }
+
+    /**
+     * Starts one round and lets it schedule the next run. Only the current round may set the next
+     * timer. A result from an older round cannot replace it.
+     *
+     * @param {function(number): void} scheduleNextRound Schedules the next round after the given delay in milliseconds.
+     * @param {function(): void} holdScheduling Prevent the scheduler from scheduling automatically.
+     * @returns {Promise<void>} Completes when run() returns. The round may still be active.
+     */
+    async worker(scheduleNextRound, holdScheduling) {
+        if (!this.#canRun()) return;
+
+        const epochOperations = this.#vdfServiceManager.operations;
+        if (!epochOperations) return;
+
+        holdScheduling();
+
+        const round = new EpochCoordinationRound({
+            state: this.#state,
+            wallet: this.#wallet,
+            config: this.#config,
+            manager: this.#indexerConnectionManager,
+            logger: this.#logger,
+            operations: epochOperations,
+            intervalMs: this.#roundIntervalMs,
+            appenderSelector: this.#appenderSelector,
+        });
+
+        this.#replaceCurrentRound(round);
+
+        const roundExecution = round.run((delayMs) => this.#scheduleNextRound(round, scheduleNextRound, delayMs));
+        this.#pendingRoundExecutions.add(roundExecution);
+
+        try {
+            await roundExecution;
+        } catch (error) {
+            if (round !== this.#currentRound || !this.#canRun()) return;
+
+            this.#logger.error(`[EpochCoordinatorService] round failed: ${error.message}`);
+            await this.#cancelRound(round);
+            this.#scheduleNextRound(round, scheduleNextRound, this.#roundIntervalMs);
+        } finally {
+            this.#pendingRoundExecutions.delete(roundExecution);
+        }
+    }
+
+    /**
+     * Waits for any config reload and opens the VDF service before scheduling starts. Repeats if
+     * another reload starts while the service is opening.
+     *
+     * @returns {Promise<void>}
+     */
+    async #openVdf() {
+        do {
+            if (this.#configReloadPromise) await this.#configReloadPromise;
+            await this.#vdfServiceManager.open();
+        } while (this.#configReloadPromise);
+    }
+
+    /**
+     * Checks whether the scheduler can run or schedule another round.
+     *
+     * @returns {boolean}
+     */
+    #canRun() {
+        return this.#canStart() && !this.isInterrupted;
+    }
+
+    /**
+     * Checks whether coordination is enabled and the service can start. A temporary scheduler stop
+     * during config reload does not disable coordination.
+     *
+     * @returns {boolean}
+     */
+    #canStart() {
+        return this.#coordinationEnabled && this.closing === null && !this.closed;
+    }
+
+    /**
+     * Sets the current round and cancels the previous one.
+     *
+     * @param {EpochCoordinationRound} round New round to use for coordination.
+     */
+    #replaceCurrentRound(round) {
+        const previousRound = this.#currentRound;
+        this.#currentRound = round;
+
+        if (previousRound) void this.#cancelRound(previousRound);
+    }
+
+    /**
+     * Clears the current round and waits for its cancellation.
+     *
+     * @returns {Promise<void>}
+     */
+    async #cancelCurrentRound() {
+        const round = this.#currentRound;
+        this.#currentRound = null;
+
+        if (round) await this.#cancelRound(round);
+    }
+
+    /**
+     * Cancels a round and logs any cleanup error.
+     *
+     * @param {EpochCoordinationRound} round Round to cancel.
+     * @returns {Promise<void>}
+     */
+    async #cancelRound(round) {
+        try {
+            await round.cancel();
+        } catch (error) {
+            this.#logger.error(`[EpochCoordinatorService] failed to cancel epoch round: ${error.message}`);
+        }
+    }
+
+    /**
+     * Schedules the next run if this round is still current. A callback from an older round cannot
+     * change the timer.
+     *
+     * @param {EpochCoordinationRound} round Round requesting the next run.
+     * @param {(delay: number) => void} scheduleNextRound Callback that sets the next scheduler timer.
+     * @param {number} delayMs Delay before the next round, in milliseconds.
+     */
+    #scheduleNextRound(round, scheduleNextRound, delayMs) {
+        if (round !== this.#currentRound || !this.#canRun()) return;
+
+        this.#currentRound = null;
+        scheduleNextRound(delayMs);
+    }
+
+    /**
+     * Starts a consensus config reload. Events received during the same reload are ignored.
+     *
+     * @returns {void}
+     */
+    #handleConfigChange() {
+        if (this.closing !== null || this.closed || this.#configReloadPromise) return;
+        this.#configReloadPromise = this.#reloadConfig();
+    }
+
+    /**
+     * Cancels the round, stops the scheduler and reloads VDF. Restarts scheduling if coordination is
+     * still enabled.
+     *
+     * @returns {Promise<void>}
+     */
+    async #reloadConfig() {
+        const shouldRestart = this.#coordinationEnabled;
+
+        try {
+            await Promise.all([
+                this.#cancelCurrentRound(),
+                super.stop(false),
+                shouldRestart ? this.#reloadVdf() : this.#vdfServiceManager.close(),
+            ]);
+        } catch (error) {
+            this.#logger.error(`[EpochCoordinatorService] config reload failed: ${error.message}`);
+            return;
+        } finally {
+            this.#configReloadPromise = null;
+        }
+
+        if (!shouldRestart) return;
+        if (!this.#vdfServiceManager.operations || !this.#canStart()) return;
+
+        super.start(0);
+    }
+
+    /** Reloads VDF and retries on failure while coordination remains enabled. */
+    async #reloadVdf() {
+        while (this.#canStart()) {
+            try {
+                await this.#vdfServiceManager.replace();
+                return true;
+            } catch (error) {
+                if (!this.#canStart()) return false;
+
+                this.#logger.error(
+                    `[EpochCoordinatorService] config reload failed: ${error.message}; ` +
+                    `retrying in ${this.#config.epochBackoffDelay}ms`,
+                );
+                await this.#waitBeforeVdfReloadRetry();
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Waits before retrying a VDF reload. stop() and close() end the wait early.
+     *
+     * @returns {Promise<void>} Resolves when the timer ends or the wait is cancelled.
+     */
+    #waitBeforeVdfReloadRetry() {
+        return new Promise(resolve => {
+            const timer = setTimeout(resolve, this.#config.epochBackoffDelay);
+            this.#cancelReloadDelay = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+        }).finally(() => {
+            this.#cancelReloadDelay = null;
+        });
+    }
+}
+
+export default EpochCoordinatorService;

package/src/core/consensus/services/EpochRoundListeners.js

@@ -0,0 +1,116 @@
+import b4a from 'b4a';
+import { CustomEventType, EPOCH_BYTE_LENGTH } from '../../../utils/constants.js';
+import { EPOCH_EVENTS, EPOCH_STATES } from './EpochStateMachine.js';
+
+/**
+ * Adds an event listener and returns a function that removes it.
+ *
+ * @param {object} eventEmitter Event source with on and off methods.
+ * @param {string} event Event name.
+ * @param {Function} handler Listener called by the source.
+ * @returns {function(): void} Removes this listener.
+ */
+const listenTo = (eventEmitter, event, handler) => {
+    eventEmitter.on(event, handler);
+    return () => eventEmitter.off(event, handler);
+};
+
+/**
+ * Listens for validated proposals and epoch events during one round. Manages the approval timeout and
+ * asks the round to check signed epoch progress. Closing the round's FSM removes the listeners and
+ * timers.
+ */
+export class EpochRoundListeners {
+    #state;
+    #epochStateMachine;
+    #config;
+    #isRoundActive;
+    #listenerCleanups = [];
+    #checkSignedEpochProgress;
+
+    /**
+     * Sets the event sources and callbacks for this round. start() adds the listeners.
+     *
+     * @param {object} dependencies Services and callbacks used by this round.
+     * @param {object} dependencies.state Ledger and consensus event emitter.
+     * @param {import('./EpochStateMachine.js').EpochStateMachine} dependencies.machine Round FSM.
+     * @param {object} dependencies.config Supplies epochSignatureTimeout in milliseconds.
+     * @param {function(): boolean} dependencies.isRoundActive Rejects late events after cancellation or completion.
+     * @param {function(): Promise<void>} dependencies.onEpochProgress Checks signed progress after an epoch event.
+     */
+    constructor({ state, machine: epochStateMachine, config, isRoundActive, onEpochProgress: checkSignedEpochProgress }) {
+        this.#state = state;
+        this.#epochStateMachine = epochStateMachine;
+        this.#config = config;
+        this.#isRoundActive = isRoundActive;
+        this.#checkSignedEpochProgress = checkSignedEpochProgress;
+    }
+
+    /** Starts this round's listeners and timers. They are removed when the FSM closes. */
+    start() {
+        this.#listenForValidatedProposals();
+        this.#listenForEpochCreated();
+        this.#manageApprovalDeadline();
+
+        this.#epochStateMachine.once('close', () => this.#removeListenersAndTimers());
+    }
+
+    /** Removes the listeners and timers added by start(). */
+    #removeListenersAndTimers() {
+        for (const cleanup of this.#listenerCleanups.splice(0)) {
+            cleanup();
+        }
+    }
+
+    /** Marks a remote proposal only if it matches this round's epoch and parent hash. */
+    #listenForValidatedProposals() {
+        this.#listenerCleanups.push(
+            listenTo(this.#state, CustomEventType.EPOCH_PROPOSAL_VALIDATION_SUCCESS, (event) => {
+                if (!this.#isRoundActive()) return;
+                const { currentEpoch, currentEpochHash } = this.#epochStateMachine.context;
+                const { epoch, previous_epoch_record_hash: proposalParentHash } = event?.proofProposal ?? {};
+                // Validation can finish after the round that received the proposal has ended.
+                if (typeof currentEpoch !== 'bigint') return;
+                if (!b4a.isBuffer(epoch) || epoch.length !== EPOCH_BYTE_LENGTH) return;
+                if (epoch.readBigUInt64BE(0) !== currentEpoch + 1n) return;
+                if (!b4a.isBuffer(currentEpochHash) || !b4a.isBuffer(proposalParentHash)) return;
+                if (!b4a.equals(proposalParentHash, currentEpochHash)) return;
+                this.#epochStateMachine.appendContext({ remoteProposalReceived: true });
+            }),
+        );
+    }
+
+    /** Asks the round to check signed progress when an epoch event arrives. */
+    #listenForEpochCreated() {
+        this.#listenerCleanups.push(
+            listenTo(this.#state, CustomEventType.EPOCH_CREATED, async () => {
+                if (!this.#isRoundActive()) return;
+                await this.#checkSignedEpochProgress();
+            }),
+        );
+    }
+
+    /** Starts the approval timer when collection begins and clears it when collection ends. */
+    #manageApprovalDeadline() {
+        let approvalDeadlineTimer = null;
+
+        this.#epochStateMachine.on('*', ({ next, prev }) => {
+            if (!this.#isRoundActive()) return;
+
+            if (next === EPOCH_STATES.COLLECT_APPROVALS && prev !== EPOCH_STATES.COLLECT_APPROVALS) {
+                approvalDeadlineTimer = setTimeout(
+                    () => {
+                        if (this.#isRoundActive()) {
+                            this.#epochStateMachine.send(EPOCH_EVENTS.APPROVAL_COLLECTION_FAILED);
+                        }
+                    },
+                    this.#config.epochSignatureTimeout,
+                );
+            } else if (prev === EPOCH_STATES.COLLECT_APPROVALS && next !== EPOCH_STATES.COLLECT_APPROVALS) {
+                clearTimeout(approvalDeadlineTimer);
+            }
+        });
+
+        this.#listenerCleanups.push(() => clearTimeout(approvalDeadlineTimer));
+    }
+}