@aztec/sequencer-client 3.0.0-nightly.20251221 → 3.0.0-nightly.20251223

package/dest/sequencer/checkpoint_proposal_job.js

@@ -0,0 +1,638 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { filter } from '@aztec/foundation/iterator';
+import { sleep, sleepUntil } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { unfreeze } from '@aztec/foundation/types';
+import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { Gas } from '@aztec/stdlib/gas';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
+import { CheckpointVoter } from './checkpoint_voter.js';
+import { SequencerInterruptedError } from './errors.js';
+import { SequencerState } from './utils.js';
+/** How much time to sleep while waiting for min transactions to accumulate for a block */ const TXS_POLLING_MS = 500;
+/** What's the latest time before a block build deadline we're willing to *start* building it */ const MIN_BLOCK_BUILD_TIME_MS = 1000;
+/**
+ * Handles the execution of a checkpoint proposal after the initial preparation phase.
+ * This includes building blocks, collecting attestations, and publishing the checkpoint to L1,
+ * as well as enqueueing votes for slashing and governance proposals. This class is created from
+ * the Sequencer once the check for being the proposer for the slot has succeeded.
+ */ export class CheckpointProposalJob {
+    slot;
+    checkpointNumber;
+    syncedToBlockNumber;
+    proposer;
+    publisher;
+    attestorAddress;
+    invalidateBlock;
+    validatorClient;
+    globalsBuilder;
+    p2pClient;
+    worldState;
+    l1ToL2MessageSource;
+    checkpointsBuilder;
+    l1Constants;
+    config;
+    timetable;
+    slasherClient;
+    epochCache;
+    dateProvider;
+    metrics;
+    eventEmitter;
+    setStateFn;
+    log;
+    constructor(slot, checkpointNumber, syncedToBlockNumber, // TODO(palla/mbps): Can we remove the proposer in favor of attestorAddress? Need to check fisherman-node flows.
+    proposer, publisher, attestorAddress, invalidateBlock, validatorClient, globalsBuilder, p2pClient, worldState, l1ToL2MessageSource, checkpointsBuilder, l1Constants, config, timetable, slasherClient, epochCache, dateProvider, metrics, eventEmitter, setStateFn, log){
+        this.slot = slot;
+        this.checkpointNumber = checkpointNumber;
+        this.syncedToBlockNumber = syncedToBlockNumber;
+        this.proposer = proposer;
+        this.publisher = publisher;
+        this.attestorAddress = attestorAddress;
+        this.invalidateBlock = invalidateBlock;
+        this.validatorClient = validatorClient;
+        this.globalsBuilder = globalsBuilder;
+        this.p2pClient = p2pClient;
+        this.worldState = worldState;
+        this.l1ToL2MessageSource = l1ToL2MessageSource;
+        this.checkpointsBuilder = checkpointsBuilder;
+        this.l1Constants = l1Constants;
+        this.config = config;
+        this.timetable = timetable;
+        this.slasherClient = slasherClient;
+        this.epochCache = epochCache;
+        this.dateProvider = dateProvider;
+        this.metrics = metrics;
+        this.eventEmitter = eventEmitter;
+        this.setStateFn = setStateFn;
+        this.log = log;
+    }
+    /**
+   * Executes the checkpoint proposal job.
+   * Returns the published checkpoint if successful, undefined otherwise.
+   */ async execute() {
+        // Enqueue governance and slashing votes (returns promises that will be awaited later)
+        // In fisherman mode, we simulate slashing but don't actually publish to L1
+        // These are constant for the whole slot, so we only enqueue them once
+        const votesPromises = new CheckpointVoter(this.slot, this.publisher, this.attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log).enqueueVotes();
+        // Build and propose the checkpoint. This will enqueue the request on the publisher if a checkpoint is built.
+        const checkpoint = await this.proposeCheckpoint();
+        // Wait until the voting promises have resolved, so all requests are enqueued (not sent)
+        await Promise.all(votesPromises);
+        // Do not post anything to L1 if we are fishermen, but do perform L1 fee analysis
+        if (this.config.fishermanMode) {
+            await this.handleCheckpointEndAsFisherman(checkpoint);
+            return;
+        }
+        // Then send everything to L1
+        const l1Response = await this.publisher.sendRequests();
+        const proposedAction = l1Response?.successfulActions.find((a)=>a === 'propose');
+        if (proposedAction) {
+            this.eventEmitter.emit('checkpoint-published', {
+                checkpoint: this.checkpointNumber,
+                slot: this.slot
+            });
+            const coinbase = checkpoint?.header.coinbase;
+            await this.metrics.incFilledSlot(this.publisher.getSenderAddress().toString(), coinbase);
+            return checkpoint;
+        } else if (checkpoint) {
+            this.eventEmitter.emit('checkpoint-publish-failed', {
+                ...l1Response,
+                slot: this.slot
+            });
+            return undefined;
+        }
+    }
+    async proposeCheckpoint() {
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                // Get operator configured coinbase and fee recipient for this attestor
+                const coinbase = this.validatorClient.getCoinbaseForAttestor(this.attestorAddress);
+                const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(this.attestorAddress);
+                // Start the checkpoint
+                this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.slot);
+                this.metrics.incOpenSlot(this.slot, this.proposer?.toString() ?? 'unknown');
+                // Enqueues block invalidation (constant for the whole slot)
+                if (this.invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
+                    this.publisher.enqueueInvalidateBlock(this.invalidateBlock);
+                }
+                // Create checkpoint builder for the slot
+                const checkpointGlobalVariables = await this.globalsBuilder.buildCheckpointGlobalVariables(coinbase, feeRecipient, this.slot);
+                // Collect L1 to L2 messages for the checkpoint
+                const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(this.checkpointNumber);
+                const fork = _ts_add_disposable_resource(env, await this.worldState.fork(this.syncedToBlockNumber, {
+                    closeDelayMs: 12_000
+                }), false);
+                // Create checkpoint builder for the entire slot
+                const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(this.checkpointNumber, checkpointGlobalVariables, l1ToL2Messages, fork);
+                // Options for the validator client when creating block and checkpoint proposals
+                const blockProposalOptions = {
+                    publishFullTxs: !!this.config.publishTxsWithProposals,
+                    broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
+                };
+                // Main loop: build blocks for the checkpoint
+                const { blocksInCheckpoint, pendingBroadcast } = await this.buildBlocksForCheckpoint(checkpointBuilder, checkpointGlobalVariables.timestamp, blockProposalOptions);
+                if (blocksInCheckpoint.length === 0) {
+                    this.log.warn(`No blocks were built for slot ${this.slot}`, {
+                        slot: this.slot
+                    });
+                    this.eventEmitter.emit('checkpoint-empty', {
+                        slot: this.slot
+                    });
+                    return undefined;
+                }
+                // Assemble and broadcast the checkpoint proposal, including the last block that was not
+                // broadcasted yet, and wait to collect the committee attestations.
+                this.setStateFn(SequencerState.FINALIZING_CHECKPOINT, this.slot);
+                const checkpoint = await checkpointBuilder.completeCheckpoint();
+                // Do not collect attestations nor publish to L1 in fisherman mode
+                if (this.config.fishermanMode) {
+                    this.log.info(`Built checkpoint for slot ${this.slot} with ${blocksInCheckpoint.length} blocks. ` + `Skipping proposal in fisherman mode.`, {
+                        slot: this.slot,
+                        checkpoint: checkpoint.header.toInspect(),
+                        blocksBuilt: blocksInCheckpoint.length
+                    });
+                    this.metrics.recordCheckpointSuccess();
+                    return checkpoint;
+                }
+                // TODO(palla/mbps): Wire this to the new p2p API once available, including the pendingBroadcast.block
+                const proposal = await this.validatorClient.createCheckpointProposal(checkpoint.header, checkpoint.archive.root, pendingBroadcast?.txs ?? [], this.proposer, blockProposalOptions);
+                await this.p2pClient.broadcastProposal(proposal);
+                this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.slot);
+                const attestations = await this.waitForAttestations(proposal);
+                // Proposer must sign over the attestations before pushing them to L1
+                const signer = this.proposer ?? this.publisher.getSenderAddress();
+                const attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer);
+                // Enqueue publishing the checkpoint to L1
+                this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.slot);
+                const aztecSlotDuration = this.l1Constants.slotDuration;
+                const slotStartBuildTimestamp = this.getSlotStartBuildTimestamp();
+                const txTimeoutAt = new Date((slotStartBuildTimestamp + aztecSlotDuration) * 1000);
+                await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
+                    txTimeoutAt,
+                    forcePendingBlockNumber: this.invalidateBlock?.forcePendingBlockNumber
+                });
+                return checkpoint;
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                _ts_dispose_resources(env);
+            }
+        } catch (err) {
+            this.log.error(`Error building checkpoint at slot ${this.slot}`, err);
+            return undefined;
+        }
+    }
+    /**
+   * Builds blocks for a checkpoint within the current slot.
+   */ async buildBlocksForCheckpoint(checkpointBuilder, timestamp, blockProposalOptions) {
+        const blocksInCheckpoint = [];
+        const txHashesAlreadyIncluded = new Set();
+        const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
+        // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
+        let pendingBroadcast = undefined;
+        while(true){
+            const blocksBuilt = blocksInCheckpoint.length;
+            const indexWithinCheckpoint = blocksBuilt;
+            const blockNumber = BlockNumber(initialBlockNumber + blocksBuilt);
+            const secondsIntoSlot = this.getSecondsIntoSlot();
+            const timingInfo = this.timetable.canStartNextBlock(secondsIntoSlot);
+            if (!timingInfo.canStart) {
+                this.log.debug(`Not enough time left in slot to start another block`, {
+                    slot: this.slot,
+                    blocksBuilt,
+                    secondsIntoSlot
+                });
+                break;
+            }
+            const buildResult = await this.buildSingleBlock(checkpointBuilder, {
+                // Create all blocks with the same timestamp
+                blockTimestamp: timestamp,
+                // Create an empty block if we haven't already and this is the last one
+                forceCreate: timingInfo.isLastBlock && blocksBuilt === 0 && this.config.buildCheckpointIfEmpty,
+                // Build deadline is only set if we are enforcing the timetable
+                buildDeadline: timingInfo.deadline ? new Date((this.getSlotStartBuildTimestamp() + timingInfo.deadline) * 1000) : undefined,
+                blockNumber,
+                indexWithinCheckpoint,
+                txHashesAlreadyIncluded
+            });
+            if (!buildResult && timingInfo.isLastBlock) {
+                break;
+            } else if (!buildResult) {
+                // But if there is still time for more blocks, wait until the next block time and try again
+                await this.waitUntilNextBlock(secondsIntoSlot);
+                continue;
+            } else if ('error' in buildResult) {
+                // If there was an error building the block, just exit the loop and give up the rest of the slot
+                if (!(buildResult.error instanceof SequencerInterruptedError)) {
+                    this.log.warn(`Halting block building for slot ${this.slot}`, {
+                        slot: this.slot,
+                        blocksBuilt,
+                        error: buildResult.error
+                    });
+                }
+                break;
+            }
+            const { block, usedTxs } = buildResult;
+            blocksInCheckpoint.push(block);
+            // Sync the proposed block to the archiver to make it available
+            // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
+            // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
+            await this.syncProposedBlockToArchiver(block);
+            // If this is the last block, exit the loop now so we start collecting attestations
+            if (timingInfo.isLastBlock) {
+                this.log.verbose(`Completed final block ${blockNumber} for slot ${this.slot}`, {
+                    slot: this.slot,
+                    blockNumber,
+                    blocksBuilt
+                });
+                pendingBroadcast = {
+                    block,
+                    txs: usedTxs
+                };
+                break;
+            }
+            // For non-last blocks, broadcast the block proposal (unless we're in fisherman mode)
+            // If the block is the last one, we'll broadcast it along with the checkpoint at the end of the loop
+            if (!this.config.fishermanMode) {
+                // TODO(palla/mbps): Wire this to the new p2p API once available
+                const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, (await checkpointBuilder.getCheckpoint()).header, block.archive.root, usedTxs, this.proposer, blockProposalOptions);
+                await this.p2pClient.broadcastProposal(proposal);
+            }
+            // Wait until the next block's start time
+            await this.waitUntilNextBlock(secondsIntoSlot);
+        }
+        this.log.verbose(`Block building loop completed for slot ${this.slot}`, {
+            slot: this.slot,
+            blocksBuilt: blocksInCheckpoint.length
+        });
+        return {
+            blocksInCheckpoint,
+            pendingBroadcast
+        };
+    }
+    /** Sleeps until it is time to produce the next block in the slot */ async waitUntilNextBlock(blockStartedAtSecondsIntoSlot) {
+        this.setStateFn(SequencerState.WAITING_UNTIL_NEXT_BLOCK, this.slot);
+        const blockDurationSeconds = this.timetable.blockDuration;
+        const nextBlockStart = blockStartedAtSecondsIntoSlot + blockDurationSeconds;
+        this.log.verbose(`Waiting until time for the next block at ${nextBlockStart}s into slot`, {
+            slot: this.slot
+        });
+        await this.waitUntilTimeInSlot(nextBlockStart);
+    }
+    /** Builds a single block. Called from the main block building loop. */ async buildSingleBlock(checkpointBuilder, opts) {
+        const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } = opts;
+        this.log.verbose(`Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.slot}`, {
+            ...checkpointBuilder.getConstantData(),
+            ...opts
+        });
+        try {
+            // Wait until we have enough txs to build the block
+            const minTxs = this.config.minTxsPerBlock;
+            const { availableTxs, canStartBuilding } = await this.waitForMinTxs(opts);
+            if (!canStartBuilding) {
+                this.log.warn(`Not enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.slot} (got ${availableTxs} txs but needs ${minTxs})`, {
+                    blockNumber,
+                    slot: this.slot,
+                    indexWithinCheckpoint
+                });
+                this.eventEmitter.emit('block-tx-count-check-failed', {
+                    minTxs,
+                    availableTxs,
+                    slot: this.slot
+                });
+                this.metrics.recordBlockProposalFailed('insufficient_txs');
+                return undefined;
+            }
+            // Create iterator to pending txs. We filter out txs already included in previous blocks in the checkpoint
+            // just in case p2p failed to sync the provisional block and didn't get to remove those txs from the mempool yet.
+            const pendingTxs = filter(this.p2pClient.iteratePendingTxs(), (tx)=>!txHashesAlreadyIncluded.has(tx.txHash.toString()));
+            this.log.debug(`Building block ${blockNumber} at index ${indexWithinCheckpoint} for slot ${this.slot} with ${availableTxs} available txs`, {
+                slot: this.slot,
+                blockNumber,
+                indexWithinCheckpoint
+            });
+            this.setStateFn(SequencerState.CREATING_BLOCK, this.slot);
+            const blockBuilderOptions = {
+                maxTransactions: this.config.maxTxsPerBlock,
+                maxBlockSize: this.config.maxBlockSizeInBytes,
+                maxBlockGas: new Gas(this.config.maxDABlockGas, this.config.maxL2BlockGas),
+                maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
+                deadline: buildDeadline
+            };
+            // Actually build the block by executing txs
+            const workTimer = new Timer();
+            const { publicGas, block, publicProcessorDuration, numTxs, blockBuildingTimer, usedTxs, failedTxs } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+            const blockBuildDuration = workTimer.ms();
+            // If any txs failed during execution, drop them from the mempool so we don't pick them up again
+            await this.dropFailedTxsFromP2P(failedTxs);
+            // Check if we have created a block with enough txs. If there were invalid txs in the pool, or if execution took
+            // too long, then we may not get to minTxsPerBlock after executing public functions.
+            const minValidTxs = this.config.minValidTxsPerBlock ?? minTxs;
+            if (!forceCreate && numTxs < minValidTxs) {
+                this.log.warn(`Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed (got ${numTxs} but required ${minValidTxs})`, {
+                    slot: this.slot,
+                    blockNumber,
+                    numTxs,
+                    indexWithinCheckpoint
+                });
+                this.eventEmitter.emit('block-tx-count-check-failed', {
+                    minTxs: minValidTxs,
+                    availableTxs: numTxs,
+                    slot: this.slot
+                });
+                this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
+                return undefined;
+            }
+            // Block creation succeeded, emit stats and metrics
+            const blockStats = {
+                eventName: 'l2-block-built',
+                duration: blockBuildDuration,
+                publicProcessDuration: publicProcessorDuration,
+                rollupCircuitsDuration: blockBuildingTimer.ms(),
+                ...block.getStats()
+            };
+            const blockHash = await block.hash();
+            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+            const manaPerSec = publicGas.l2Gas / (blockBuildDuration / 1000);
+            this.log.info(`Built block ${block.number} at checkpoint ${this.checkpointNumber} for slot ${this.slot} with ${numTxs} txs`, {
+                blockHash,
+                txHashes,
+                manaPerSec,
+                ...blockStats
+            });
+            this.eventEmitter.emit('block-proposed', {
+                blockNumber: block.number,
+                slot: this.slot
+            });
+            this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
+            return {
+                block,
+                usedTxs
+            };
+        } catch (err) {
+            this.eventEmitter.emit('block-build-failed', {
+                reason: err.message,
+                slot: this.slot
+            });
+            this.log.error(`Error building block`, err, {
+                blockNumber,
+                slot: this.slot
+            });
+            this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
+            this.metrics.recordFailedBlock();
+            return {
+                error: err
+            };
+        }
+    }
+    /** Waits until minTxs are available on the pool for building a block. */ async waitForMinTxs(opts) {
+        const minTxs = this.config.minTxsPerBlock;
+        const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
+        // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
+        const startBuildingDeadline = buildDeadline ? new Date(buildDeadline.getTime() - MIN_BLOCK_BUILD_TIME_MS) : undefined;
+        let availableTxs = await this.p2pClient.getPendingTxCount();
+        while(!forceCreate && availableTxs < minTxs){
+            // If we're past deadline, or we have no deadline, give up
+            const now = this.dateProvider.nowAsDate();
+            if (startBuildingDeadline === undefined || now >= startBuildingDeadline) {
+                return {
+                    canStartBuilding: false,
+                    availableTxs: availableTxs
+                };
+            }
+            // Wait a bit before checking again
+            this.setStateFn(SequencerState.WAITING_FOR_TXS, this.slot);
+            this.log.verbose(`Waiting for enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.slot} (have ${availableTxs} but need ${minTxs})`, {
+                blockNumber,
+                slot: this.slot,
+                indexWithinCheckpoint
+            });
+            await sleep(TXS_POLLING_MS);
+            availableTxs = await this.p2pClient.getPendingTxCount();
+        }
+        return {
+            canStartBuilding: true,
+            availableTxs
+        };
+    }
+    /**
+   * Waits for enough attestations to be collected via p2p.
+   * This is run after all blocks for the checkpoint have been built.
+   */ async waitForAttestations(proposal) {
+        if (this.config.fishermanMode) {
+            this.log.debug('Skipping attestation collection in fisherman mode');
+            return CommitteeAttestationsAndSigners.empty();
+        }
+        const slotNumber = proposal.slotNumber;
+        const { committee, seed, epoch } = await this.epochCache.getCommittee(slotNumber);
+        if (!committee) {
+            throw new Error('No committee when collecting attestations');
+        } else if (committee.length === 0) {
+            this.log.verbose(`Attesting committee is empty`);
+            return CommitteeAttestationsAndSigners.empty();
+        } else {
+            this.log.debug(`Attesting committee length is ${committee.length}`, {
+                committee
+            });
+        }
+        const numberOfRequiredAttestations = Math.floor(committee.length * 2 / 3) + 1;
+        if (this.config.skipCollectingAttestations) {
+            this.log.warn('Skipping attestation collection as per config (attesting with own keys only)');
+            const attestations = await this.validatorClient?.collectOwnAttestations(proposal);
+            return new CommitteeAttestationsAndSigners(orderAttestations(attestations ?? [], committee));
+        }
+        const attestationTimeAllowed = this.config.enforceTimeTable ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_CHECKPOINT) : this.l1Constants.slotDuration;
+        const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
+        const collectAttestationsTimer = new Timer();
+        let collectedAttestationsCount = 0;
+        try {
+            const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
+            collectedAttestationsCount = attestations.length;
+            // Rollup contract requires that the signatures are provided in the order of the committee
+            const sorted = orderAttestations(attestations, committee);
+            // Manipulate the attestations if we've been configured to do so
+            if (this.config.injectFakeAttestation || this.config.shuffleAttestationOrdering) {
+                const checkpoint = proposal.payload.header;
+                return this.manipulateAttestations(checkpoint, epoch, seed, committee, sorted);
+            }
+            return new CommitteeAttestationsAndSigners(sorted);
+        } catch (err) {
+            if (err && err instanceof AttestationTimeoutError) {
+                collectedAttestationsCount = err.collectedCount;
+            }
+            throw err;
+        } finally{
+            this.metrics.recordCollectedAttestations(collectedAttestationsCount, collectAttestationsTimer.ms());
+        }
+    }
+    /** Breaks the attestations before publishing based on attack configs */ manipulateAttestations(checkpoint, epoch, seed, committee, attestations) {
+        // Compute the proposer index in the committee, since we dont want to tweak it.
+        // Otherwise, the L1 rollup contract will reject the block outright.
+        const { slotNumber } = checkpoint;
+        const proposerIndex = Number(this.epochCache.computeProposerIndex(slotNumber, epoch, seed, BigInt(committee.length)));
+        if (this.config.injectFakeAttestation) {
+            // Find non-empty attestations that are not from the proposer
+            const nonProposerIndices = [];
+            for(let i = 0; i < attestations.length; i++){
+                if (!attestations[i].signature.isEmpty() && i !== proposerIndex) {
+                    nonProposerIndices.push(i);
+                }
+            }
+            if (nonProposerIndices.length > 0) {
+                const targetIndex = nonProposerIndices[randomInt(nonProposerIndices.length)];
+                this.log.warn(`Injecting fake attestation in checkpoint for slot ${slotNumber} at index ${targetIndex}`);
+                unfreeze(attestations[targetIndex]).signature = Signature.random();
+            }
+            return new CommitteeAttestationsAndSigners(attestations);
+        }
+        if (this.config.shuffleAttestationOrdering) {
+            this.log.warn(`Shuffling attestation ordering in checkpoint for slot ${slotNumber} (proposer #${proposerIndex})`);
+            const shuffled = [
+                ...attestations
+            ];
+            const [i, j] = [
+                (proposerIndex + 1) % shuffled.length,
+                (proposerIndex + 2) % shuffled.length
+            ];
+            const valueI = shuffled[i];
+            const valueJ = shuffled[j];
+            shuffled[i] = valueJ;
+            shuffled[j] = valueI;
+            const signers = new CommitteeAttestationsAndSigners(attestations).getSigners();
+            return new MaliciousCommitteeAttestationsAndSigners(shuffled, signers);
+        }
+        return new CommitteeAttestationsAndSigners(attestations);
+    }
+    async dropFailedTxsFromP2P(failedTxs) {
+        if (failedTxs.length === 0) {
+            return;
+        }
+        const failedTxData = failedTxs.map((fail)=>fail.tx);
+        const failedTxHashes = failedTxData.map((tx)=>tx.getTxHash());
+        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+        await this.p2pClient.deleteTxs(failedTxHashes);
+    }
+    /**
+   * Placeholder for pushing block to archiver and waiting for sync.
+   * To be implemented when archiver and world-state support proposed blocks.
+   */ async syncProposedBlockToArchiver(block) {
+        this.log.debug(`Syncing proposed block ${block.number}`, {
+            blockNumber: block.number,
+            slot: block.header.globalVariables.slotNumber
+        });
+        // TODO(palla/mbps): Implement actual sync to archiver and world-state
+        await Promise.resolve();
+    }
+    /** Runs fee analysis and logs checkpoint outcome as fisherman */ async handleCheckpointEndAsFisherman(checkpoint) {
+        // Perform L1 fee analysis before clearing requests
+        // The callback is invoked asynchronously after the next block is mined
+        const feeAnalysis = await this.publisher.analyzeL1Fees(this.slot, (analysis)=>this.metrics.recordFishermanFeeAnalysis(analysis));
+        if (checkpoint) {
+            this.log.info(`Validation checkpoint building SUCCEEDED for slot ${this.slot}`, {
+                ...checkpoint.toCheckpointInfo(),
+                ...checkpoint.getStats(),
+                feeAnalysisId: feeAnalysis?.id
+            });
+            this.metrics.recordBlockProposalSuccess();
+        } else {
+            this.log.warn(`Validation block building FAILED for slot ${this.slot}`, {
+                slot: this.slot,
+                feeAnalysisId: feeAnalysis?.id
+            });
+            this.metrics.recordBlockProposalFailed('block_build_failed');
+        }
+        this.publisher.clearPendingRequests();
+    }
+    /** Waits until a specific time within the current slot */ async waitUntilTimeInSlot(targetSecondsIntoSlot) {
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
+        const targetTimestamp = slotStartTimestamp + targetSecondsIntoSlot;
+        await sleepUntil(new Date(targetTimestamp * 1000), this.dateProvider.nowAsDate());
+    }
+    getSlotStartBuildTimestamp() {
+        return getSlotStartBuildTimestamp(this.slot, this.l1Constants);
+    }
+    getSecondsIntoSlot() {
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
+        return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
+    }
+    getPublisher() {
+        return this.publisher;
+    }
+}

package/dest/sequencer/checkpoint_voter.d.ts

@@ -0,0 +1,34 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { SlasherClientInterface } from '@aztec/slasher';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import type { ValidatorClient } from '@aztec/validator-client';
+import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import type { SequencerMetrics } from './metrics.js';
+import type { SequencerRollupConstants } from './types.js';
+/**
+ * Handles governance and slashing voting for a given slot.
+ */
+export declare class CheckpointVoter {
+    private readonly slot;
+    private readonly publisher;
+    private readonly attestorAddress;
+    private readonly validatorClient;
+    private readonly slasherClient;
+    private readonly l1Constants;
+    private readonly config;
+    private readonly metrics;
+    private readonly log;
+    private slotTimestamp;
+    private signer;
+    constructor(slot: SlotNumber, publisher: SequencerPublisher, attestorAddress: EthAddress, validatorClient: ValidatorClient, slasherClient: SlasherClientInterface | undefined, l1Constants: SequencerRollupConstants, config: ResolvedSequencerConfig, metrics: SequencerMetrics, log: Logger);
+    /**
+     * Enqueues governance and slashing votes with the publisher.
+     * Returns a tuple of promises that resolve to whether each vote was successfully enqueued.
+     */
+    enqueueVotes(): [Promise<boolean | undefined>, Promise<boolean | undefined>];
+    private enqueueGovernanceVote;
+    private enqueueSlashingVote;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF92b3Rlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcXVlbmNlci9jaGVja3BvaW50X3ZvdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2xFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0QsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMvRSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUkvRCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTNEOztHQUVHO0FBQ0gscUJBQWEsZUFBZTtJQUt4QixPQUFPLENBQUMsUUFBUSxDQUFDLElBQUk7SUFDckIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBQzFCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZTtJQUNoQyxPQUFPLENBQUMsUUFBUSxDQUFDLGVBQWU7SUFDaEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBQzlCLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVztJQUM1QixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUFPO0lBQ3hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQVp0QixPQUFPLENBQUMsYUFBYSxDQUFTO0lBQzlCLE9BQU8sQ0FBQyxNQUFNLENBQXVEO0lBRXJFLFlBQ21CLElBQUksRUFBRSxVQUFVLEVBQ2hCLFNBQVMsRUFBRSxrQkFBa0IsRUFDN0IsZUFBZSxFQUFFLFVBQVUsRUFDM0IsZUFBZSxFQUFFLGVBQWUsRUFDaEMsYUFBYSxFQUFFLHNCQUFzQixHQUFHLFNBQVMsRUFDakQsV0FBVyxFQUFFLHdCQUF3QixFQUNyQyxNQUFNLEVBQUUsdUJBQXVCLEVBQy9CLE9BQU8sRUFBRSxnQkFBZ0IsRUFDekIsR0FBRyxFQUFFLE1BQU0sRUFLN0I7SUFFRDs7O09BR0c7SUFDSCxZQUFZLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxHQUFHLFNBQVMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxPQUFPLEdBQUcsU0FBUyxDQUFDLENBQUMsQ0FVM0U7WUFFYSxxQkFBcUI7WUF5QnJCLG1CQUFtQjtDQTBCbEMifQ==