@aztec/sequencer-client 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/dest/sequencer/sequencer.js

@@ -372,22 +372,23 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 }
 var _dec, _dec1, _dec2, _dec3, _initProto;
 import { getKzg } from '@aztec/blob-lib';
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { CheckpointNumber, 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 { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getSlotStartBuildTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { MIN_EXECUTION_TIME } from '@aztec/stdlib/timetable';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import EventEmitter from 'node:events';
 import { DefaultSequencerConfig } from '../config.js';
+import { buildCheckpointSimulationOverridesPlan } from './chain_state_overrides.js';
 import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import { CheckpointProposalJobMetrics } from './checkpoint_proposal_job_metrics.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
 import { SequencerMetrics } from './metrics.js';
@@ -448,46 +449,51 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
     }
     runningPromise;
     state;
+    stateSlotNumber;
+    stateEnteredAtMs;
     metrics;
+    checkpointProposalJobMetrics;
+    stateLog;
     /** The last slot for which we attempted to perform our voting duties with degraded block production */ lastSlotForFallbackVote;
     /** The last slot for which we logged "no committee" warning, to avoid spam */ lastSlotForNoCommitteeWarning;
     /** 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 last checkpoint proposal job, tracked so we can await its pending L1 submission during shutdown. */ lastCheckpointProposalJob;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
-    // 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;
     /** Config for the sequencer */ config;
+    signatureContext;
     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 = (_initProto(this), SequencerState.STOPPED), this.config = DefaultSequencerConfig;
+        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 = (_initProto(this), SequencerState.STOPPED), this.stateEnteredAtMs = performance.now(), this.config = DefaultSequencerConfig;
+        this.stateLog = log.createChild('state');
         // Add [FISHERMAN] prefix to logger if in fisherman mode
         if (config.fishermanMode) {
             this.log = log.createChild('[FISHERMAN]');
         }
+        this.signatureContext = {
+            chainId: config.l1ChainId,
+            rollupAddress: config.rollupAddress
+        };
         this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+        this.checkpointProposalJobMetrics = new CheckpointProposalJobMetrics(telemetry);
         this.updateConfig(config);
     }
     /** 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.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowListExtend'));
         this.config = merge(this.config, filteredConfig);
+        const p2pPropagationTime = this.config.attestationPropagationTime;
         this.timetable = new SequencerTimetable({
             ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
             aztecSlotDuration: this.aztecSlotDuration,
             l1PublishingTime: this.l1PublishingTime,
-            p2pPropagationTime: this.config.attestationPropagationTime,
+            p2pPropagationTime,
             blockDurationMs: this.config.blockDurationMs,
             enforce: this.config.enforceTimeTable
         }, this.metrics, this.log);
     }
-    /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */ async init() {
+    /** Initializes the sequencer (precomputes tables). Takes about 3s. */ 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.config.sequencerPollingIntervalMS);
@@ -497,13 +503,18 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         this.runningPromise.start();
         this.log.info('Started sequencer');
     }
+    /** Triggers an immediate run of the sequencer, bypassing the polling interval. */ trigger() {
+        return this.runningPromise?.trigger();
+    }
     /** 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
         });
-        this.publisher?.interrupt();
+        this.lastCheckpointProposalJob?.interrupt();
+        await this.publisherFactory.stopAll();
         await this.runningPromise?.stop();
+        await this.lastCheckpointProposalJob?.awaitPendingSubmission();
         this.setState(SequencerState.STOPPED, undefined, {
             force: true
         });
@@ -513,21 +524,19 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         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, {
+            if (err instanceof SequencerTooSlowError && [
+                SequencerState.INITIALIZING_CHECKPOINT,
+                SequencerState.PROPOSER_CHECK
+            ].includes(err.proposedState)) {
+                // No need to alert if we just didn't get to start in time
+                this.log.debug(err.message, {
                     now: this.dateProvider.nowInSeconds()
                 });
             } else {
                 // Re-throw other errors
+                this.emit('checkpoint-error', {
+                    error: err
+                });
                 throw err;
             }
         } finally{
@@ -548,40 +557,62 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
    * - Submit checkpoint
    */ async work() {
         this.setState(SequencerState.SYNCHRONIZING, undefined);
-        const { slot, ts, now, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+        const { slot, targetSlot, epoch, targetEpoch, ts, nowSeconds } = this.getSlotContextInNextL1Slot();
         // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
-        const checkpointProposalJob = await this.prepareCheckpointProposal(epoch, slot, ts, now);
+        const checkpointProposalJob = await this.prepareCheckpointProposal(slot, targetSlot, epoch, targetEpoch, ts, nowSeconds);
         if (!checkpointProposalJob) {
             return;
         }
+        // Track the job so we can await its pending L1 submission during shutdown
+        this.lastCheckpointProposalJob = checkpointProposalJob;
         // 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;
+        // 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;
     }
+    /** Returns slot and target slot from a single clock snapshot. */ getSlotContextInNextL1Slot() {
+        const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+        const targetSlot = SlotNumber(slot + PROPOSER_PIPELINING_SLOT_OFFSET);
+        return {
+            slot,
+            targetSlot,
+            epoch,
+            targetEpoch: getEpochAtSlot(targetSlot, this.l1Constants),
+            ts,
+            nowSeconds
+        };
+    }
     /**
    * 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(epoch, slot, ts, now) {
-        // Check we have not already processed this slot (cheapest check)
+   */ async prepareCheckpointProposal(slot, targetSlot, epoch, targetEpoch, ts, nowSeconds) {
+        // 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 >= slot && this.config.enforceTimeTable) {
-            this.log.trace(`Slot ${slot} has already been processed`);
+        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;
         }
-        // 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}`);
+        // Test-only: skip proposing for explicitly paused slots. Attestation paths run in the validator
+        // client and are not gated by this hook, so paused proposers still attest to others' proposals.
+        if (this.config.pauseProposingForSlots?.some((s)=>s === targetSlot)) {
+            this.log.warn(`Skipping proposal for paused slot ${targetSlot} (test-only pauseProposingForSlots hook)`, {
+                targetSlot
+            });
             return undefined;
         }
         // Check all components are synced to latest as seen by the archiver (queries all subsystems)
@@ -592,19 +623,22 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         if (!syncedTo) {
             await this.tryVoteWhenSyncFails({
                 slot,
+                targetSlot,
                 ts
             });
             return undefined;
         }
-        // If escape hatch is open for this epoch, do not start checkpoint proposal work and do not attempt invalidations.
+        // 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.
-        const isEscapeHatchOpen = await this.epochCache.isEscapeHatchOpen(epoch);
+        // 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(slot);
+            const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
             if (canPropose) {
                 await this.tryVoteWhenEscapeHatchOpen({
                     slot,
+                    targetSlot,
                     proposer
                 });
             } else {
@@ -619,29 +653,36 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         // Next checkpoint follows from the last synced one
         const checkpointNumber = CheckpointNumber(syncedTo.checkpointNumber + 1);
         const logCtx = {
-            now,
-            syncedToL1Ts: syncedTo.l1Timestamp,
-            syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
+            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 an invalid checkpoint, and bail
         if (!canPropose) {
             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) {
-            this.log.warn(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
+        // Guard: don't exceed 1-deep pipeline. Without a proposed checkpoint, we can only build
+        // confirmed + 1. With a proposed checkpoint, we can build confirmed + 2.
+        const confirmedCkpt = syncedTo.checkpointedCheckpointNumber;
+        if (checkpointNumber > confirmedCkpt + 2) {
+            this.log.verbose(`Skipping slot ${targetSlot}: checkpoint ${checkpointNumber} exceeds max pipeline depth (confirmed=${confirmedCkpt})`);
+            return undefined;
+        }
+        // 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 target slot ${targetSlot} since that slot was taken by block ${syncedTo.blockNumber}`, {
                 ...logCtx,
-                block: syncedTo.block.header.toInspect()
+                block: syncedTo.blockData.header.toInspect()
             });
-            this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
+            this.metrics.recordCheckpointPrecheckFailed('slot_already_taken');
             return undefined;
         }
         // We now need to get ourselves a publisher.
@@ -651,42 +692,109 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         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 && 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).
+        // Only simulate invalidation when there's no proposed parent, since we assume the proposed parent
+        // will invalidate the currently invalid checkpoint on L1.
+        const invalidateCheckpoint = syncedTo.hasProposedCheckpoint || syncedTo.pendingChainValidationStatus.valid ? undefined : await publisher.simulateInvalidateCheckpoint(syncedTo.pendingChainValidationStatus);
+        // Determine the correct archive and L1 state overrides for the canProposeAt check.
+        // The L1 contract reads archives[proposedCheckpointNumber] and compares it with the provided archive.
+        // When invalidating or pipelining, the local archive may differ from L1's, so we adjust accordingly.
+        let archiveForCheck = syncedTo.archive;
+        if (syncedTo.hasProposedCheckpoint) {
+            this.metrics.recordPipelineDepth(syncedTo.checkpointNumber - syncedTo.checkpointedCheckpointNumber);
+            this.log.verbose(`Building on top of proposed checkpoint (pending=${syncedTo.proposedCheckpointData?.checkpointNumber}) for target slot ${targetSlot}`, {
+                targetSlot,
+                parentCheckpointNumber: CheckpointNumber(checkpointNumber - 1)
+            });
+            // Match what L1 will see at archives[pending] once the proposed parent lands: the parent's
+            // own archive root from the gossiped proposal. `syncedTo.archive` is the world-state-local
+            // view and can transiently diverge from the proposed parent (e.g. before the proposed
+            // parent's blocks have been applied locally); diverging here would cause the canProposeAt
+            // override to set archives[pending] to one value while we present another for comparison.
+            archiveForCheck = syncedTo.proposedCheckpointData.archive.root;
+        } else if (invalidateCheckpoint) {
+            // After invalidation, L1 will roll back to checkpoint N-1. The archive at N-1 already
+            // exists on L1, so we just pass the matching archive (the lastArchive of the invalid checkpoint).
+            archiveForCheck = invalidateCheckpoint.lastArchive;
+            this.metrics.recordPipelineDepth(0);
+        } else {
+            this.metrics.recordPipelineDepth(0);
         }
-        // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
-        const invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(syncedTo.pendingChainValidationStatus);
-        // 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(syncedTo.archive, proposer ?? EthAddress.ZERO, invalidateCheckpoint);
+        // Build the simulation plan: pending/proven override from pipelining or invalidation (or the
+        // current snapshot when neither applies, to short-circuit any pending prune in simulation),
+        // plus the parent checkpoint cell and fee header when pipelining.
+        const simulationOverridesPlan = await buildCheckpointSimulationOverridesPlan({
+            checkpointNumber,
+            proposedCheckpointData: syncedTo.hasProposedCheckpoint ? syncedTo.proposedCheckpointData : undefined,
+            invalidateToPendingCheckpointNumber: invalidateCheckpoint?.forcePendingCheckpointNumber,
+            checkpointedCheckpointNumber: syncedTo.checkpointedCheckpointNumber,
+            rollup: this.rollupContract,
+            signatureContext: this.signatureContext,
+            log: this.log
+        });
+        // The plan always pins both pending/proven (to short-circuit `canPruneAtTime` in simulation),
+        // so `provenOverride` always reflects the assumed proven checkpoint we are pinning the
+        // simulation to. We additionally warn when the pin is load-bearing — i.e. when a prune would
+        // actually fire at the target slot without it — so observers can spot "we are building
+        // optimistically across a pruning boundary" in the logs.
+        const provenOverride = simulationOverridesPlan?.chainTipsOverride?.proven;
+        if (provenOverride !== undefined && await this.l2BlockSource.isPruneDueAtSlot(targetSlot)) {
+            this.log.warn(`Assuming proof for epoch ending at checkpoint ${provenOverride} lands by target slot ${targetSlot}`, {
+                checkpointNumber,
+                slot,
+                targetSlot,
+                provenOverride
+            });
+        }
+        this.emit('preparing-checkpoint', {
+            targetSlot,
+            checkpointNumber,
+            hadProposedParent: syncedTo.hasProposedCheckpoint,
+            provenOverride,
+            simulatedPending: simulationOverridesPlan?.chainTipsOverride?.pending
+        });
+        const canProposeCheck = await publisher.canProposeAt(archiveForCheck, proposer ?? EthAddress.ZERO, simulationOverridesPlan);
+        const proposeContext = {
+            hasProposedCheckpoint: syncedTo.hasProposedCheckpoint,
+            proposedCheckpointNumber: syncedTo.proposedCheckpointData?.checkpointNumber,
+            checkpointedCheckpointNumber: syncedTo.checkpointedCheckpointNumber,
+            isInvalidating: !!invalidateCheckpoint,
+            invalidatingCheckpointNumber: invalidateCheckpoint?.checkpointNumber,
+            archiveForCheck: archiveForCheck.toString(),
+            overridePendingCheckpointNumber: simulationOverridesPlan?.chainTipsOverride?.pending,
+            overrideArchive: simulationOverridesPlan?.pendingCheckpointState?.archive,
+            overrideFeeHeader: simulationOverridesPlan?.pendingCheckpointState?.feeHeader
+        };
         if (canProposeCheck === undefined) {
-            this.log.warn(`Cannot propose checkpoint ${checkpointNumber} at slot ${slot} due to failed rollup contract check`, logCtx);
+            this.log.warn(`Cannot propose checkpoint ${checkpointNumber} at slot ${slot} due to failed rollup contract check`, {
+                ...logCtx,
+                ...proposeContext
+            });
             this.emit('proposer-rollup-check-failed', {
                 reason: 'Rollup contract check failed',
                 slot
             });
-            this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
+            this.metrics.recordCheckpointPrecheckFailed('rollup_contract_check_failed');
             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}.`, {
+        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 ${targetSlot} but got ${canProposeCheck.slot}.`, {
                 ...logCtx,
+                ...proposeContext,
                 rollup: canProposeCheck,
-                expectedSlot: slot
+                expectedSlot: targetSlot
             });
             this.emit('proposer-rollup-check-failed', {
                 reason: 'Slot mismatch',
                 slot
             });
-            this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
+            this.metrics.recordCheckpointPrecheckFailed('slot_mismatch');
             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,
+                ...proposeContext,
                 rollup: canProposeCheck,
                 expectedSlot: slot
             });
@@ -694,25 +802,35 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
                 reason: 'Block mismatch',
                 slot
             });
-            this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
+            this.metrics.recordCheckpointPrecheckFailed('block_number_mismatch');
             return undefined;
         }
-        this.lastSlotForCheckpointProposalJob = slot;
-        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} at slot ${slot}`, {
+        this.lastSlotForCheckpointProposalJob = targetSlot;
+        await this.p2pClient.prepareForSlot(targetSlot);
+        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} for target slot ${targetSlot} during wall-clock slot ${slot}`, {
             ...logCtx,
+            ...proposeContext,
             proposer
         });
         // Create and return the checkpoint proposal job
-        return this.createCheckpointProposalJob(epoch, slot, checkpointNumber, syncedTo.blockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint);
+        return this.createCheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedTo.blockNumber, syncedTo.checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, syncedTo.proposedCheckpointData);
     }
-    createCheckpointProposalJob(epoch, slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint) {
-        return new CheckpointProposalJob(epoch, slot, 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());
+    createCheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, proposedCheckpointData) {
+        return new CheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.l2BlockSource, this.checkpointsBuilder, this.l2BlockSource, this.l1Constants, this.signatureContext, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this.checkpointProposalJobMetrics.createRecorder(), this, (state, slot, timeReferenceSlot)=>this.setState(state, slot, {
+                timeReferenceSlot
+            }), this.tracer, this.log.getBindings(), proposedCheckpointData);
+    }
+    /**
+   * Returns the current sequencer state.
+   */ getState() {
+        return this.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 slotNumber - The logical slot associated with the new state.
    * @param force - Whether to force the transition even if the sequencer is stopped.
+   * @param timeReferenceSlot - The slot to use for deadline checks when it differs from the logical slot.
    */ 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.`);
@@ -723,41 +841,59 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
             return;
         }
         let secondsIntoSlot = undefined;
-        if (slotNumber !== undefined) {
-            secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
+        const timeReferenceSlot = opts.timeReferenceSlot ?? slotNumber;
+        if (timeReferenceSlot !== undefined) {
+            secondsIntoSlot = this.getSecondsIntoSlot(timeReferenceSlot);
             this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
         }
+        const oldState = this.state;
+        const oldStateSlotNumber = this.stateSlotNumber;
+        const stateChanged = proposedState !== oldState;
+        const transitionAtMs = performance.now();
+        const stateDurationMs = transitionAtMs - this.stateEnteredAtMs;
         const boringStates = [
             SequencerState.IDLE,
             SequencerState.SYNCHRONIZING
         ];
-        const logLevel = boringStates.includes(proposedState) && boringStates.includes(this.state) ? 'trace' : 'debug';
-        this.log[logLevel](`Transitioning from ${this.state} to ${proposedState}`, {
+        const logLevel = boringStates.includes(proposedState) && boringStates.includes(oldState) ? 'trace' : 'debug';
+        this.stateLog[logLevel](`Transitioning from ${oldState} to ${proposedState}`, {
+            oldState,
+            newState: proposedState,
             slotNumber,
-            secondsIntoSlot
+            timeReferenceSlot,
+            stateSlotNumber: oldStateSlotNumber,
+            secondsIntoSlot,
+            ...stateChanged && {
+                stateDurationMs: Math.ceil(stateDurationMs)
+            }
         });
         this.emit('state-changed', {
-            oldState: this.state,
+            oldState,
             newState: proposedState,
             secondsIntoSlot,
-            slot: slotNumber
+            slot: slotNumber,
+            timeReferenceSlot
         });
+        if (stateChanged) {
+            this.metrics.recordStateDuration(stateDurationMs, oldState);
+            this.stateEnteredAtMs = transitionAtMs;
+            this.stateSlotNumber = slotNumber;
+        }
         this.state = proposedState;
     }
     /**
    * Returns whether all dependencies have caught up.
    * We don't check against the previous block submitted since it may have been reorg'd out.
    */ async checkSync(args) {
-        // Check that the archiver and dependencies have synced to the previous L1 slot at least
-        // 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) {
+        // Check that the archiver has fully synced the L2 slot before the one we want to propose in.
+        // The archiver reports sync progress via L1 block timestamps and synced checkpoint slots.
+        // See getSyncedL2SlotNumber for how missed L1 blocks are handled.
+        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;
         }
@@ -766,71 +902,142 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
                     number: syncSummary.latestBlockNumber,
                     hash: syncSummary.latestBlockHash
                 })),
-            this.l2BlockSource.getL2Tips().then((t)=>t.proposed),
+            this.l2BlockSource.getL2Tips().then((t)=>({
+                    proposed: t.proposed,
+                    checkpointed: t.checkpointed,
+                    proposedCheckpoint: t.proposedCheckpoint
+                })),
             this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
-            this.l1ToL2MessageSource.getL2Tips().then((t)=>t.proposed),
-            this.l2BlockSource.getPendingChainValidationStatus()
+            this.l1ToL2MessageSource.getL2Tips().then((t)=>({
+                    proposed: t.proposed,
+                    checkpointed: t.checkpointed
+                })),
+            this.l2BlockSource.getPendingChainValidationStatus(),
+            this.l2BlockSource.getProposedCheckpointData()
         ]);
-        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, pendingChainValidationStatus] = syncedBlocks;
-        // 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.number === 0 && worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0 || worldState.hash === l2BlockSource.hash && p2p.hash === l2BlockSource.hash && l1ToL2MessageSource.hash === l2BlockSource.hash;
+        const [worldState, l2Tips, p2p, l1ToL2MessageSourceTips, pendingChainValidationStatus, proposedCheckpointData] = syncedBlocks;
+        const result = worldState.hash === l2Tips.proposed.hash && p2p.hash === l2Tips.proposed.hash && l1ToL2MessageSourceTips.proposed.hash === l2Tips.proposed.hash && l1ToL2MessageSourceTips.checkpointed.block.hash === l2Tips.checkpointed.block.hash && l1ToL2MessageSourceTips.checkpointed.checkpoint.hash === l2Tips.checkpointed.checkpoint.hash;
         if (!result) {
             this.log.debug(`Sequencer sync check failed`, {
                 worldState,
-                l2BlockSource,
+                l2BlockSource: l2Tips.proposed,
                 p2p,
-                l1ToL2MessageSource
+                l1ToL2MessageSourceTips
             });
             return undefined;
         }
-        // Special case for genesis state
         const blockNumber = worldState.number;
-        if (blockNumber < INITIAL_L2_BLOCK_NUM) {
-            const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-            return {
-                checkpointNumber: CheckpointNumber.ZERO,
-                blockNumber: BlockNumber.ZERO,
-                archive,
-                l1Timestamp,
-                pendingChainValidationStatus
+        const blockData = await this.l2BlockSource.getBlockData({
+            number: blockNumber
+        });
+        if (!blockData) {
+            this.log.warn(`Sequencer sync check failed: failed to get L2 block data ${blockNumber} from the archiver`, {
+                blockNumber,
+                l2Tips,
+                syncedL2Slot,
+                ...args
+            });
+            return undefined;
+        }
+        // Refuse to build a checkpoint on top of a proposed block whose enclosing checkpoint was never
+        // proposed. Under pipelining we may have received and reexecuted such a block locally — advancing
+        // our world-state tip past the checkpointed tip — while the proposing node never published the
+        // matching proposed checkpoint (e.g. it crashed before assembling it). Building on this orphan block
+        // would fork the chain off a tip no other node can follow. The archiver prunes these orphan blocks
+        // once their build slot ends; this guard is the correctness barrier during the grace window before.
+        if (blockData.checkpointNumber > l2Tips.checkpointed.checkpoint.number && (l2Tips.proposedCheckpoint.checkpoint.number !== blockData.checkpointNumber || proposedCheckpointData?.checkpointNumber !== blockData.checkpointNumber)) {
+            const logCtx = {
+                blockCheckpointNumber: blockData.checkpointNumber,
+                checkpointedCheckpointNumber: l2Tips.checkpointed.checkpoint.number,
+                proposedCheckpointTipNumber: l2Tips.proposedCheckpoint.checkpoint.number,
+                proposedCheckpointDataNumber: proposedCheckpointData?.checkpointNumber,
+                blockNumber: blockData.header.getBlockNumber(),
+                blockSlot: blockData.header.getSlot(),
+                syncedL2Slot,
+                ...args
             };
+            // Under pipelining the block proposal for a checkpoint leads its checkpoint proposal by up to one
+            // slot, so a world-state tip sitting in an as-yet-unproposed checkpoint is the expected steady state
+            // until that checkpoint is due. Only treat it as abnormal — and warn — once the checkpoint is overdue
+            // by the same deadline the archiver uses to prune the orphan block (see pruneOrphanProposedBlocks).
+            // Before then this is normal pipelining and we wait it out quietly.
+            if (this.isProposedCheckpointOverdue(blockData.header.getSlot())) {
+                this.log.warn(`Sequencer sync check failed: proposed block has no matching proposed checkpoint`, logCtx);
+            } else {
+                this.log.debug(`Waiting for proposed checkpoint to catch up with reexecuted block`, logCtx);
+            }
+            return undefined;
+        }
+        const hasProposedCheckpoint = l2Tips.proposedCheckpoint.checkpoint.number > l2Tips.checkpointed.checkpoint.number;
+        // The l2Tips and proposedCheckpointData reads above come from independent archiver snapshots
+        // (a JS-side tips cache vs. a direct store read on `#proposedCheckpoints`). A concurrent archiver
+        // write that mutates both can be observed split, leaving us with `hasProposedCheckpoint=true` but
+        // no proposedCheckpointData (or one whose number doesn't match the tip). Refuse to proceed in that
+        // window — the next checkSync tick will see a coherent snapshot.
+        if (hasProposedCheckpoint && (!proposedCheckpointData || proposedCheckpointData.checkpointNumber !== l2Tips.proposedCheckpoint.checkpoint.number)) {
+            this.log.warn(`Sequencer sync check failed: inconsistent proposed-checkpoint state`, {
+                proposedCheckpointTipNumber: l2Tips.proposedCheckpoint.checkpoint.number,
+                checkpointedTipNumber: l2Tips.checkpointed.checkpoint.number,
+                proposedCheckpointDataNumber: proposedCheckpointData?.checkpointNumber,
+                syncedL2Slot,
+                ...args
+            });
+            return undefined;
         }
-        const block = await this.l2BlockSource.getL2Block(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`);
+        // Check that the proposed checkpoint is indeed the parent of the checkpoint we'll be building
+        // The checkpoint number to build is derived as blockData.checkpointNumber + 1
+        if (proposedCheckpointData && proposedCheckpointData.checkpointNumber !== blockData.checkpointNumber) {
+            this.log.warn(`Sequencer sync check failed: proposed checkpoint number mismatch`, {
+                proposedCheckpointNumber: proposedCheckpointData.checkpointNumber,
+                blockCheckpointNumber: blockData.checkpointNumber,
+                syncedL2Slot,
+                ...args
+            });
             return undefined;
         }
         return {
-            block,
-            blockNumber: block.number,
-            checkpointNumber: block.checkpointNumber,
-            archive: block.archive.root,
-            l1Timestamp,
+            blockData,
+            blockNumber: blockData.header.getBlockNumber(),
+            checkpointNumber: blockData.checkpointNumber,
+            checkpointedCheckpointNumber: l2Tips.checkpointed.checkpoint.number,
+            archive: blockData.archive.root,
+            hasProposedCheckpoint,
+            proposedCheckpointData,
+            syncedL2Slot,
             pendingChainValidationStatus
         };
     }
     /**
+   * Whether the enclosing checkpoint of a reexecuted block is overdue: past the deadline by which a
+   * well-behaved proposer should have published it. Mirrors the archiver's orphan-prune deadline (the
+   * start of the slot after the block's build slot, plus a grace period) so the sequencer only warns
+   * about a missing proposed checkpoint once the archiver itself would prune the orphan block. The grace
+   * is derived from the block build duration the same way the archiver defaults it at node wiring.
+   */ isProposedCheckpointOverdue(blockSlot) {
+        const expectedBySlot = SlotNumber(Number(blockSlot) - PROPOSER_PIPELINING_SLOT_OFFSET + 1);
+        const graceSeconds = this.config.blockDurationMs !== undefined ? Math.ceil(this.config.blockDurationMs / 1000) : MIN_EXECUTION_TIME;
+        const expectedByTime = getTimestampForSlot(expectedBySlot, this.l1Constants) + BigInt(graceSeconds);
+        return BigInt(this.dateProvider.nowInSeconds()) >= expectedByTime;
+    }
+    /**
    * 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) {
+   */ async checkCanPropose(targetSlot) {
         let proposer;
         try {
-            proposer = await this.epochCache.getProposerAttesterAddressInSlot(slot);
+            proposer = await this.epochCache.getProposerAttesterAddressInSlot(targetSlot);
         } catch (e) {
             if (e instanceof NoCommitteeError) {
-                if (this.lastSlotForNoCommitteeWarning !== slot) {
-                    this.lastSlotForNoCommitteeWarning = slot;
-                    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
@@ -853,7 +1060,8 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         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`, {
+            this.log.debug(`Cannot propose at target slot ${targetSlot} since we are not a proposer`, {
+                targetSlot,
                 validatorAddresses,
                 proposer
             });
@@ -862,6 +1070,10 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
                 proposer
             ];
         }
+        this.log.info(`We are the proposer for pipeline slot ${targetSlot}`, {
+            targetSlot,
+            proposer
+        });
         return [
             true,
             proposer
@@ -871,7 +1083,7 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
    * 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 } = args;
+        const { slot, targetSlot } = args;
         // Prevent duplicate attempts in the same slot
         if (this.lastSlotForFallbackVote === slot) {
             this.log.trace(`Already attempted to vote in slot ${slot} (skipping)`);
@@ -894,7 +1106,7 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
             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.trace(`Cannot vote in slot ${slot} since we are not a proposer`, {
                 slot,
@@ -910,8 +1122,8 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
             attestorAddress,
             slot
         });
-        // Enqueue governance and slashing votes
-        const voter = new CheckpointVoter(slot, publisher, attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log);
+        // 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 (votes.every((p)=>!p)) {
@@ -921,13 +1133,21 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         this.log.info(`Voting in slot ${slot} despite sync failure`, {
             slot
         });
-        await publisher.sendRequests();
+        // Votes are EIP-712-signed for `targetSlot` (the pipelined slot in which the multicall is
+        // expected to mine). Delay submission to the start of `targetSlot` so the tx mines in the
+        // slot the votes were signed for. We fire-and-forget so we don't block the sequencer's
+        // work loop while waiting for the target slot to start.
+        void publisher.sendRequestsAt(targetSlot).catch((err)=>{
+            this.log.error(`Failed to publish votes despite sync failure for slot ${slot}`, err, {
+                slot
+            });
+        });
     }
     /**
    * 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.
    */ async tryVoteWhenEscapeHatchOpen(args) {
-        const { slot, proposer } = args;
+        const { slot, targetSlot, 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)`);
@@ -938,9 +1158,14 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
         this.log.debug(`Escape hatch open for slot ${slot}, attempting vote-only actions`, {
             slot,
+            targetSlot,
             attestorAddress
         });
-        const voter = new CheckpointVoter(slot, publisher, attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log);
+        // Under proposer pipelining, the multicall is expected to mine in `targetSlot` (slot + 1).
+        // Governance and slashing votes are EIP-712-signed against the slot they will mine in, and the
+        // L1 contract checks `msg.sender == getCurrentProposer()` using the mining slot. So we must
+        // sign for `targetSlot` and delay submission to the start of `targetSlot`.
+        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 (votes.every((p)=>!p)) {
@@ -948,9 +1173,20 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
             return;
         }
         this.log.info(`Voting in slot ${slot} (escape hatch open)`, {
-            slot
+            slot,
+            targetSlot
+        });
+        // Votes are EIP-712-signed for `targetSlot`. Delay submission to the start of `targetSlot` so
+        // the multicall mines in the slot the votes were signed for; otherwise the L1 contract reads
+        // `signaler = getCurrentProposer()` against the wrong slot and signature verification fails
+        // silently inside Multicall3. Fire-and-forget so we don't block the sequencer's work loop while
+        // waiting for the target slot to start, mirroring tryVoteWhenSyncFails.
+        void publisher.sendRequestsAt(targetSlot).catch((err)=>{
+            this.log.error(`Failed to publish escape-hatch votes for slot ${slot}`, err, {
+                slot,
+                targetSlot
+            });
         });
-        await publisher.sendRequests();
     }
     /**
    * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
@@ -958,7 +1194,7 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
    * 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.
    */ async considerInvalidatingCheckpoint(syncedTo, currentSlot) {
-        const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
+        const { pendingChainValidationStatus, syncedL2Slot } = syncedTo;
         if (pendingChainValidationStatus.valid) {
             return;
         }
@@ -969,7 +1205,7 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
         const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } = this.config;
         const logData = {
             invalidL1Timestamp: invalidCheckpointTimestamp,
-            l1Timestamp,
+            syncedL2Slot,
             invalidCheckpoint: pendingChainValidationStatus.checkpoint,
             secondsBeforeInvalidatingBlockAsCommitteeMember,
             secondsBeforeInvalidatingBlockAsNonCommitteeMember,
@@ -1060,6 +1296,9 @@ _dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpoi
     getValidatorAddresses() {
         return this.validatorClient?.getValidatorAddresses();
     }
+    /** Updates the publisher factory's node keystore adapter after a keystore reload. */ updatePublisherNodeKeyStore(adapter) {
+        this.publisherFactory.updateNodeKeyStore(adapter);
+    }
     getConfig() {
         return this.config;
     }