@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/sequencer/sequencer.ts

@@ -1,497 +1,470 @@
-import { L2Block } from '@aztec/aztec.js/block';
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { getKzg } from '@aztec/blob-lib';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { FormattedViemError, NoCommitteeError, type RollupContract } from '@aztec/ethereum';
-import { omit, pick } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
+import { NoCommitteeError, type RollupContract } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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 { type DateProvider, Timer } from '@aztec/foundation/timer';
-import { type TypedEventEmitter, unfreeze } from '@aztec/foundation/types';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
+import type { BlockData, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import {
-  CommitteeAttestation,
-  CommitteeAttestationsAndSigners,
-  type L2BlockSource,
-  type ValidateBlockResult,
-} from '@aztec/stdlib/block';
-import { type L1RollupConstants, getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
-import {
-  type IFullNodeBlockBuilder,
-  type PublicProcessorLimits,
+  type ResolvedSequencerConfig,
+  type SequencerConfig,
   SequencerConfigSchema,
   type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { BlockProposalOptions } from '@aztec/stdlib/p2p';
-import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
-import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment, type FailedTx, GlobalVariables, Tx } from '@aztec/stdlib/tx';
-import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import type { ValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
 import EventEmitter from 'node:events';
-import type { TypedDataDefinition } from 'viem';
 
+import { DefaultSequencerConfig } from '../config.js';
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
-import type { Action, InvalidateBlockRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
-import type { SequencerConfig } from './config.js';
+import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
+import type { SequencerEvents } from './events.js';
 import { SequencerMetrics } from './metrics.js';
 import { SequencerTimetable } from './timetable.js';
-import { SequencerState, type SequencerStateWithSlot } from './utils.js';
+import type { SequencerRollupConstants } from './types.js';
+import { SequencerState } from './utils.js';
 
 export { SequencerState };
 
-type SequencerRollupConstants = Pick<L1RollupConstants, 'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'>;
-
-export type SequencerEvents = {
-  ['state-changed']: (args: {
-    oldState: SequencerState;
-    newState: SequencerState;
-    secondsIntoSlot?: number;
-    slotNumber?: bigint;
-  }) => void;
-  ['proposer-rollup-check-failed']: (args: { reason: string }) => void;
-  ['tx-count-check-failed']: (args: { minTxs: number; availableTxs: number }) => void;
-  ['block-build-failed']: (args: { reason: string }) => void;
-  ['block-publish-failed']: (args: {
-    successfulActions?: Action[];
-    failedActions?: Action[];
-    sentActions?: Action[];
-    expiredActions?: Action[];
-  }) => void;
-  ['block-published']: (args: { blockNumber: number; slot: number }) => void;
-};
-
 /**
  * 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 as new () => TypedEventEmitter<SequencerEvents>) {
   private runningPromise?: RunningPromise;
-  private pollingIntervalMs: number = 1000;
-  private maxTxsPerBlock = 32;
-  private minTxsPerBlock = 1;
-  private maxL1TxInclusionTimeIntoSlot = 0;
   private state = SequencerState.STOPPED;
-  private maxBlockSizeInBytes: number = 1024 * 1024;
-  private maxBlockGas: Gas = new Gas(100e9, 100e9);
   private metrics: SequencerMetrics;
 
-  private lastBlockPublished: L2Block | undefined;
+  /** The last slot for which we attempted to perform our voting duties with degraded block production */
+  private lastSlotForFallbackVote: SlotNumber | undefined;
+
+  /** The last slot for which we logged "no committee" warning, to avoid spam */
+  private lastSlotForNoCommitteeWarning: SlotNumber | undefined;
+
+  /** The last slot for which we triggered a checkpoint proposal job, to prevent duplicate attempts. */
+  private lastSlotForCheckpointProposalJob: SlotNumber | undefined;
 
-  private governanceProposerPayload: EthAddress | undefined;
+  /** Last successful checkpoint proposed */
+  private lastCheckpointProposed: Checkpoint | undefined;
 
-  /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */
-  private lastSlotForVoteWhenSyncFailed: bigint | undefined;
+  /** The last epoch for which we logged strategy comparison in fisherman mode. */
+  private lastEpochForStrategyComparison: EpochNumber | undefined;
 
   /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
   protected timetable!: SequencerTimetable;
-  protected enforceTimeTable: boolean = false;
 
-  // 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.
-  protected publisher: SequencerPublisher | undefined;
+  /** Config for the sequencer */
+  protected config: ResolvedSequencerConfig = DefaultSequencerConfig;
 
   constructor(
     protected publisherFactory: SequencerPublisherFactory,
-    protected validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
+    protected validatorClient: ValidatorClient,
     protected globalsBuilder: GlobalVariableBuilder,
     protected p2pClient: P2P,
     protected worldState: WorldStateSynchronizer,
     protected slasherClient: SlasherClientInterface | undefined,
-    protected l2BlockSource: L2BlockSource,
+    protected l2BlockSource: L2BlockSource & L2BlockSink,
     protected l1ToL2MessageSource: L1ToL2MessageSource,
-    protected blockBuilder: IFullNodeBlockBuilder,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
     protected l1Constants: SequencerRollupConstants,
     protected dateProvider: DateProvider,
     protected epochCache: EpochCache,
     protected rollupContract: RollupContract,
-    protected config: SequencerConfig,
+    config: SequencerConfig,
     protected telemetry: TelemetryClient = getTelemetryClient(),
     protected log = createLogger('sequencer'),
   ) {
     super();
 
-    this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
-    // Initialize config
-    this.updateConfig(this.config);
-  }
-
-  get tracer(): Tracer {
-    return this.metrics.tracer;
-  }
-
-  public getValidatorAddresses() {
-    return this.validatorClient?.getValidatorAddresses();
-  }
-
-  public getConfig() {
-    return this.config;
-  }
-
-  /**
-   * Updates sequencer config by the defined values in the config on input.
-   * @param config - New parameters.
-   */
-  public updateConfig(config: SequencerConfig) {
-    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;
+    // Add [FISHERMAN] prefix to logger if in fisherman mode
+    if (config.fishermanMode) {
+      this.log = log.createChild('[FISHERMAN]');
     }
-    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);
+    this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+    this.updateConfig(config);
   }
 
-  private setTimeTable() {
+  /** Updates sequencer config by the defined values and updates the timetable */
+  public updateConfig(config: Partial<SequencerConfig>) {
+    const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
+    this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowListExtend'));
+    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,
     );
   }
 
-  public async init() {
-    this.publisher = (await this.publisherFactory.create(undefined)).publisher;
+  /** Initializes the sequencer (precomputes tables). Takes about 3s. */
+  public init() {
+    getKzg();
   }
 
-  /**
-   * Starts the sequencer and moves to IDLE state.
-   */
+  /** Starts the sequencer and moves to IDLE state. */
   public start() {
-    this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.pollingIntervalMs);
+    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.
-   */
+  /** Stops the sequencer from building blocks and moves to STOPPED state. */
   public async stop(): Promise<void> {
     this.log.info(`Stopping sequencer`);
     this.setState(SequencerState.STOPPING, undefined, { force: true });
-    this.publisher?.interrupt();
+    this.publisherFactory.interruptAll();
     await this.runningPromise?.stop();
     this.setState(SequencerState.STOPPED, undefined, { force: true });
     this.log.info('Stopped sequencer');
   }
 
-  /**
-   * Returns the current state of the sequencer.
-   * @returns An object with a state entry with one of SequencerState.
-   */
+  /** Main sequencer loop with a try/catch */
+  protected async safeWork() {
+    try {
+      await this.work();
+    } catch (err) {
+      this.emit('checkpoint-error', { error: err as Error });
+      if (err instanceof SequencerTooSlowError) {
+        // 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' as const)
+          : ('warn' as const);
+        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. */
   public 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
    */
+  @trackSpan('Sequencer.work')
   protected async work() {
     this.setState(SequencerState.SYNCHRONIZING, undefined);
-    const { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
+    const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+    const { slot: targetSlot, epoch: targetEpoch } = this.epochCache.getTargetEpochAndSlotInNextL1Slot();
 
-    // 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}`,
-      );
+    // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
+    const checkpointProposalJob = await this.prepareCheckpointProposal(
+      slot,
+      targetSlot,
+      epoch,
+      targetEpoch,
+      ts,
+      nowSeconds,
+    );
+    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 (uses target epoch since we mirror the proposer's perspective)
+    if (
+      this.config.fishermanMode &&
+      (this.lastEpochForStrategyComparison === undefined || targetEpoch > this.lastEpochForStrategyComparison)
+    ) {
+      this.logStrategyComparison(targetEpoch, checkpointProposalJob.getPublisher());
+      this.lastEpochForStrategyComparison = targetEpoch;
+    }
+
+    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.
+   */
+  @trackSpan('Sequencer.prepareCheckpointProposal')
+  private async prepareCheckpointProposal(
+    slot: SlotNumber,
+    targetSlot: SlotNumber,
+    epoch: EpochNumber,
+    targetEpoch: EpochNumber,
+    ts: bigint,
+    nowSeconds: bigint,
+  ): Promise<CheckpointProposalJob | undefined> {
+    // Check we have not already processed this target 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 >= targetSlot &&
+      this.config.enforceTimeTable
+    ) {
+      this.log.trace(`Target slot ${targetSlot} has already been processed`);
+      return undefined;
+    }
+
+    // But if we have already proposed for this slot, then we definitely have to skip it, automining or not
+    if (this.lastCheckpointProposed && this.lastCheckpointProposed.header.slotNumber >= targetSlot) {
+      this.log.trace(
+        `Slot ${targetSlot} 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, slot });
     if (!syncedTo) {
-      await this.tryVoteWhenSyncFails({ slot, ts });
-      return;
+      await this.tryVoteWhenSyncFails({ slot, targetSlot, ts });
+      return undefined;
+    }
+
+    // If escape hatch is open for the target epoch, do not start checkpoint proposal work and do not attempt invalidations.
+    // Still perform governance/slashing voting (as proposer) once per slot.
+    // When pipelining, we check the target epoch (slot+1's epoch) since that's the epoch we're building for.
+    const isEscapeHatchOpen = await this.epochCache.isEscapeHatchOpen(targetEpoch);
+
+    if (isEscapeHatchOpen) {
+      this.setState(SequencerState.PROPOSER_CHECK, slot);
+      const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
+      if (canPropose) {
+        await this.tryVoteWhenEscapeHatchOpen({ slot, proposer });
+      } else {
+        this.log.trace(`Escape hatch open but we are not proposer, skipping vote-only actions`, {
+          slot,
+          epoch,
+          proposer,
+        });
+      }
+      return undefined;
     }
 
-    const chainTipArchive = syncedTo.archive;
-    const newBlockNumber = syncedTo.blockNumber + 1;
-
-    const syncLogData = {
-      now,
-      syncedToL1Ts: syncedTo.l1Timestamp,
-      syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
-      nextL2Slot: slot,
-      nextL2SlotTs: ts,
-      l1SlotDuration: this.l1Constants.ethereumSlotDuration,
-      newBlockNumber,
+    // Next checkpoint follows from the last synced one
+    const checkpointNumber = CheckpointNumber(syncedTo.checkpointNumber + 1);
+
+    const logCtx = {
+      nowSeconds,
+      syncedToL2Slot: syncedTo.syncedL2Slot,
+      slot,
+      targetSlot,
+      slotTs: ts,
+      checkpointNumber,
       isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex'),
     };
 
-    // Check that we are a proposer for the next slot
+    // Check that we are a proposer for the target slot.
     this.setState(SequencerState.PROPOSER_CHECK, slot);
-    const [canPropose, proposer] = await this.checkCanPropose(slot);
+    const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
 
-    // If we are not a proposer, check if we should invalidate a invalid block, and bail
+    // If we are not a proposer check if we should invalidate an invalid checkpoint, and bail
     if (!canPropose) {
-      await this.considerInvalidatingBlock(syncedTo, slot);
-      return;
+      await this.considerInvalidatingCheckpoint(syncedTo, 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) {
+    // Check that the target slot is not taken by a block already (should never happen, since only us can propose for this slot)
+    if (syncedTo.blockData && syncedTo.blockData.header.getSlot() >= targetSlot) {
       this.log.warn(
-        `Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`,
-        { ...syncLogData, block: syncedTo.block.header.toInspect() },
+        `Cannot propose block at target slot ${targetSlot} since that slot was taken by block ${syncedTo.blockNumber}`,
+        { ...logCtx, block: syncedTo.blockData.header.toInspect() },
       );
-      return;
+      this.metrics.recordCheckpointPrecheckFailed('slot_already_taken');
+      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.
-    const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+    // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
+    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;
 
-    const coinbase = this.validatorClient!.getCoinbaseForAttestor(attestorAddress);
-    const feeRecipient = this.validatorClient!.getFeeRecipientForAttestor(attestorAddress);
+    // In fisherman mode, set the actual proposer's address for simulations
+    if (this.config.fishermanMode && proposer) {
+      publisher.setProposerAddressForSimulation(proposer);
+      this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
+    }
 
     // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
-    const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
+    const invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(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 target 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.canProposeAt(syncedTo.archive, proposer ?? EthAddress.ZERO, {
+      ...invalidateCheckpoint,
+    });
 
     if (canProposeCheck === undefined) {
       this.log.warn(
-        `Cannot propose block ${newBlockNumber} at slot ${slot} due to failed rollup contract check`,
-        syncLogData,
+        `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' });
-      return;
-    } else if (canProposeCheck.slot !== slot) {
+      this.emit('proposer-rollup-check-failed', { reason: 'Rollup contract check failed', slot });
+      this.metrics.recordCheckpointPrecheckFailed('rollup_contract_check_failed');
+      return undefined;
+    }
+
+    if (canProposeCheck.slot !== targetSlot) {
       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, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
+        `Cannot propose block due to slot mismatch with rollup contract (this can be caused by a clock out of sync). Expected slot ${targetSlot} but got ${canProposeCheck.slot}.`,
+        { ...logCtx, rollup: canProposeCheck, expectedSlot: targetSlot },
       );
-      this.emit('proposer-rollup-check-failed', { reason: 'Slot mismatch' });
-      return;
-    } else if (canProposeCheck.blockNumber !== BigInt(newBlockNumber)) {
+      this.emit('proposer-rollup-check-failed', { reason: 'Slot mismatch', slot });
+      this.metrics.recordCheckpointPrecheckFailed('slot_mismatch');
+      return undefined;
+    }
+
+    if (canProposeCheck.checkpointNumber !== checkpointNumber) {
       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.blockNumber}.`,
-        { ...syncLogData, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
+        `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, expectedSlot: slot },
       );
-      this.emit('proposer-rollup-check-failed', { reason: 'Block mismatch' });
-      return;
+      this.emit('proposer-rollup-check-failed', { reason: 'Block mismatch', slot });
+      this.metrics.recordCheckpointPrecheckFailed('block_number_mismatch');
+      return undefined;
     }
 
-    this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot} as ${proposer}`, { ...syncLogData });
+    this.lastSlotForCheckpointProposalJob = targetSlot;
 
-    const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
-      newBlockNumber,
-      coinbase,
-      feeRecipient,
-      slot,
-    );
-
-    // Enqueue governance and slashing votes (returns promises that will be awaited later)
-    const votesPromises = this.enqueueGovernanceAndSlashingVotes(
-      publisher,
-      attestorAddress,
-      slot,
-      newGlobalVariables.timestamp,
+    await this.p2pClient.prepareForSlot(targetSlot);
+    this.log.info(
+      `Preparing checkpoint proposal ${checkpointNumber} for target slot ${targetSlot} during wall-clock slot ${slot}`,
+      {
+        ...logCtx,
+        proposer,
+        pipeliningEnabled: this.epochCache.isProposerPipeliningEnabled(),
+      },
     );
 
-    // Enqueues block invalidation
-    if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-      publisher.enqueueInvalidateBlock(invalidateBlock);
-    }
-
-    // Actual block building
-    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-    const block: L2Block | undefined = await this.tryBuildBlockAndEnqueuePublish(
+    // Create and return the checkpoint proposal job
+    return this.createCheckpointProposalJob(
       slot,
+      targetSlot,
+      epoch,
+      targetEpoch,
+      checkpointNumber,
+      syncedTo.blockNumber,
       proposer,
-      newBlockNumber,
       publisher,
-      newGlobalVariables,
-      chainTipArchive,
-      invalidateBlock,
+      attestorAddress,
+      invalidateCheckpoint,
     );
-
-    // Wait until the voting promises have resolved, so all requests are enqueued
-    await Promise.all(votesPromises);
-
-    // And 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 ?? {});
-    }
-
-    this.setState(SequencerState.IDLE, undefined);
   }
 
-  /** Tries building a block proposal, and if successful, enqueues it for publishing. */
-  private async tryBuildBlockAndEnqueuePublish(
-    slot: bigint,
+  protected createCheckpointProposalJob(
+    slot: SlotNumber,
+    targetSlot: SlotNumber,
+    epoch: EpochNumber,
+    targetEpoch: EpochNumber,
+    checkpointNumber: CheckpointNumber,
+    syncedToBlockNumber: BlockNumber,
     proposer: EthAddress | undefined,
-    newBlockNumber: number,
     publisher: SequencerPublisher,
-    newGlobalVariables: GlobalVariables,
-    chainTipArchive: Fr,
-    invalidateBlock: InvalidateBlockRequest | undefined,
-  ) {
-    this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-      proposer,
-      publisher: publisher.getSenderAddress(),
-      globalVariables: newGlobalVariables.toInspect(),
-      chainTipArchive,
-      blockNumber: newBlockNumber,
+    attestorAddress: EthAddress,
+    invalidateCheckpoint: InvalidateCheckpointRequest | undefined,
+  ): CheckpointProposalJob {
+    return new CheckpointProposalJob(
       slot,
-    });
-
-    const proposalHeader = CheckpointHeader.from({
-      ...newGlobalVariables,
-      timestamp: newGlobalVariables.timestamp,
-      lastArchiveRoot: chainTipArchive,
-      contentCommitment: ContentCommitment.empty(),
-      totalManaUsed: Fr.ZERO,
-    });
-
-    let block: L2Block | undefined;
-
-    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: any) {
-        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 });
-        }
-      }
-    } 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 });
-    }
-    return block;
+      targetSlot,
+      epoch,
+      targetEpoch,
+      checkpointNumber,
+      syncedToBlockNumber,
+      proposer,
+      publisher,
+      attestorAddress,
+      invalidateCheckpoint,
+      this.validatorClient,
+      this.globalsBuilder,
+      this.p2pClient,
+      this.worldState,
+      this.l1ToL2MessageSource,
+      this.l2BlockSource,
+      this.checkpointsBuilder,
+      this.l2BlockSource,
+      this.l1Constants,
+      this.config,
+      this.timetable,
+      this.slasherClient,
+      this.epochCache,
+      this.dateProvider,
+      this.metrics,
+      this,
+      this.setState.bind(this),
+      this.tracer,
+      this.log.getBindings(),
+    );
   }
 
-  @trackSpan('Sequencer.work')
-  protected 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' as const)
-          : ('warn' as const);
-        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 sequencer state.
+   */
+  public getState(): SequencerState {
+    return this.state;
   }
 
   /**
-   * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+   * 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: SequencerStateWithSlot, slotNumber: bigint, opts?: { force?: boolean }): void;
-  setState(
-    proposedState: Exclude<SequencerState, SequencerStateWithSlot>,
-    slotNumber?: undefined,
-    opts?: { force?: boolean },
-  ): void;
-  setState(proposedState: SequencerState, slotNumber: bigint | undefined, opts: { force?: boolean } = {}): void {
+  protected setState(
+    proposedState: SequencerState,
+    slotNumber: SlotNumber | undefined,
+    opts: { force?: boolean } = {},
+  ): void {
     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();
@@ -517,308 +490,25 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       oldState: this.state,
       newState: proposedState,
       secondsIntoSlot,
-      slotNumber,
+      slot: slotNumber,
     });
     this.state = proposedState;
   }
 
-  private async dropFailedTxsFromP2P(failedTxs: FailedTx[]) {
-    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);
-  }
-
-  protected getBlockBuilderOptions(slot: number): PublicProcessorLimits {
-    // 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_BLOCK * 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
-   */
-  @trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, _proposalHeader, newGlobalVariables) => ({
-    [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber,
-  }))
-  private async buildBlockAndEnqueuePublish(
-    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
-    proposalHeader: CheckpointHeader,
-    newGlobalVariables: GlobalVariables,
-    proposerAddress: EthAddress | undefined,
-    invalidateBlock: InvalidateBlockRequest | undefined,
-    publisher: SequencerPublisher,
-  ): Promise<L2Block> {
-    await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
-
-    const blockNumber = newGlobalVariables.blockNumber;
-    const slot = proposalHeader.slotNumber.toBigInt();
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-
-    const workTimer = new Timer();
-    this.setState(SequencerState.CREATING_BLOCK, slot);
-
-    try {
-      const blockBuilderOptions = this.getBlockBuilderOptions(Number(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: L2BlockBuiltStats = {
-        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,
-        },
-      );
-
-      this.log.debug('Collecting attestations');
-      const attestations = await this.collectAttestations(block, usedTxs, proposerAddress);
-      if (attestations !== undefined) {
-        this.log.verbose(`Collected ${attestations.length} attestations`, { blockHash, blockNumber });
-      }
-
-      const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations ?? []);
-      const attestationsAndSignersSignature = this.validatorClient
-        ? await this.validatorClient.signAttestationsAndSigners(
-            attestationsAndSigners,
-            proposerAddress ?? publisher.getSenderAddress(),
-          )
-        : Signature.empty();
-
-      await this.enqueuePublishL2Block(
-        block,
-        attestationsAndSigners,
-        attestationsAndSignersSignature,
-        invalidateBlock,
-        publisher,
-      );
-      this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
-      return block;
-    } catch (err) {
-      this.metrics.recordFailedBlock();
-      throw err;
-    }
-  }
-
-  @trackSpan('Sequencer.collectAttestations', (block, txHashes) => ({
-    [Attributes.BLOCK_NUMBER]: block.number,
-    [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
-    [Attributes.BLOCK_TXS_COUNT]: txHashes.length,
-  }))
-  protected async collectAttestations(
-    block: L2Block,
-    txs: Tx[],
-    proposerAddress: EthAddress | undefined,
-  ): Promise<CommitteeAttestation[] | undefined> {
-    const { committee } = await this.epochCache.getCommittee(block.header.getSlot());
-
-    // 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 undefined;
-    } else {
-      this.log.debug(`Attesting committee length is ${committee.length}`);
-    }
-
-    if (!this.validatorClient) {
-      const msg = 'Missing validator client: Cannot collect attestations';
-      this.log.error(msg);
-      throw new Error(msg);
-    }
-
-    const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
-
-    const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
-    this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
-
-    this.log.debug('Creating block proposal for validators');
-    const blockProposalOptions: BlockProposalOptions = {
-      publishFullTxs: !!this.config.publishTxsWithProposals,
-      broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
-    };
-    const proposal = await this.validatorClient.createBlockProposal(
-      block.header.globalVariables.blockNumber,
-      block.getCheckpointHeader(),
-      block.archive.root,
-      block.header.state,
-      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 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: number = 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);
-      if (this.config.injectFakeAttestation) {
-        const nonEmpty = sorted.filter(a => !a.signature.isEmpty());
-        const randomIndex = randomInt(nonEmpty.length);
-        this.log.warn(`Injecting fake attestation in block ${block.number}`);
-        unfreeze(nonEmpty[randomIndex]).signature = Signature.random();
-      }
-      return sorted;
-    } catch (err) {
-      if (err && err instanceof AttestationTimeoutError) {
-        collectedAttestationsCount = err.collectedCount;
-      }
-      throw err;
-    } finally {
-      this.metrics.recordCollectedAttestations(collectedAttestationsCount, timer.ms());
-    }
-  }
-
-  /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */
-  @trackSpan('Sequencer.enqueuePublishL2Block', block => ({
-    [Attributes.BLOCK_NUMBER]: block.number,
-  }))
-  protected async enqueuePublishL2Block(
-    block: L2Block,
-    attestationsAndSigners: CommitteeAttestationsAndSigners,
-    attestationsAndSignersSignature: Signature,
-    invalidateBlock: InvalidateBlockRequest | undefined,
-    publisher: SequencerPublisher,
-  ): Promise<void> {
-    // Publishes new block to the network and awaits the tx to be mined
-    this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
-
-    // Time out tx at the end of the slot
-    const slot = block.header.globalVariables.slotNumber.toNumber();
-    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.
    */
-  protected async checkSync(args: { ts: bigint; slot: bigint }): Promise<
-    | {
-        block?: L2Block;
-        blockNumber: number;
-        archive: Fr;
-        l1Timestamp: bigint;
-        pendingChainValidationStatus: ValidateBlockResult;
-      }
-    | undefined
-  > {
-    // Check that the archiver and dependencies have synced to the previous L1 slot at least
+  protected async checkSync(args: { ts: bigint; slot: SlotNumber }): Promise<SequencerSyncCheckResult | undefined> {
+    // Check that the archiver has fully synced the L2 slot before the one we want to propose in.
     // TODO(#14766): Archiver reports L1 timestamp based on L1 blocks seen, which means that a missed L1 block will
     // cause the archiver L1 timestamp to fall behind, and cause this sequencer to start processing one L1 slot later.
-    const l1Timestamp = await this.l2BlockSource.getL1Timestamp();
-    const { slot, ts } = args;
-    if (l1Timestamp === undefined || l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
+    const syncedL2Slot = await this.l2BlockSource.getSyncedL2SlotNumber();
+    const { slot } = args;
+    if (syncedL2Slot === undefined || syncedL2Slot + 1 < slot) {
       this.log.debug(`Cannot propose block at next L2 slot ${slot} due to pending sync from L1`, {
         slot,
-        ts,
-        l1Timestamp,
+        syncedL2Slot,
       });
       return undefined;
     }
@@ -828,22 +518,22 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         number: syncSummary.latestBlockNumber,
         hash: syncSummary.latestBlockHash,
       })),
-      this.l2BlockSource.getL2Tips().then(t => t.latest),
+      this.l2BlockSource.getL2Tips().then(t => t.proposed),
       this.p2pClient.getStatus().then(p2p => p2p.syncedToL2Block),
-      this.l1ToL2MessageSource.getL2Tips().then(t => t.latest),
+      this.l1ToL2MessageSource.getL2Tips().then(t => t.proposed),
       this.l2BlockSource.getPendingChainValidationStatus(),
     ] as const);
 
     const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, pendingChainValidationStatus] = syncedBlocks;
 
-    // The archiver reports 'undefined' hash for the genesis block
-    // because it doesn't have access to world state to compute it (facepalm)
+    // Handle zero as a special case, since the block hash won't match across services if we're changing the prefilled data for the genesis block,
+    // as the world state can compute the new genesis block hash, but other components use the hardcoded constant.
+    // TODO(palla/mbps): Fix the above. All components should be able to handle dynamic genesis block hashes.
     const result =
-      l2BlockSource.hash === undefined
-        ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0
-        : worldState.hash === l2BlockSource.hash &&
-          p2p.hash === l2BlockSource.hash &&
-          l1ToL2MessageSource.hash === l2BlockSource.hash;
+      (l2BlockSource.number === 0 && worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0) ||
+      (worldState.hash === l2BlockSource.hash &&
+        p2p.hash === l2BlockSource.hash &&
+        l1ToL2MessageSource.hash === l2BlockSource.hash);
 
     if (!result) {
       this.log.debug(`Sequencer sync check failed`, { worldState, l2BlockSource, p2p, l1ToL2MessageSource });
@@ -854,85 +544,50 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     const blockNumber = worldState.number;
     if (blockNumber < INITIAL_L2_BLOCK_NUM) {
       const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-      return { blockNumber: INITIAL_L2_BLOCK_NUM - 1, archive, l1Timestamp, pendingChainValidationStatus };
+      return {
+        checkpointNumber: CheckpointNumber.ZERO,
+        blockNumber: BlockNumber.ZERO,
+        archive,
+        syncedL2Slot,
+        pendingChainValidationStatus,
+      };
     }
 
-    const block = await this.l2BlockSource.getBlock(blockNumber);
-    if (!block) {
+    const blockData = await this.l2BlockSource.getBlockData(blockNumber);
+    if (!blockData) {
       // 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`);
+      this.log.error(`Failed to get L2 block data ${blockNumber} from the archiver with all components in sync`);
       return undefined;
     }
 
     return {
-      block,
-      blockNumber: block.number,
-      archive: block.archive.root,
-      l1Timestamp,
+      blockData,
+      blockNumber: blockData.header.getBlockNumber(),
+      checkpointNumber: blockData.checkpointNumber,
+      archive: blockData.archive.root,
+      syncedL2Slot,
       pendingChainValidationStatus,
     };
   }
 
-  /**
-   * 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]
-   */
-  protected enqueueGovernanceAndSlashingVotes(
-    publisher: SequencerPublisher,
-    attestorAddress: EthAddress,
-    slot: bigint,
-    timestamp: bigint,
-  ): [Promise<boolean> | undefined, Promise<boolean> | undefined] {
-    try {
-      const signerFn = (msg: TypedDataDefinition) =>
-        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 => 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)
    */
-  protected async checkCanPropose(slot: bigint): Promise<[boolean, EthAddress | undefined]> {
+  protected async checkCanPropose(targetSlot: SlotNumber): Promise<[boolean, EthAddress | undefined]> {
     let proposer: EthAddress | undefined;
+
     try {
-      proposer = await this.epochCache.getProposerAttesterAddressInSlot(slot);
+      proposer = await this.epochCache.getProposerAttesterAddressInSlot(targetSlot);
     } catch (e) {
       if (e instanceof NoCommitteeError) {
-        this.log.warn(`Cannot propose at next L2 slot ${slot} since the committee does not exist on L1`);
+        if (this.lastSlotForNoCommitteeWarning !== targetSlot) {
+          this.lastSlotForNoCommitteeWarning = targetSlot;
+          this.log.warn(`Cannot propose at target slot ${targetSlot} since the committee does not exist on L1`);
+        }
         return [false, undefined];
       }
-      this.log.error(`Error getting proposer for slot ${slot}`, e);
+      this.log.error(`Error getting proposer for target slot ${targetSlot}`, e);
       return [false, undefined];
     }
 
@@ -940,15 +595,24 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     if (proposer === undefined) {
       return [true, undefined];
     }
+    // In fisherman mode, just return the current proposer
+    if (this.config.fishermanMode) {
+      return [true, proposer];
+    }
 
-    const validatorAddresses = this.validatorClient!.getValidatorAddresses();
+    const validatorAddresses = this.validatorClient.getValidatorAddresses();
     const weAreProposer = validatorAddresses.some(addr => addr.equals(proposer));
 
     if (!weAreProposer) {
-      this.log.debug(`Cannot propose at slot ${slot} since we are not a proposer`, { validatorAddresses, proposer });
+      this.log.debug(`Cannot propose at target slot ${targetSlot} since we are not a proposer`, {
+        targetSlot,
+        validatorAddresses,
+        proposer,
+      });
       return [false, proposer];
     }
 
+    this.log.debug(`We are the proposer for target slot ${targetSlot}`, { targetSlot, proposer });
     return [true, proposer];
   }
 
@@ -956,43 +620,44 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    * 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.
    */
-  protected async tryVoteWhenSyncFails(args: { slot: bigint; ts: bigint }): Promise<void> {
-    const { slot, ts } = args;
+  @trackSpan('Seqeuencer.tryVoteWhenSyncFails', ({ slot }) => ({ [Attributes.SLOT_NUMBER]: slot }))
+  protected async tryVoteWhenSyncFails(args: { slot: SlotNumber; targetSlot: SlotNumber; ts: bigint }): Promise<void> {
+    const { slot, targetSlot } = args;
 
     // Prevent duplicate attempts in the same slot
-    if (this.lastSlotForVoteWhenSyncFailed === slot) {
-      this.log.debug(`Already attempted to vote in slot ${slot} (skipping)`);
+    if (this.lastSlotForFallbackVote === slot) {
+      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);
+    const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
     if (!canPropose) {
-      this.log.debug(`Cannot vote in slot ${slot} since we are not a proposer`, { slot, proposer });
+      this.log.trace(`Cannot vote in slot ${slot} since we are not a proposer`, { slot, proposer });
       return;
     }
 
     // Mark this slot as attempted
-    this.lastSlotForVoteWhenSyncFailed = slot;
+    this.lastSlotForFallbackVote = slot;
 
     // Get a publisher for voting
     const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
@@ -1002,11 +667,22 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       slot,
     });
 
-    // Enqueue governance and slashing votes using the shared helper method
-    const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, ts);
-    await Promise.all(votesPromises);
+    // Enqueue governance and slashing votes (voter uses the target slot for L1 submission)
+    const voter = new CheckpointVoter(
+      targetSlot,
+      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 (votesPromises.every(p => !p)) {
+    if (votes.every(p => !p)) {
       this.log.debug(`No votes to enqueue for slot ${slot}`);
       return;
     }
@@ -1015,34 +691,81 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     await publisher.sendRequests();
   }
 
+  /**
+   * Tries to vote on slashing actions and governance proposals when escape hatch is open.
+   * This allows the sequencer to participate in voting without performing checkpoint proposal work.
+   */
+  @trackSpan('Sequencer.tryVoteWhenEscapeHatchOpen', ({ slot }) => ({ [Attributes.SLOT_NUMBER]: slot }))
+  protected async tryVoteWhenEscapeHatchOpen(args: {
+    slot: SlotNumber;
+    proposer: EthAddress | undefined;
+  }): Promise<void> {
+    const { slot, proposer } = args;
+
+    // Prevent duplicate attempts in the same slot
+    if (this.lastSlotForFallbackVote === slot) {
+      this.log.trace(`Already attempted to vote in slot ${slot} (escape hatch open, skipping)`);
+      return;
+    }
+
+    // Mark this slot as attempted
+    this.lastSlotForFallbackVote = slot;
+
+    const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+
+    this.log.debug(`Escape hatch open for slot ${slot}, attempting vote-only actions`, { slot, attestorAddress });
+
+    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} (escape hatch open)`);
+      return;
+    }
+
+    this.log.info(`Voting in slot ${slot} (escape hatch open)`, { slot });
+    await publisher.sendRequests();
+  }
+
   /**
    * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
    * has been there without being invalidated and whether the sequencer is in the committee or not. We always
    * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
    * and if they fail, any sequencer will try as well.
    */
-  protected async considerInvalidatingBlock(
-    syncedTo: NonNullable<Awaited<ReturnType<Sequencer['checkSync']>>>,
-    currentSlot: bigint,
+  protected async considerInvalidatingCheckpoint(
+    syncedTo: SequencerSyncCheckResult,
+    currentSlot: SlotNumber,
   ): Promise<void> {
-    const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
+    const { pendingChainValidationStatus, syncedL2Slot } = syncedTo;
     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);
-    const ourValidatorAddresses = this.validatorClient!.getValidatorAddresses();
+    const invalidCheckpointNumber = pendingChainValidationStatus.checkpoint.checkpointNumber;
+    const invalidCheckpointTimestamp = pendingChainValidationStatus.checkpoint.timestamp;
+    const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidCheckpointTimestamp);
+    const ourValidatorAddresses = this.validatorClient.getValidatorAddresses();
 
     const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } =
       this.config;
 
     const logData = {
-      invalidL1Timestamp: invalidBlockTimestamp,
-      l1Timestamp,
-      invalidBlock: pendingChainValidationStatus.block,
+      invalidL1Timestamp: invalidCheckpointTimestamp,
+      syncedL2Slot,
+      invalidCheckpoint: pendingChainValidationStatus.checkpoint,
       secondsBeforeInvalidatingBlockAsCommitteeMember,
       secondsBeforeInvalidatingBlockAsNonCommitteeMember,
       ourValidatorAddresses,
@@ -1070,41 +793,124 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       return;
     }
 
-    const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
-    if (!invalidateBlock) {
-      this.log.warn(`Failed to simulate invalidate block`, logData);
+    let validatorToUse: EthAddress;
+    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 invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(pendingChainValidationStatus);
+    if (!invalidateCheckpoint) {
+      this.log.warn(`Failed to simulate invalidate checkpoint`, logData);
       return;
     }
 
     this.log.info(
       invalidateAsCommitteeMember
-        ? `Invalidating block ${invalidBlockNumber} as committee member`
-        : `Invalidating block ${invalidBlockNumber} as non-committee member`,
+        ? `Invalidating checkpoint ${invalidCheckpointNumber} as committee member`
+        : `Invalidating checkpoint ${invalidCheckpointNumber} as non-committee member`,
       logData,
     );
 
-    publisher.enqueueInvalidateBlock(invalidateBlock);
-    await publisher.sendRequests();
+    publisher.enqueueInvalidateCheckpoint(invalidateCheckpoint);
+
+    if (!this.config.fishermanMode) {
+      await publisher.sendRequests();
+    } else {
+      this.log.info('Invalidating checkpoint in fisherman mode, clearing pending requests');
+      publisher.clearPendingRequests();
+    }
+  }
+
+  private logStrategyComparison(epoch: EpochNumber, publisher: SequencerPublisher): void {
+    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),
+      })),
+    });
   }
 
-  private getSlotStartBuildTimestamp(slotNumber: number | bigint): number {
+  private getSlotStartBuildTimestamp(slotNumber: SlotNumber): number {
     return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
   }
 
-  private getSecondsIntoSlot(slotNumber: number | bigint): number {
+  private getSecondsIntoSlot(slotNumber: SlotNumber): number {
     const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
     return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
   }
 
-  get aztecSlotDuration() {
+  public get aztecSlotDuration() {
     return this.l1Constants.slotDuration;
   }
 
-  get maxL2BlockGas(): number | undefined {
+  public get maxL2BlockGas(): number | undefined {
     return this.config.maxL2BlockGas;
   }
 
   public getSlasherClient(): SlasherClientInterface | undefined {
     return this.slasherClient;
   }
+
+  public get tracer(): Tracer {
+    return this.metrics.tracer;
+  }
+
+  public getValidatorAddresses() {
+    return this.validatorClient?.getValidatorAddresses();
+  }
+
+  /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+  public updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.publisherFactory.updateNodeKeyStore(adapter);
+  }
+
+  public getConfig() {
+    return this.config;
+  }
+
+  private get l1PublishingTime(): number {
+    return this.config.l1PublishingTime ?? this.l1Constants.ethereumSlotDuration;
+  }
 }
+
+type SequencerSyncCheckResult = {
+  blockData?: BlockData;
+  checkpointNumber: CheckpointNumber;
+  blockNumber: BlockNumber;
+  archive: Fr;
+  syncedL2Slot: SlotNumber;
+  pendingChainValidationStatus: ValidateCheckpointResult;
+};