@aztec/sequencer-client 0.0.1-commit.d3ec352c → 0.0.1-commit.fcb71a6

package/dest/sequencer/sequencer.js

@@ -4,30 +4,24 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { FormattedViemError, NoCommitteeError } from '@aztec/ethereum';
+import { getKzg } from '@aztec/blob-lib';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { omit, pick } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
+import { merge, omit, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { Timer } from '@aztec/foundation/timer';
-import { unfreeze } from '@aztec/foundation/types';
-import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
-import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment } from '@aztec/stdlib/tx';
-import { AttestationTimeoutError } from '@aztec/stdlib/validators';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import EventEmitter from 'node:events';
+import { DefaultSequencerConfig } from '../config.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
 import { SequencerMetrics } from './metrics.js';
 import { SequencerTimetable } from './timetable.js';
@@ -35,12 +29,11 @@ import { SequencerState } from './utils.js';
 export { SequencerState };
 /**
  * Sequencer client
- * - Wins a period of time to become the sequencer (depending on finalized protocol).
- * - Chooses a set of txs from the tx pool to be in the rollup.
- * - Simulate the rollup of txs.
- * - Adds proof requests to the request pool (not for this milestone).
- * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
- * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
+ * - Checks whether it is elected as proposer for the next slot
+ * - Builds multiple blocks and broadcasts them
+ * - Collects attestations for the checkpoint
+ * - Publishes the checkpoint to L1
+ * - Votes for proposals and slashes on L1
  */ export class Sequencer extends EventEmitter {
     publisherFactory;
     validatorClient;
@@ -50,116 +43,64 @@ export { SequencerState };
     slasherClient;
     l2BlockSource;
     l1ToL2MessageSource;
-    blockBuilder;
+    checkpointsBuilder;
     l1Constants;
     dateProvider;
     epochCache;
     rollupContract;
-    config;
     telemetry;
     log;
     runningPromise;
-    pollingIntervalMs;
-    maxTxsPerBlock;
-    minTxsPerBlock;
-    maxL1TxInclusionTimeIntoSlot;
     state;
-    maxBlockSizeInBytes;
-    maxBlockGas;
     metrics;
-    lastBlockPublished;
-    governanceProposerPayload;
     /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */ lastSlotForVoteWhenSyncFailed;
-    /** The last slot for which we built a validation block in fisherman mode, to prevent duplicate attempts. */ lastSlotForValidationBlock;
+    /** The last slot for which we triggered a checkpoint proposal job, to prevent duplicate attempts. */ lastSlotForCheckpointProposalJob;
+    /** Last successful checkpoint proposed */ lastCheckpointProposed;
+    /** The last epoch for which we logged strategy comparison in fisherman mode. */ lastEpochForStrategyComparison;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
-    enforceTimeTable;
     // This shouldn't be here as this gets re-created each time we build/propose a block.
     // But we have a number of tests that abuse/rely on this class having a permanent publisher.
     // As long as those tests only configure a single publisher they will continue to work.
     // This will get re-assigned every time the sequencer goes to build a new block to a publisher that is valid
     // for the block proposer.
+    // TODO(palla/mbps): Remove this field and fix tests
     publisher;
-    constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, blockBuilder, l1Constants, dateProvider, epochCache, rollupContract, config, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
-        super(), this.publisherFactory = publisherFactory, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.enforceTimeTable = false;
+    /** Config for the sequencer */ config;
+    constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, checkpointsBuilder, l1Constants, dateProvider, epochCache, rollupContract, config, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
+        super(), this.publisherFactory = publisherFactory, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.checkpointsBuilder = checkpointsBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.telemetry = telemetry, this.log = log, this.state = SequencerState.STOPPED, this.config = DefaultSequencerConfig;
         // Add [FISHERMAN] prefix to logger if in fisherman mode
-        if (this.config.fishermanMode) {
+        if (config.fishermanMode) {
             this.log = log.createChild('[FISHERMAN]');
         }
         this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
-        // Initialize config
-        this.updateConfig(this.config);
-    }
-    get tracer() {
-        return this.metrics.tracer;
-    }
-    getValidatorAddresses() {
-        return this.validatorClient?.getValidatorAddresses();
+        this.updateConfig(config);
     }
-    getConfig() {
-        return this.config;
-    }
-    /**
-   * Updates sequencer config by the defined values in the config on input.
-   * @param config - New parameters.
-   */ updateConfig(config) {
-        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'txPublicSetupAllowList'));
-        if (config.transactionPollingIntervalMS !== undefined) {
-            this.pollingIntervalMs = config.transactionPollingIntervalMS;
-        }
-        if (config.maxTxsPerBlock !== undefined) {
-            this.maxTxsPerBlock = config.maxTxsPerBlock;
-        }
-        if (config.minTxsPerBlock !== undefined) {
-            this.minTxsPerBlock = config.minTxsPerBlock;
-        }
-        if (config.maxDABlockGas !== undefined) {
-            this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
-        }
-        if (config.maxL2BlockGas !== undefined) {
-            this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
-        }
-        if (config.maxBlockSizeInBytes !== undefined) {
-            this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
-        }
-        if (config.governanceProposerPayload) {
-            this.governanceProposerPayload = config.governanceProposerPayload;
-        }
-        if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
-            this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
-        }
-        if (config.enforceTimeTable !== undefined) {
-            this.enforceTimeTable = config.enforceTimeTable;
-        }
-        this.setTimeTable();
-        // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
-        // Update all values on this.config that are populated in the config object.
-        Object.assign(this.config, config);
-    }
-    setTimeTable() {
+    /** Updates sequencer config by the defined values and updates the timetable */ updateConfig(config) {
+        const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
+        this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowList'));
+        this.config = merge(this.config, filteredConfig);
         this.timetable = new SequencerTimetable({
             ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
             aztecSlotDuration: this.aztecSlotDuration,
-            maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
-            attestationPropagationTime: this.config.attestationPropagationTime,
-            enforce: this.enforceTimeTable
+            l1PublishingTime: this.l1PublishingTime,
+            p2pPropagationTime: this.config.attestationPropagationTime,
+            blockDurationMs: this.config.blockDurationMs,
+            enforce: this.config.enforceTimeTable
         }, this.metrics, this.log);
     }
-    async init() {
+    /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */ async init() {
+        getKzg();
         this.publisher = (await this.publisherFactory.create(undefined)).publisher;
     }
-    /**
-   * Starts the sequencer and moves to IDLE state.
-   */ start() {
-        this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.pollingIntervalMs);
+    /** Starts the sequencer and moves to IDLE state. */ start() {
+        this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.config.sequencerPollingIntervalMS);
         this.setState(SequencerState.IDLE, undefined, {
             force: true
         });
         this.runningPromise.start();
         this.log.info('Started sequencer');
     }
-    /**
-   * Stops the sequencer from processing txs and moves to STOPPED state.
-   */ async stop() {
+    /** Stops the sequencer from building blocks and moves to STOPPED state. */ async stop() {
         this.log.info(`Stopping sequencer`);
         this.setState(SequencerState.STOPPING, undefined, {
             force: true
@@ -171,29 +112,81 @@ export { SequencerState };
         });
         this.log.info('Stopped sequencer');
     }
-    /**
-   * Returns the current state of the sequencer.
-   * @returns An object with a state entry with one of SequencerState.
-   */ status() {
+    async safeWork() {
+        try {
+            await this.work();
+        } catch (err) {
+            this.emit('checkpoint-error', {
+                error: err
+            });
+            if (err instanceof SequencerTooSlowError) {
+                // TODO(palla/mbps): Add missing states
+                // Log as warn only if we had to abort halfway through the block proposal
+                const logLvl = [
+                    SequencerState.INITIALIZING_CHECKPOINT,
+                    SequencerState.PROPOSER_CHECK
+                ].includes(err.proposedState) ? 'debug' : 'warn';
+                this.log[logLvl](err.message, {
+                    now: this.dateProvider.nowInSeconds()
+                });
+            } else {
+                // Re-throw other errors
+                throw err;
+            }
+        } finally{
+            this.setState(SequencerState.IDLE, undefined);
+        }
+    }
+    /** Returns the current state of the sequencer. */ status() {
         return {
             state: this.state
         };
     }
     /**
-   * @notice  Performs most of the sequencer duties:
-   *          - Checks if we are up to date
-   *          - If we are and we are the sequencer, collect txs and build a block
-   *          - Collect attestations for the block
-   *          - Submit block
-   *          - If our block for some reason is not included, revert the state
+   * Main sequencer loop:
+   * - Checks if we are up to date
+   * - If we are and we are the sequencer, collect txs and build blocks
+   * - Build multiple blocks per slot when configured
+   * - Collect attestations for the final block
+   * - Submit checkpoint
    */ async work() {
         this.setState(SequencerState.SYNCHRONIZING, undefined);
-        const { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
-        // Check we have not already published a block for this slot (cheapest check)
-        if (this.lastBlockPublished && this.lastBlockPublished.header.getSlot() >= slot) {
-            this.log.debug(`Cannot propose block at next L2 slot ${slot} since that slot was taken by our own block ${this.lastBlockPublished.number}`);
+        const { slot, ts, now, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+        // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
+        const checkpointProposalJob = await this.prepareCheckpointProposal(slot, ts, now);
+        if (!checkpointProposalJob) {
             return;
         }
+        // Execute the checkpoint proposal job
+        const checkpoint = await checkpointProposalJob.execute();
+        // Update last checkpoint proposed (currently unused)
+        if (checkpoint) {
+            this.lastCheckpointProposed = checkpoint;
+        }
+        // Log fee strategy comparison if on fisherman
+        if (this.config.fishermanMode && (this.lastEpochForStrategyComparison === undefined || epoch > this.lastEpochForStrategyComparison)) {
+            this.logStrategyComparison(epoch, checkpointProposalJob.getPublisher());
+            this.lastEpochForStrategyComparison = epoch;
+        }
+        return checkpoint;
+    }
+    /**
+   * Prepares the checkpoint proposal by performing all necessary checks and setup.
+   * This is the initial step in the main loop.
+   * @returns CheckpointProposalJob if successful, undefined if we are not yet synced or are not the proposer.
+   */ async prepareCheckpointProposal(slot, ts, now) {
+        // Check we have not already processed this slot (cheapest check)
+        // We only check this if enforce timetable is set, since we want to keep processing the same slot if we are not
+        // running against actual time (eg when we use sandbox-style automining)
+        if (this.lastSlotForCheckpointProposalJob && this.lastSlotForCheckpointProposalJob >= slot && this.config.enforceTimeTable) {
+            this.log.trace(`Slot ${slot} has already been processed`);
+            return undefined;
+        }
+        // But if we have already proposed for this slot, the we definitely have to skip it, automining or not
+        if (this.lastCheckpointProposed && this.lastCheckpointProposed.header.slotNumber >= slot) {
+            this.log.trace(`Slot ${slot} has already been published as checkpoint ${this.lastCheckpointProposed.number}`);
+            return undefined;
+        }
         // Check all components are synced to latest as seen by the archiver (queries all subsystems)
         const syncedTo = await this.checkSync({
             ts,
@@ -204,18 +197,17 @@ export { SequencerState };
                 slot,
                 ts
             });
-            return;
+            return undefined;
         }
-        const chainTipArchive = syncedTo.archive;
-        const newBlockNumber = BlockNumber(syncedTo.blockNumber + 1);
-        const syncLogData = {
+        // TODO(palla/mbps): Compute proper checkpoint number
+        const checkpointNumber = CheckpointNumber.fromBlockNumber(BlockNumber(syncedTo.blockNumber + 1));
+        const logCtx = {
             now,
             syncedToL1Ts: syncedTo.l1Timestamp,
             syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
-            nextL2Slot: slot,
-            nextL2SlotTs: ts,
-            l1SlotDuration: this.l1Constants.ethereumSlotDuration,
-            newBlockNumber,
+            slot,
+            slotTs: ts,
+            checkpointNumber,
             isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex')
         };
         // Check that we are a proposer for the next slot
@@ -224,216 +216,88 @@ export { SequencerState };
         // If we are not a proposer check if we should invalidate a invalid block, and bail
         if (!canPropose) {
             await this.considerInvalidatingBlock(syncedTo, slot);
-            return;
-        }
-        // In fisherman mode, check if we've already validated this slot to prevent duplicate attempts
-        if (this.config.fishermanMode) {
-            if (this.lastSlotForValidationBlock === slot) {
-                this.log.trace(`Already validated block building for slot ${slot} (skipping)`, {
-                    slot
-                });
-                return;
-            }
-            this.log.debug(`Building validation block for slot ${slot} (actual proposer: ${proposer?.toString() ?? 'none'})`, {
-                slot,
-                proposer: proposer?.toString()
-            });
-            // Mark this slot as being validated
-            this.lastSlotForValidationBlock = slot;
+            return undefined;
         }
         // Check that the slot is not taken by a block already (should never happen, since only us can propose for this slot)
         if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
             this.log.warn(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
-                ...syncLogData,
+                ...logCtx,
                 block: syncedTo.block.header.toInspect()
             });
             this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
-            return;
+            return undefined;
         }
         // We now need to get ourselves a publisher.
         // The returned attestor will be the one we provided if we provided one.
         // Otherwise it will be a valid attestor for the returned publisher.
         // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
-        const { attestorAddress, publisher } = await this.publisherFactory.create(this.config.fishermanMode ? undefined : proposer);
+        const proposerForPublisher = this.config.fishermanMode ? undefined : proposer;
+        const { attestorAddress, publisher } = await this.publisherFactory.create(proposerForPublisher);
         this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
         this.publisher = publisher;
         // In fisherman mode, set the actual proposer's address for simulations
-        if (this.config.fishermanMode) {
-            if (proposer) {
-                publisher.setProposerAddressForSimulation(proposer);
-                this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
-            }
+        if (this.config.fishermanMode && proposer) {
+            publisher.setProposerAddressForSimulation(proposer);
+            this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
         }
-        // Get proposer credentials
-        const coinbase = this.validatorClient.getCoinbaseForAttestor(attestorAddress);
-        const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(attestorAddress);
         // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
+        // TODO(palla/mbps): We need to invalidate checkpoints, not blocks
         const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
-        // Check with the rollup if we can indeed propose at the next L2 slot. This check should not fail
+        // Check with the rollup contract if we can indeed propose at the next L2 slot. This check should not fail
         // if all the previous checks are good, but we do it just in case.
-        const canProposeCheck = await publisher.canProposeAtNextEthBlock(chainTipArchive, proposer ?? EthAddress.ZERO, invalidateBlock);
+        const canProposeCheck = await publisher.canProposeAtNextEthBlock(syncedTo.archive, proposer ?? EthAddress.ZERO, invalidateBlock);
         if (canProposeCheck === undefined) {
-            this.log.warn(`Cannot propose block ${newBlockNumber} at slot ${slot} due to failed rollup contract check`, syncLogData);
+            this.log.warn(`Cannot propose checkpoint ${checkpointNumber} at slot ${slot} due to failed rollup contract check`, logCtx);
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Rollup contract check failed'
+                reason: 'Rollup contract check failed',
+                slot
             });
             this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
-            return;
-        } else if (canProposeCheck.slot !== slot) {
+            return undefined;
+        }
+        if (canProposeCheck.slot !== slot) {
             this.log.warn(`Cannot propose block due to slot mismatch with rollup contract (this can be caused by a clock out of sync). Expected slot ${slot} but got ${canProposeCheck.slot}.`, {
-                ...syncLogData,
+                ...logCtx,
                 rollup: canProposeCheck,
-                newBlockNumber,
                 expectedSlot: slot
             });
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Slot mismatch'
+                reason: 'Slot mismatch',
+                slot
             });
             this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
-            return;
-        } else if (canProposeCheck.checkpointNumber !== CheckpointNumber.fromBlockNumber(newBlockNumber)) {
-            this.log.warn(`Cannot propose block due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected block ${newBlockNumber} but got ${canProposeCheck.checkpointNumber}.`, {
-                ...syncLogData,
+            return undefined;
+        }
+        if (canProposeCheck.checkpointNumber !== checkpointNumber) {
+            this.log.warn(`Cannot propose due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected checkpoint ${checkpointNumber} but got ${canProposeCheck.checkpointNumber}.`, {
+                ...logCtx,
                 rollup: canProposeCheck,
-                newBlockNumber,
                 expectedSlot: slot
             });
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Block mismatch'
+                reason: 'Block mismatch',
+                slot
             });
             this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
-            return;
-        }
-        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot} as ${proposer}`, {
-            ...syncLogData
-        });
-        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, coinbase, feeRecipient, slot);
-        // 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
-        const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, newGlobalVariables.timestamp);
-        // Enqueues block invalidation
-        if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-            publisher.enqueueInvalidateBlock(invalidateBlock);
-        }
-        // Actual block building
-        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-        this.metrics.incOpenSlot(slot, proposer?.toString() ?? 'unknown');
-        const block = await this.tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock);
-        // Wait until the voting promises have resolved, so all requests are enqueued
-        await Promise.all(votesPromises);
-        // In fisherman mode, we don't publish to L1
-        if (this.config.fishermanMode) {
-            // Clear pending requests
-            publisher.clearPendingRequests();
-            if (block) {
-                this.log.info(`Validation block building SUCCEEDED for slot ${slot}`, {
-                    blockNumber: newBlockNumber,
-                    slot: Number(slot),
-                    archive: block.archive.toString(),
-                    txCount: block.body.txEffects.length
-                });
-                this.lastBlockPublished = block;
-                this.metrics.recordBlockProposalSuccess();
-            } else {
-                // Block building failed in fisherman mode
-                this.log.warn(`Validation block building FAILED for slot ${slot}`, {
-                    blockNumber: newBlockNumber,
-                    slot: Number(slot)
-                });
-                this.metrics.recordBlockProposalFailed('block_build_failed');
-            }
-        } else {
-            // Normal mode: send the tx to L1
-            const l1Response = await publisher.sendRequests();
-            const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
-            if (proposedBlock) {
-                this.lastBlockPublished = block;
-                this.emit('block-published', {
-                    blockNumber: newBlockNumber,
-                    slot: Number(slot)
-                });
-                await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
-            } else if (block) {
-                this.emit('block-publish-failed', l1Response ?? {});
-            }
+            return undefined;
         }
-        this.setState(SequencerState.IDLE, undefined);
-    }
-    /** Tries building a block proposal, and if successful, enqueues it for publishing. */ async tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock) {
-        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-            proposer,
-            publisher: publisher.getSenderAddress(),
-            globalVariables: newGlobalVariables.toInspect(),
-            chainTipArchive,
-            blockNumber: newBlockNumber,
-            slot
-        });
-        const proposalHeader = CheckpointHeader.from({
-            ...newGlobalVariables,
-            timestamp: newGlobalVariables.timestamp,
-            lastArchiveRoot: chainTipArchive,
-            blockHeadersHash: Fr.ZERO,
-            contentCommitment: ContentCommitment.empty(),
-            totalManaUsed: Fr.ZERO
+        this.lastSlotForCheckpointProposalJob = slot;
+        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} at slot ${slot}`, {
+            ...logCtx,
+            proposer
         });
-        let block;
-        const pendingTxCount = await this.p2pClient.getPendingTxCount();
-        if (pendingTxCount >= this.minTxsPerBlock) {
-            // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
-            // and also we may need to fetch more if we don't have enough valid txs.
-            const pendingTxs = this.p2pClient.iteratePendingTxs();
-            try {
-                block = await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposer, invalidateBlock, publisher);
-            } catch (err) {
-                this.emit('block-build-failed', {
-                    reason: err.message
-                });
-                if (err instanceof FormattedViemError) {
-                    this.log.verbose(`Unable to build/enqueue block ${err.message}`);
-                } else {
-                    this.log.error(`Error building/enqueuing block`, err, {
-                        blockNumber: newBlockNumber,
-                        slot
-                    });
-                }
-                this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
-            }
-        } else {
-            this.log.verbose(`Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`, {
-                chainTipArchive,
-                blockNumber: newBlockNumber,
-                slot
-            });
-            this.emit('tx-count-check-failed', {
-                minTxs: this.minTxsPerBlock,
-                availableTxs: pendingTxCount
-            });
-            this.metrics.recordBlockProposalFailed('insufficient_txs');
-        }
-        return block;
+        // Create and return the checkpoint proposal job
+        return this.createCheckpointProposalJob(slot, checkpointNumber, syncedTo.blockNumber, proposer, publisher, attestorAddress, invalidateBlock);
     }
-    async safeWork() {
-        try {
-            await this.work();
-        } catch (err) {
-            if (err instanceof SequencerTooSlowError) {
-                // Log as warn only if we had to abort halfway through the block proposal
-                const logLvl = [
-                    SequencerState.INITIALIZING_PROPOSAL,
-                    SequencerState.PROPOSER_CHECK
-                ].includes(err.proposedState) ? 'debug' : 'warn';
-                this.log[logLvl](err.message, {
-                    now: this.dateProvider.nowInSeconds()
-                });
-            } else {
-                // Re-throw other errors
-                throw err;
-            }
-        } finally{
-            this.setState(SequencerState.IDLE, undefined);
-        }
+    createCheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateBlock) {
+        return new CheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateBlock, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.checkpointsBuilder, this.l1Constants, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this, this.setState.bind(this), this.log);
     }
-    setState(proposedState, slotNumber, opts = {}) {
+    /**
+   * Internal helper for setting the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+   * @param proposedState - The new state to transition to.
+   * @param slotNumber - The current slot number.
+   * @param force - Whether to force the transition even if the sequencer is stopped.
+   */ setState(proposedState, slotNumber, opts = {}) {
         if (this.state === SequencerState.STOPPING && proposedState !== SequencerState.STOPPED && !opts.force) {
             this.log.warn(`Cannot set sequencer to ${proposedState} as it is stopping.`);
             throw new SequencerInterruptedError();
@@ -460,220 +324,10 @@ export { SequencerState };
             oldState: this.state,
             newState: proposedState,
             secondsIntoSlot,
-            slotNumber
+            slot: slotNumber
         });
         this.state = proposedState;
     }
-    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);
-    }
-    getBlockBuilderOptions(slot) {
-        // Deadline for processing depends on whether we're proposing a block
-        const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-        const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
-        // Deadline is only set if enforceTimeTable is enabled.
-        const deadline = this.enforceTimeTable ? new Date((this.getSlotStartBuildTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
-        return {
-            maxTransactions: this.maxTxsPerBlock,
-            maxBlockSize: this.maxBlockSizeInBytes,
-            maxBlockGas: this.maxBlockGas,
-            maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
-            deadline
-        };
-    }
-    /**
-   * @notice  Build and propose a block to the chain
-   *
-   * @dev     MUST throw instead of exiting early to ensure that world-state
-   *          is being rolled back if the block is dropped.
-   *
-   * @param pendingTxs - Iterable of pending transactions to construct the block from
-   * @param proposalHeader - The partial header constructed for the proposal
-   * @param newGlobalVariables - The global variables for the new block
-   * @param proposerAddress - The address of the proposer
-   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerAddress, invalidateBlock, publisher) {
-        await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
-        const blockNumber = newGlobalVariables.blockNumber;
-        const slot = proposalHeader.slotNumber;
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-        const workTimer = new Timer();
-        this.setState(SequencerState.CREATING_BLOCK, slot);
-        try {
-            const blockBuilderOptions = this.getBlockBuilderOptions(slot);
-            const buildBlockRes = await this.blockBuilder.buildBlock(pendingTxs, l1ToL2Messages, newGlobalVariables, blockBuilderOptions);
-            const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs, failedTxs } = buildBlockRes;
-            const blockBuildDuration = workTimer.ms();
-            await this.dropFailedTxsFromP2P(failedTxs);
-            const minTxsPerBlock = this.minTxsPerBlock;
-            if (numTxs < minTxsPerBlock) {
-                this.log.warn(`Block ${blockNumber} has too few txs to be proposed (got ${numTxs} but required ${minTxsPerBlock})`, {
-                    slot,
-                    blockNumber,
-                    numTxs
-                });
-                throw new Error(`Block has too few successful txs to be proposed`);
-            }
-            // TODO(@PhilWindle) We should probably periodically check for things like another
-            // block being published before ours instead of just waiting on our block
-            await publisher.validateBlockHeader(block.getCheckpointHeader(), invalidateBlock);
-            const blockStats = {
-                eventName: 'l2-block-built',
-                creator: proposerAddress?.toString() ?? publisher.getSenderAddress().toString(),
-                duration: workTimer.ms(),
-                publicProcessDuration: publicProcessorDuration,
-                rollupCircuitsDuration: blockBuildingTimer.ms(),
-                ...block.getStats()
-            };
-            const blockHash = await block.hash();
-            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
-            this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs and ${numMsgs} messages. ${publicGas.l2Gas / workTimer.s()} mana/s`, {
-                blockHash,
-                globalVariables: block.header.globalVariables.toInspect(),
-                txHashes,
-                ...blockStats
-            });
-            // In fisherman mode, skip attestation collection
-            let attestationsAndSigners;
-            if (this.config.fishermanMode) {
-                this.log.debug('Skipping attestation collection');
-                attestationsAndSigners = CommitteeAttestationsAndSigners.empty();
-            } else {
-                this.log.debug('Collecting attestations');
-                attestationsAndSigners = await this.collectAttestations(block, usedTxs, proposerAddress);
-                this.log.verbose(`Collected ${attestationsAndSigners.attestations.length} attestations for block ${blockNumber} at slot ${slot}`, {
-                    blockHash,
-                    blockNumber,
-                    slot
-                });
-            }
-            // In fisherman mode, skip attestation signing
-            const attestationsAndSignersSignature = this.config.fishermanMode || !this.validatorClient ? Signature.empty() : await this.validatorClient.signAttestationsAndSigners(attestationsAndSigners, proposerAddress ?? publisher.getSenderAddress());
-            await this.enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher);
-            this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
-            return block;
-        } catch (err) {
-            this.metrics.recordFailedBlock();
-            throw err;
-        }
-    }
-    async collectAttestations(block, txs, proposerAddress) {
-        const { committee, seed, epoch } = await this.epochCache.getCommittee(block.slot);
-        // We checked above that the committee is defined, so this should never happen.
-        if (!committee) {
-            throw new Error('No committee when collecting attestations');
-        }
-        if (committee.length === 0) {
-            this.log.verbose(`Attesting committee is empty`);
-            return CommitteeAttestationsAndSigners.empty();
-        } else {
-            this.log.debug(`Attesting committee length is ${committee.length}`);
-        }
-        if (!this.validatorClient) {
-            throw new Error('Missing validator client: Cannot collect attestations');
-        }
-        const numberOfRequiredAttestations = Math.floor(committee.length * 2 / 3) + 1;
-        const slotNumber = block.header.globalVariables.slotNumber;
-        this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
-        this.log.debug('Creating block proposal for validators');
-        const blockProposalOptions = {
-            publishFullTxs: !!this.config.publishTxsWithProposals,
-            broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
-        };
-        const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, block.getCheckpointHeader(), block.archive.root, txs, proposerAddress, blockProposalOptions);
-        if (!proposal) {
-            throw new Error(`Failed to create block proposal`);
-        }
-        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));
-        }
-        this.log.debug('Broadcasting block proposal to validators');
-        await this.validatorClient.broadcastBlockProposal(proposal);
-        const attestationTimeAllowed = this.enforceTimeTable ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK) : this.aztecSlotDuration;
-        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
-        const timer = new Timer();
-        let collectedAttestationsCount = 0;
-        try {
-            const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
-            const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
-            collectedAttestationsCount = attestations.length;
-            // note: the smart 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) {
-                return this.manipulateAttestations(block, 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, timer.ms());
-        }
-    }
-    /** Breaks the attestations before publishing based on attack configs */ manipulateAttestations(block, 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 proposerIndex = Number(this.epochCache.computeProposerIndex(block.slot, 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 block ${block.number} at index ${targetIndex}`);
-                unfreeze(attestations[targetIndex]).signature = Signature.random();
-            }
-            return new CommitteeAttestationsAndSigners(attestations);
-        }
-        if (this.config.shuffleAttestationOrdering) {
-            this.log.warn(`Shuffling attestation ordering in block ${block.number} (proposer index ${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);
-    }
-    /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber);
-        // Time out tx at the end of the slot
-        const slot = block.header.globalVariables.slotNumber;
-        const txTimeoutAt = new Date((this.getSlotStartBuildTimestamp(slot) + this.aztecSlotDuration) * 1000);
-        const enqueued = await publisher.enqueueProposeL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, {
-            txTimeoutAt,
-            forcePendingBlockNumber: invalidateBlock?.forcePendingBlockNumber
-        });
-        if (!enqueued) {
-            throw new Error(`Failed to enqueue publish of block ${block.number}`);
-        }
-    }
     /**
    * Returns whether all dependencies have caught up.
    * We don't check against the previous block submitted since it may have been reorg'd out.
@@ -725,7 +379,7 @@ export { SequencerState };
                 pendingChainValidationStatus
             };
         }
-        const block = await this.l2BlockSource.getBlock(blockNumber);
+        const block = await this.l2BlockSource.getL2BlockNew(blockNumber);
         if (!block) {
             // this shouldn't really happen because a moment ago we checked that all components were in sync
             this.log.error(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`);
@@ -740,52 +394,6 @@ export { SequencerState };
         };
     }
     /**
-   * Enqueues governance and slashing votes with the publisher. Does not block.
-   * @param publisher - The publisher to enqueue votes with
-   * @param attestorAddress - The attestor address to use for signing
-   * @param slot - The slot number
-   * @param timestamp - The timestamp for the votes
-   * @param context - Optional context for logging (e.g., block number)
-   * @returns A tuple of [governanceEnqueued, slashingEnqueued]
-   */ enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, timestamp) {
-        try {
-            const signerFn = (msg)=>this.validatorClient.signWithAddress(attestorAddress, msg).then((s)=>s.toString());
-            const enqueueGovernancePromise = this.governanceProposerPayload && !this.governanceProposerPayload.isZero() ? publisher.enqueueGovernanceCastSignal(this.governanceProposerPayload, slot, timestamp, attestorAddress, signerFn).catch((err)=>{
-                this.log.error(`Error enqueuing governance vote`, err, {
-                    slot
-                });
-                return false;
-            }) : undefined;
-            const enqueueSlashingPromise = this.slasherClient ? this.slasherClient.getProposerActions(slot).then((actions)=>{
-                // Record metrics for fisherman mode
-                if (this.config.fishermanMode && actions.length > 0) {
-                    this.log.debug(`Fisherman mode: simulating ${actions.length} slashing action(s) for slot ${slot}`, {
-                        slot,
-                        actionCount: actions.length
-                    });
-                    this.metrics.recordSlashingAttempt(actions.length);
-                }
-                // Enqueue the actions to fully simulate L1 tx building (they won't be sent in fisherman mode)
-                return publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn);
-            }).catch((err)=>{
-                this.log.error(`Error enqueuing slashing actions`, err, {
-                    slot
-                });
-                return false;
-            }) : undefined;
-            return [
-                enqueueGovernancePromise,
-                enqueueSlashingPromise
-            ];
-        } catch (err) {
-            this.log.error(`Error enqueueing governance and slashing votes`, err);
-            return [
-                undefined,
-                undefined
-            ];
-        }
-    }
-    /**
    * Checks if we are the proposer for the next slot.
    * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
    */ async checkCanPropose(slot) {
@@ -841,32 +449,32 @@ export { SequencerState };
    * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
    * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
    */ async tryVoteWhenSyncFails(args) {
-        const { slot, ts } = args;
+        const { slot } = args;
         // Prevent duplicate attempts in the same slot
         if (this.lastSlotForVoteWhenSyncFailed === slot) {
-            this.log.debug(`Already attempted to vote in slot ${slot} (skipping)`);
+            this.log.trace(`Already attempted to vote in slot ${slot} (skipping)`);
             return;
         }
         // Check if we're past the max time for initializing a proposal
         const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-        const maxAllowedTime = this.timetable.getMaxAllowedTime(SequencerState.INITIALIZING_PROPOSAL);
+        const maxAllowedTime = this.timetable.getMaxAllowedTime(SequencerState.INITIALIZING_CHECKPOINT);
         // If we haven't exceeded the time limit for initializing a proposal, don't proceed with voting
         // We use INITIALIZING_PROPOSAL time limit because if we're past that, we can't build a block anyway
         if (maxAllowedTime === undefined || secondsIntoSlot <= maxAllowedTime) {
-            this.log.trace(`Not attempting to vote since there is still for block building`, {
+            this.log.trace(`Not attempting to vote since there is still time for block building`, {
                 secondsIntoSlot,
                 maxAllowedTime
             });
             return;
         }
-        this.log.debug(`Sync for slot ${slot} failed, checking for voting opportunities`, {
+        this.log.trace(`Sync for slot ${slot} failed, checking for voting opportunities`, {
             secondsIntoSlot,
             maxAllowedTime
         });
         // Check if we're a proposer or proposal is open
         const [canPropose, proposer] = await this.checkCanPropose(slot);
         if (!canPropose) {
-            this.log.debug(`Cannot vote in slot ${slot} since we are not a proposer`, {
+            this.log.trace(`Cannot vote in slot ${slot} since we are not a proposer`, {
                 slot,
                 proposer
             });
@@ -880,10 +488,11 @@ export { SequencerState };
             attestorAddress,
             slot
         });
-        // Enqueue governance and slashing votes using the shared helper method
-        const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, ts);
-        await Promise.all(votesPromises);
-        if (votesPromises.every((p)=>!p)) {
+        // Enqueue governance and slashing votes
+        const voter = new CheckpointVoter(slot, publisher, attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log);
+        const votesPromises = voter.enqueueVotes();
+        const votes = await Promise.all(votesPromises);
+        if (votes.every((p)=>!p)) {
             this.log.debug(`No votes to enqueue for slot ${slot}`);
             return;
         }
@@ -902,7 +511,6 @@ export { SequencerState };
         if (pendingChainValidationStatus.valid) {
             return;
         }
-        const { publisher } = await this.publisherFactory.create(undefined);
         const invalidBlockNumber = pendingChainValidationStatus.block.blockNumber;
         const invalidBlockTimestamp = pendingChainValidationStatus.block.timestamp;
         const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidBlockTimestamp);
@@ -924,6 +532,21 @@ export { SequencerState };
             this.log.debug(`Not invalidating pending chain`, logData);
             return;
         }
+        let validatorToUse;
+        if (invalidateAsCommitteeMember) {
+            // When invalidating as a committee member, use first validator that's actually in the committee
+            const { committee } = await this.epochCache.getCommittee(currentSlot);
+            if (committee) {
+                const committeeSet = new Set(committee.map((addr)=>addr.toString()));
+                validatorToUse = ourValidatorAddresses.find((addr)=>committeeSet.has(addr.toString())) ?? ourValidatorAddresses[0];
+            } else {
+                validatorToUse = ourValidatorAddresses[0];
+            }
+        } else {
+            // When invalidating as a non-committee member, use the first validator
+            validatorToUse = ourValidatorAddresses[0];
+        }
+        const { publisher } = await this.publisherFactory.create(validatorToUse);
         const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
         if (!invalidateBlock) {
             this.log.warn(`Failed to simulate invalidate block`, logData);
@@ -938,6 +561,32 @@ export { SequencerState };
             publisher.clearPendingRequests();
         }
     }
+    logStrategyComparison(epoch, publisher) {
+        const feeAnalyzer = publisher.getL1FeeAnalyzer();
+        if (!feeAnalyzer) {
+            return;
+        }
+        const comparison = feeAnalyzer.getStrategyComparison();
+        if (comparison.length === 0) {
+            this.log.debug(`No strategy data available yet for epoch ${epoch}`);
+            return;
+        }
+        this.log.info(`L1 Fee Strategy Performance Report - End of Epoch ${epoch}`, {
+            epoch: Number(epoch),
+            totalAnalyses: comparison[0]?.totalAnalyses,
+            strategies: comparison.map((s)=>({
+                    id: s.strategyId,
+                    name: s.strategyName,
+                    inclusionRate: `${(s.inclusionRate * 100).toFixed(1)}%`,
+                    inclusionCount: `${s.inclusionCount}/${s.totalAnalyses}`,
+                    avgCostEth: s.avgEstimatedCostEth.toFixed(6),
+                    totalCostEth: s.totalEstimatedCostEth.toFixed(6),
+                    avgOverpaymentEth: s.avgOverpaymentEth.toFixed(6),
+                    totalOverpaymentEth: s.totalOverpaymentEth.toFixed(6),
+                    avgPriorityFeeDeltaGwei: s.avgPriorityFeeDeltaGwei.toFixed(2)
+                }))
+        });
+    }
     getSlotStartBuildTimestamp(slotNumber) {
         return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
     }
@@ -954,24 +603,19 @@ export { SequencerState };
     getSlasherClient() {
         return this.slasherClient;
     }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    getValidatorAddresses() {
+        return this.validatorClient?.getValidatorAddresses();
+    }
+    getConfig() {
+        return this.config;
+    }
+    get l1PublishingTime() {
+        return this.config.l1PublishingTime ?? this.l1Constants.ethereumSlotDuration;
+    }
 }
 _ts_decorate([
     trackSpan('Sequencer.work')
 ], Sequencer.prototype, "safeWork", null);
-_ts_decorate([
-    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, _proposalHeader, newGlobalVariables)=>({
-            [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber
-        }))
-], Sequencer.prototype, "buildBlockAndEnqueuePublish", null);
-_ts_decorate([
-    trackSpan('Sequencer.collectAttestations', (block, txHashes)=>({
-            [Attributes.BLOCK_NUMBER]: block.number,
-            [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
-            [Attributes.BLOCK_TXS_COUNT]: txHashes.length
-        }))
-], Sequencer.prototype, "collectAttestations", null);
-_ts_decorate([
-    trackSpan('Sequencer.enqueuePublishL2Block', (block)=>({
-            [Attributes.BLOCK_NUMBER]: block.number
-        }))
-], Sequencer.prototype, "enqueuePublishL2Block", null);