@aztec/sequencer-client 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/sequencer/checkpoint_proposal_job.js

@@ -435,19 +435,20 @@ function applyDecs2203RFactory() {
 function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _initProto;
-import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, _initProto;
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { flipSignature, generateRecoverableSignature, generateUnrecoverableSignature } from '@aztec/foundation/crypto/secp256k1-signer';
+import { InterruptError, TimeoutError } from '@aztec/foundation/error';
 import { filter } from '@aztec/foundation/iterator';
 import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
-import { sleep, sleepUntil } from '@aztec/foundation/sleep';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
 import { isErrorClass, unfreeze } from '@aztec/foundation/types';
-import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
-import { getPreviousCheckpointOutHashes, validateCheckpoint } from '@aztec/stdlib/checkpoint';
-import { computeQuorum, getSlotStartBuildTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners, MaliciousYParityCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { buildCheckpointSimulationOverridesPlan, getPreviousCheckpointOutHashes, validateCheckpoint } from '@aztec/stdlib/checkpoint';
+import { computeQuorum, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import { InsufficientValidTxsError } from '@aztec/stdlib/interfaces/server';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
@@ -455,25 +456,24 @@ import { orderAttestations, trimAttestations } from '@aztec/stdlib/p2p';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, trackSpan } from '@aztec/telemetry-client';
 import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
-import { buildCheckpointSimulationOverridesPlan } from './chain_state_overrides.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError } from './errors.js';
 import { SequencerState } from './utils.js';
 /** How much time to sleep while waiting for min transactions to accumulate for a block */ const TXS_POLLING_MS = 500;
+const ARCHIVER_SYNC_POLLING_MS = 200;
 _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('CheckpointProposalJob.proposeCheckpoint', function() {
     return {
         // nullish operator needed for tests
         [Attributes.COINBASE]: this.validatorClient.getCoinbaseForAttestor(this.attestorAddress)?.toString(),
         [Attributes.SLOT_NUMBER]: this.targetSlot
     };
-}), _dec2 = trackSpan('CheckpointProposalJob.buildBlocksForCheckpoint'), _dec3 = trackSpan('CheckpointProposalJob.waitUntilNextSubslot'), _dec4 = trackSpan('CheckpointProposalJob.buildSingleBlock'), _dec5 = trackSpan('CheckpointProposalJob.waitForMinTxs'), _dec6 = trackSpan('CheckpointProposalJob.waitForAttestations'), _dec7 = trackSpan('CheckpointProposalJob.waitUntilTimeInSlot');
+}), _dec2 = trackSpan('CheckpointProposalJob.buildBlocksForCheckpoint'), _dec3 = trackSpan('CheckpointProposalJob.waitUntilNextSubslot'), _dec4 = trackSpan('CheckpointProposalJob.buildSingleBlock'), _dec5 = trackSpan('CheckpointProposalJob.waitForMinTxs'), _dec6 = trackSpan('CheckpointProposalJob.waitForAttestations');
 /**
  * Handles the execution of a checkpoint proposal after the initial preparation phase.
  * This includes building blocks, collecting attestations, and publishing the checkpoint to L1,
  * as well as enqueueing votes for slashing and governance proposals. This class is created from
  * the Sequencer once the check for being the proposer for the slot has succeeded.
  */ export class CheckpointProposalJob {
-    slotNow;
     targetSlot;
     targetEpoch;
     checkpointNumber;
@@ -501,6 +501,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
     metrics;
     checkpointMetrics;
     eventEmitter;
+    pendingRequests;
     setStateFn;
     tracer;
     proposedCheckpointData;
@@ -540,17 +541,13 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 _dec6,
                 2,
                 "waitForAttestations"
-            ],
-            [
-                _dec7,
-                2,
-                "waitUntilTimeInSlot"
             ]
         ], []));
     }
     log;
     checkpointEventLog;
-    /** Tracks the fire-and-forget L1 submission promise so it can be awaited during shutdown. */ pendingL1Submission;
+    interruptibleSleep;
+    interrupted;
     /**
    * Chain state overrides built once per slot in proposeCheckpoint after the checkpoint is
    * complete. Carries the pending parent override (archive + slot + fee header) for pipelining,
@@ -560,9 +557,10 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
     getSignatureContext() {
         return this.signatureContext;
     }
-    constructor(slotNow, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, // TODO(palla/mbps): Can we remove the proposer in favor of attestorAddress? Need to check fisherman-node flows.
-    proposer, publisher, attestorAddress, invalidateCheckpoint, validatorClient, globalsBuilder, p2pClient, worldState, l1ToL2MessageSource, l2BlockSource, checkpointsBuilder, blockSink, l1Constants, signatureContext, config, timetable, slasherClient, epochCache, dateProvider, metrics, checkpointMetrics, eventEmitter, setStateFn, tracer, bindings, proposedCheckpointData){
-        this.slotNow = slotNow;
+    constructor(targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, // TODO(palla/mbps): Can we remove the proposer in favor of attestorAddress? Need to check fisherman-node flows.
+    proposer, publisher, attestorAddress, invalidateCheckpoint, validatorClient, globalsBuilder, p2pClient, worldState, l1ToL2MessageSource, l2BlockSource, checkpointsBuilder, blockSink, l1Constants, signatureContext, config, timetable, slasherClient, epochCache, dateProvider, metrics, checkpointMetrics, eventEmitter, // Shared with the owning sequencer, which drains it during shutdown; the fire-and-forget L1
+    // submission this job backgrounds is tracked here rather than in a job-local tracker.
+    pendingRequests, setStateFn, tracer, bindings, proposedCheckpointData){
         this.targetSlot = targetSlot;
         this.targetEpoch = targetEpoch;
         this.checkpointNumber = checkpointNumber;
@@ -590,22 +588,54 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         this.metrics = metrics;
         this.checkpointMetrics = checkpointMetrics;
         this.eventEmitter = eventEmitter;
+        this.pendingRequests = pendingRequests;
         this.setStateFn = setStateFn;
         this.tracer = tracer;
         this.proposedCheckpointData = proposedCheckpointData;
-        _initProto(this);
+        this.interruptibleSleep = (_initProto(this), new InterruptibleSleep());
+        this.interrupted = false;
         this.log = createLogger('sequencer:checkpoint-proposal', {
             ...bindings,
-            instanceId: `slot-${this.slotNow}`
+            instanceId: `slot-${this.getBuildSlot()}`
         });
         this.checkpointEventLog = createLogger('sequencer:checkpoint-events', {
             ...bindings,
-            instanceId: `slot-${this.slotNow}`
+            instanceId: `slot-${this.getBuildSlot()}`
         });
     }
-    /** Awaits the pending L1 submission if one is in progress. Call during shutdown. */ async awaitPendingSubmission() {
-        this.log.info('Awaiting pending L1 payload submission');
-        await this.pendingL1Submission;
+    /**
+   * The wall-clock slot during which this job builds, i.e. the slot one before {@link targetSlot} under
+   * proposer pipelining. Also the slot of the parent checkpoint this job builds on top of.
+   */ getBuildSlot() {
+        return SlotNumber(this.targetSlot - PROPOSER_PIPELINING_SLOT_OFFSET);
+    }
+    /**
+   * Sets the sequencer state for this job, reporting the target slot the checkpoint is being proposed for
+   * (not the wall-clock build slot). The slot is informational on the event payload/metrics; the job knows
+   * its own target slot, so callers only pass the state.
+   */ setState(state) {
+        this.setStateFn(state, this.targetSlot);
+    }
+    /** Interrupts job-owned waits, including the publisher's send-at-slot sleep, so shutdown can finish. */ interrupt() {
+        this.interrupted = true;
+        this.interruptibleSleep.interrupt(true);
+        this.publisher.interrupt();
+    }
+    async awaitInterruptibleSleep(ms) {
+        if (this.interrupted) {
+            throw new SequencerInterruptedError();
+        }
+        if (ms <= 0) {
+            return;
+        }
+        try {
+            await this.interruptibleSleep.sleep(ms);
+        } catch (err) {
+            if (err instanceof InterruptError) {
+                throw new SequencerInterruptedError();
+            }
+            throw err;
+        }
     }
     logCheckpointEvent(eventName, message, fields) {
         this.checkpointEventLog.debug(message, {
@@ -636,7 +666,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             // signature verification to fail silently inside Multicall3. Delay submission to the
             // start of `targetSlot` so the tx mines in the slot the vote was signed for.
             if (!this.config.fishermanMode) {
-                this.pendingL1Submission = this.publisher.sendRequestsAt(this.targetSlot).then(()=>{});
+                this.pendingRequests.trackRequest(this.publisher.sendRequestsAt(this.targetSlot), ()=>this.interrupt());
             }
             return undefined;
         }
@@ -648,32 +678,30 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             return checkpoint;
         }
         // Background the attestation → signing → L1 pipeline so the work loop is unblocked
-        this.pendingL1Submission = this.waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises);
+        this.pendingRequests.trackRequest(this.waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises), ()=>this.interrupt());
         // Return the built checkpoint immediately — the work loop is now unblocked
         return checkpoint;
     }
     /**
    * Background pipeline: collects attestations, signs them, enqueues the checkpoint, and submits to L1.
-   * Runs as a fire-and-forget task stored in `pendingL1Submission` so the work loop is unblocked.
+   * Runs as a fire-and-forget task tracked in the sequencer's shared tracker so the work loop is unblocked.
    */ async waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises) {
         const { checkpoint } = broadcast;
-        const isPipelining = this.epochCache.isProposerPipeliningEnabled();
         try {
             // Wait for all votes actions, enqueued at the beginning, to resolve
             await Promise.all(votesPromises);
             // Try to collect attestations from the committee
             const signedAttestations = await this.getSignedCommitteeAttestations(broadcast);
-            // If pipelining, wait for the previous checkpoint to land on L1 before submitting,
-            // so we can check it matches the proposed checkpoint we used as parent, and has valid attestations.
-            if (signedAttestations && (!isPipelining || await this.waitForValidParentCheckpointOnL1())) {
+            // Wait for the previous checkpoint to land on L1 before submitting, so we can check it
+            // matches the proposed checkpoint we used as parent, and has valid attestations.
+            if (signedAttestations && await this.waitForValidParentCheckpointOnL1()) {
                 await this.enqueueCheckpointForSubmission({
                     checkpoint,
                     ...signedAttestations
                 });
             }
             // If we failed to collect attestations, at least check if we need to issue an invalidation
-            // Note that if we are not pipelining, we enqueued the invalidation at the beginning
-            if (!signedAttestations && isPipelining && await this.waitForSyncedL2SlotNumber(this.slotNow)) {
+            if (!signedAttestations && await this.waitForSyncedL2SlotNumber(this.getBuildSlot())) {
                 const validationStatus = await this.l2BlockSource.getPendingChainValidationStatus();
                 if (!validationStatus.valid) {
                     this.log.warn(`Checkpoint ${validationStatus.checkpoint.checkpointNumber} has invalid attestations, enqueuing invalidation in spite of attestation collection failure`, {
@@ -722,9 +750,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                     ...l1Response,
                     slot: this.targetSlot
                 });
-                if (isPipelining) {
-                    this.metrics.recordPipelineDiscard();
-                }
+                this.metrics.recordPipelineDiscard();
             }
         } catch (err) {
             if (err instanceof SequencerInterruptedError) {
@@ -743,17 +769,20 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             this.eventEmitter.emit('checkpoint-publish-failed', {
                 slot: this.targetSlot
             });
-            if (isPipelining) {
-                this.metrics.recordPipelineDiscard();
-            }
+            this.metrics.recordPipelineDiscard();
         }
     }
     /** Enqueues the checkpoint for L1 submission. Called after pipeline sleep in execute(). */ async enqueueCheckpointForSubmission(result) {
         const { checkpoint, attestations, attestationsSignature } = result;
-        this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.targetSlot);
-        const aztecSlotDuration = this.l1Constants.slotDuration;
-        const submissionSlotStart = Number(getTimestampForSlot(this.targetSlot, this.l1Constants));
-        const txTimeoutAt = new Date((submissionSlotStart + aztecSlotDuration) * 1000);
+        this.setState(SequencerState.PUBLISHING_CHECKPOINT);
+        // Latest L1 block the propose can still land in for the target slot: the last Ethereum block inside
+        // the target slot (`target_slot_start + S - E`). This is one ethereum slot later than
+        // `attestation_deadline` (= last_ethereum_block_in_target_slot - E), which bounds when validators must
+        // have signed, not when the proposer must have sent. Using the attestation deadline here is too tight:
+        // attestations are collected up to (and, when not enforcing, past) it, so the propose tx would be
+        // enqueued already expired and time out before it can mine.
+        const lastL1BlockInTargetSlot = Number(getTimestampForSlot(this.targetSlot, this.l1Constants)) + this.l1Constants.slotDuration - this.l1Constants.ethereumSlotDuration;
+        const txTimeoutAt = new Date(lastL1BlockInTargetSlot * 1000);
         // If we have been configured to potentially skip publishing checkpoint then roll the dice here
         if (this.config.skipPublishingCheckpointsPercent !== undefined && this.config.skipPublishingCheckpointsPercent > 0) {
             const roll = Math.max(0, randomInt(100));
@@ -776,11 +805,21 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         const syncDelayTolerance = this.l1Constants.ethereumSlotDuration * 2 * 1000;
         const timeoutSeconds = Math.max(0.1, (targetSlotEndMs + syncDelayTolerance - this.dateProvider.now()) / 1000);
         try {
-            return await retryUntil(async ()=>{
+            const timer = new Timer();
+            while(true){
                 const syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
-                return syncedSlot !== undefined && syncedSlot >= waitForSlot;
-            }, `archiver sync past slot ${waitForSlot}`, timeoutSeconds, 0.2);
-        } catch  {
+                if (syncedSlot !== undefined && syncedSlot >= waitForSlot) {
+                    return true;
+                }
+                if (timeoutSeconds && timer.s() > timeoutSeconds) {
+                    throw new TimeoutError(`Timeout awaiting archiver sync past slot ${waitForSlot}`);
+                }
+                await this.awaitInterruptibleSleep(ARCHIVER_SYNC_POLLING_MS);
+            }
+        } catch (err) {
+            if (err instanceof SequencerInterruptedError) {
+                throw err;
+            }
             this.log.warn(`Archiver did not sync L1 past slot ${waitForSlot} before slot ${this.targetSlot} expired, discarding pipelined work`, {
                 checkpointNumber: this.checkpointNumber
             });
@@ -802,8 +841,8 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             return true;
         }
         const parentCheckpointNumber = CheckpointNumber(this.checkpointNumber - 1);
-        // Wait until archiver has synced L1 past the parent's slot (slotNow)
-        if (!await this.waitForSyncedL2SlotNumber(this.slotNow)) {
+        // Wait until archiver has synced L1 past the parent's slot (the build slot, one before targetSlot)
+        if (!await this.waitForSyncedL2SlotNumber(this.getBuildSlot())) {
             return false;
         }
         const tips = await this.l2BlockSource.getL2Tips();
@@ -896,11 +935,11 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             };
             try {
                 const now = this.dateProvider.now();
-                if (this.epochCache.isProposerPipeliningEnabled() && this.proposedCheckpointData) {
+                if (this.proposedCheckpointData) {
                     // Measure against the wall-clock slot whose build window we are currently using.
                     // In pipelining mode `targetSlot` is intentionally one slot ahead, which makes the
                     // target-slot boundary a full slot away from the actual build start time.
-                    const slotBoundaryMs = Number(getTimestampForSlot(this.slotNow, this.l1Constants)) * 1000;
+                    const slotBoundaryMs = Number(getTimestampForSlot(this.getBuildSlot(), this.l1Constants)) * 1000;
                     this.checkpointMetrics.recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(now - slotBoundaryMs);
                 }
                 this.checkpointMetrics.startCheckpointTiming(now);
@@ -908,13 +947,12 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 const coinbase = this.validatorClient.getCoinbaseForAttestor(this.attestorAddress);
                 const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(this.attestorAddress);
                 // Start the checkpoint
-                this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.targetSlot);
+                this.setState(SequencerState.INITIALIZING_CHECKPOINT);
                 this.logCheckpointEvent('slot-started', `Starting checkpoint proposal for slot ${this.targetSlot}`, {
-                    buildSlot: this.slotNow,
+                    buildSlot: this.getBuildSlot(),
                     submissionSlot: this.targetSlot,
                     slot: this.targetSlot,
                     checkpointNumber: this.checkpointNumber,
-                    pipelining: this.epochCache.isProposerPipeliningEnabled(),
                     proposer: this.proposer?.toString(),
                     attestorAddress: this.attestorAddress.toString(),
                     publisherAddress: this.publisher.getSenderAddress().toString(),
@@ -929,10 +967,9 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 // pending/archive/fee-header to "as if the proposed parent had landed", so both the
                 // mana-min-fee simulation (in the globals builder) and the pre-broadcast
                 // validateBlockHeader see the chain tip the eventual L1 send will see.
-                const isPipelining = this.epochCache.isProposerPipeliningEnabled();
                 this.checkpointSimulationOverridesPlan = await buildCheckpointSimulationOverridesPlan({
                     checkpointNumber: this.checkpointNumber,
-                    proposedCheckpointData: isPipelining ? this.proposedCheckpointData : undefined,
+                    proposedCheckpointData: this.proposedCheckpointData,
                     invalidateToPendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
                     checkpointedCheckpointNumber: this.checkpointedCheckpointNumber,
                     rollup: this.publisher.rollupContract,
@@ -953,7 +990,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                     epoch: this.targetEpoch,
                     checkpointNumber: this.checkpointNumber,
                     l1Constants: this.epochCache.getL1Constants(),
-                    pipeliningEnabled: this.epochCache.isProposerPipeliningEnabled(),
+                    pipeliningEnabled: true,
                     proposedCheckpointData: this.proposedCheckpointData,
                     log: this.log
                 });
@@ -1028,7 +1065,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 }
                 // Assemble and broadcast the checkpoint proposal, including the last block that was not
                 // broadcasted yet, and wait to collect the committee attestations.
-                this.setStateFn(SequencerState.ASSEMBLING_CHECKPOINT, this.targetSlot);
+                this.setState(SequencerState.ASSEMBLING_CHECKPOINT);
                 const checkpoint = await checkpointBuilder.completeCheckpoint();
                 // Final validation: per-block limits are only checked if the operator set them explicitly.
                 // Otherwise, checkpoint-level budgets were already enforced by the redistribution logic.
@@ -1048,7 +1085,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                         reason: 'invalid_checkpoint',
                         checkpoint: checkpoint.header.toInspect()
                     });
-                    this.log.error(`Built an invalid checkpoint at slot ${this.slotNow} (skipping proposal)`, err, {
+                    this.log.error(`Built an invalid checkpoint at slot ${this.targetSlot} (skipping proposal)`, err, {
                         slot: this.targetSlot,
                         checkpointNumber: this.checkpointNumber,
                         blocksBuilt: blocksInCheckpoint.length,
@@ -1061,7 +1098,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 this.checkpointMetrics.recordCheckpointBuild(checkpointBuildTimer.ms(), blocksInCheckpoint.length, checkpoint.getStats().txCount, Number(checkpoint.header.totalManaUsed.toBigInt()));
                 this.logCheckpointEvent('built', `Checkpoint built for slot ${this.targetSlot}`, {
                     slot: this.targetSlot,
-                    buildSlot: this.slotNow,
+                    buildSlot: this.getBuildSlot(),
                     checkpointNumber: this.checkpointNumber,
                     proposer: this.proposer?.toString(),
                     attestorAddress: this.attestorAddress.toString(),
@@ -1166,13 +1203,13 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 });
                 break;
             }
-            const secondsIntoSlot = this.getSecondsIntoSlot();
-            const timingInfo = this.timetable.canStartNextBlock(secondsIntoSlot);
+            const nowSeconds = this.dateProvider.now() / 1000;
+            const timingInfo = this.timetable.selectNextSubslot(this.targetSlot, nowSeconds);
             if (!timingInfo.canStart) {
                 this.log.debug(`Not enough time left in slot to start another block`, {
                     slot: this.targetSlot,
                     blocksBuilt,
-                    secondsIntoSlot
+                    nowSeconds
                 });
                 break;
             }
@@ -1181,16 +1218,15 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 blockTimestamp: timestamp,
                 // Create an empty block if we haven't already and this is the last one
                 forceCreate: timingInfo.isLastBlock && blocksBuilt === 0 && this.config.buildCheckpointIfEmpty,
-                // Build deadline is only set if we are enforcing the timetable
-                buildDeadline: timingInfo.deadline ? new Date((this.getSlotStartBuildTimestamp() + timingInfo.deadline) * 1000) : undefined,
+                buildDeadline: new Date(timingInfo.deadline * 1000),
                 blockNumber,
                 indexWithinCheckpoint,
                 txHashesAlreadyIncluded
             });
             // If we failed to build the block due to insufficient txs, we try again if there is still time left in the slot
             if ('failure' in buildResult) {
-                // If this was the last subslot, or we're running with a single block per slot, we're done
-                if (timingInfo.isLastBlock || timingInfo.deadline === undefined) {
+                // If this was the last subslot, we're done.
+                if (timingInfo.isLastBlock) {
                     break;
                 }
                 // Otherwise, if there is still time for more blocks, we wait until the next subslot and try again
@@ -1259,12 +1295,15 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         }
         return this.validatorClient.createBlockProposal(block.header, this.checkpointNumber, block.indexWithinCheckpoint, inHash, block.archive.root, usedTxs, this.proposer, blockProposalOptions);
     }
-    /** Sleeps until it is time to produce the next block in the slot */ async waitUntilNextSubslot(nextSubslotStart) {
-        this.setStateFn(SequencerState.WAITING_UNTIL_NEXT_BLOCK, this.targetSlot);
-        this.log.verbose(`Waiting until time for the next block at ${nextSubslotStart}s into slot`, {
+    /**
+   * Sleeps until it is time to produce the next block in the slot.
+   * @param nextSubslotStart - Absolute wall-clock timestamp in seconds of the previous sub-slot deadline.
+   */ async waitUntilNextSubslot(nextSubslotStart) {
+        this.setState(SequencerState.WAITING_UNTIL_NEXT_BLOCK);
+        this.log.verbose(`Waiting until time for the next block at ${nextSubslotStart}s`, {
             slot: this.targetSlot
         });
-        await this.waitUntilTimeInSlot(nextSubslotStart);
+        await this.awaitInterruptibleSleep(Math.max(0, nextSubslotStart * 1000 - this.dateProvider.now()));
     }
     /** Builds a single block. Called from the main block building loop. */ async buildSingleBlock(checkpointBuilder, opts) {
         const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } = opts;
@@ -1274,7 +1313,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         });
         try {
             // Wait until we have enough txs to build the block
-            const { availableTxs, canStartBuilding, minTxs } = await this.waitForMinTxs(opts);
+            const { canStartBuilding, minTxs } = await this.waitForMinTxs(opts);
             if (!canStartBuilding) {
                 this.logCheckpointEvent('block-build-failed', `Block build failed for slot ${this.targetSlot}`, {
                     reason: 'insufficient_txs',
@@ -1282,21 +1321,18 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                     slot: this.targetSlot,
                     checkpointNumber: this.checkpointNumber,
                     indexWithinCheckpoint,
-                    availableTxs,
                     minTxs
                 });
-                this.log.warn(`Not enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot} (got ${availableTxs} txs but needs ${minTxs})`, {
+                this.log.verbose(`Not enough age-eligible txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot} (needs ${minTxs} eligible)`, {
                     reason: 'insufficient_txs',
                     blockNumber,
                     slot: this.targetSlot,
                     checkpointNumber: this.checkpointNumber,
                     indexWithinCheckpoint,
-                    availableTxs,
                     minTxs
                 });
                 this.eventEmitter.emit('block-tx-count-check-failed', {
                     minTxs,
-                    availableTxs,
                     slot: this.targetSlot
                 });
                 this.metrics.recordBlockProposalFailed('insufficient_txs');
@@ -1306,13 +1342,17 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             }
             // Create iterator to pending txs. We filter out txs already included in previous blocks in the checkpoint
             // just in case p2p failed to sync the provisional block and didn't get to remove those txs from the mempool yet.
-            const pendingTxs = filter(this.p2pClient.iterateEligiblePendingTxs(), (tx)=>!txHashesAlreadyIncluded.has(tx.txHash.toString()));
-            this.log.debug(`Building block ${blockNumber} at index ${indexWithinCheckpoint} for slot ${this.targetSlot} with ${availableTxs} available txs`, {
+            // Block building only executes txs, so we skip loading their proofs unless these same tx objects get attached
+            // to the broadcasted proposals via publishTxsWithProposals.
+            const pendingTxs = filter(this.p2pClient.iterateEligiblePendingTxs({
+                includeProof: !!this.config.publishTxsWithProposals
+            }), (tx)=>!txHashesAlreadyIncluded.has(tx.txHash.toString()));
+            this.log.debug(`Building block ${blockNumber} at index ${indexWithinCheckpoint} for slot ${this.targetSlot}`, {
                 slot: this.targetSlot,
                 blockNumber,
                 indexWithinCheckpoint
             });
-            this.setStateFn(SequencerState.CREATING_BLOCK, this.targetSlot);
+            this.setState(SequencerState.CREATING_BLOCK);
             // Per-block limits are operator overrides (from SEQ_MAX_L2_BLOCK_GAS etc.) further capped
             // by remaining checkpoint-level budgets inside CheckpointBuilder before each block is built.
             // minValidTxs is passed into the builder so it can reject the block *before* updating state.
@@ -1323,8 +1363,9 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 deadline: buildDeadline,
                 isBuildingProposal: true,
                 minValidTxs,
-                maxBlocksPerCheckpoint: this.timetable.maxNumberOfBlocks,
-                perBlockAllocationMultiplier: this.config.perBlockAllocationMultiplier
+                maxBlocksPerCheckpoint: this.timetable.getMaxBlocksPerCheckpoint(),
+                perBlockAllocationMultiplier: this.config.perBlockAllocationMultiplier,
+                perBlockDAAllocationMultiplier: this.config.perBlockDAAllocationMultiplier
             };
             // Actually build the block by executing txs. The builder throws InsufficientValidTxsError
             // if the number of successfully processed txs is below minValidTxs, ensuring state is not
@@ -1385,7 +1426,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 checkpointNumber: this.checkpointNumber,
                 indexWithinCheckpoint: block.indexWithinCheckpoint,
                 slot: this.targetSlot,
-                buildSlot: this.slotNow
+                buildSlot: this.getBuildSlot()
             });
             this.metrics.recordBuiltBlock(blockBuildDuration, block.header.totalManaUsed.toNumberUnsafe(), this.targetSlot);
             return {
@@ -1441,38 +1482,37 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
         // We only allow a block with 0 txs in the first block of the checkpoint
         const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
-        // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
-        const startBuildingDeadline = buildDeadline ? new Date(buildDeadline.getTime() - this.timetable.minExecutionTime * 1000) : undefined;
-        let availableTxs = await this.p2pClient.getPendingTxCount();
-        while(!forceCreate && availableTxs < minTxs){
+        // Latest time to keep waiting for txs: wait_for_txs_deadline = block_build_deadline(k) - min_block_duration.
+        const startBuildingDeadline = buildDeadline ? new Date(buildDeadline.getTime() - this.timetable.minBlockDuration * 1000) : undefined;
+        // Gate on age-eligible txs so we don't start building on txs the builder would then filter out for being
+        // too fresh. hasEligiblePendingTxs early-exits once minTxs are eligible instead of counting the whole pool.
+        while(!forceCreate && !await this.p2pClient.hasEligiblePendingTxs(minTxs)){
             // If we're past deadline, or we have no deadline, give up
             const now = this.dateProvider.nowAsDate();
             if (startBuildingDeadline === undefined || now >= startBuildingDeadline) {
                 return {
                     canStartBuilding: false,
-                    availableTxs,
                     minTxs
                 };
             }
             // Wait a bit before checking again
-            this.setStateFn(SequencerState.WAITING_FOR_TXS, this.targetSlot);
-            this.log.verbose(`Waiting for enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot} (have ${availableTxs} but need ${minTxs})`, {
+            this.setState(SequencerState.WAITING_FOR_TXS);
+            this.log.verbose(`Waiting for ${minTxs} age-eligible txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot}`, {
                 blockNumber,
                 slot: this.targetSlot,
-                indexWithinCheckpoint
+                indexWithinCheckpoint,
+                minTxs
             });
             await this.waitForTxsPollingInterval();
-            availableTxs = await this.p2pClient.getPendingTxCount();
         }
         return {
             canStartBuilding: true,
-            availableTxs,
             minTxs
         };
     }
     async getSignedCommitteeAttestations(broadcast) {
         const { proposal, blockProposedAt } = broadcast;
-        this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.targetSlot);
+        this.setState(SequencerState.COLLECTING_ATTESTATIONS);
         const attestations = await this.waitForAttestations(proposal);
         if (!attestations) {
             return undefined;
@@ -1523,9 +1563,10 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             });
             return new CommitteeAttestationsAndSigners(orderAttestations(attestations ?? [], committee), this.getSignatureContext());
         }
-        const attestationTimeAllowed = this.config.enforceTimeTable ? this.timetable.getCheckpointAttestationDeadline() : this.l1Constants.slotDuration;
-        const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
-        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
+        // Hard attestation-collection cutoff = the single consensus attestation_deadline (target_slot_start + S - 2E).
+        const attestationDeadlineSeconds = this.timetable.getAttestationDeadline(this.targetSlot);
+        const attestationDeadline = new Date(attestationDeadlineSeconds * 1000);
+        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, Math.max(0, attestationDeadline.getTime() - this.dateProvider.now()));
         const collectAttestationsTimer = new Timer();
         let collectedAttestationsCount = 0;
         try {
@@ -1543,7 +1584,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
                 submittedCount: trimmed.length
             });
             // Manipulate the attestations if we've been configured to do so
-            if (this.config.injectFakeAttestation || this.config.injectHighSValueAttestation || this.config.injectUnrecoverableSignatureAttestation || this.config.shuffleAttestationOrdering) {
+            if (this.config.injectFakeAttestation || this.config.injectHighSValueAttestation || this.config.injectUnrecoverableSignatureAttestation || this.config.injectYParityAttestation || this.config.shuffleAttestationOrdering) {
                 return this.manipulateAttestations(proposal.slotNumber, epoch, seed, committee, sorted);
             }
             return new CommitteeAttestationsAndSigners(sorted, this.getSignatureContext());
@@ -1615,6 +1656,14 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
             }
             return new CommitteeAttestationsAndSigners(attestations, this.getSignatureContext());
         }
+        if (this.config.injectYParityAttestation) {
+            // Force every non-proposer signed slot's recovery byte to yParity (v ∈ {0, 1}) form in the packed L1
+            // tuple, after packAttestations has canonicalized it. The proposer's own slot is left canonical so
+            // propose() still passes verifyProposer. Models a malicious proposer landing a checkpoint L1 accepts
+            // but that can never be proven (ECDSA.recover rejects v ∉ {27, 28}).
+            this.log.warn(`Injecting yParity attestations in checkpoint for slot ${slotNumber} (proposer #${proposerIndex})`);
+            return new MaliciousYParityCommitteeAttestationsAndSigners(attestations, proposerIndex, this.getSignatureContext());
+        }
         if (this.config.shuffleAttestationOrdering) {
             this.log.warn(`Shuffling attestation ordering in checkpoint for slot ${slotNumber} (proposer #${proposerIndex})`);
             const shuffled = [
@@ -1650,7 +1699,15 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         }
         const failedTxData = failedTxs.map((fail)=>fail.tx);
         const failedTxHashes = failedTxData.map((tx)=>tx.getTxHash());
-        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+        const failures = failedTxs.map((fail)=>({
+                txHash: fail.tx.getTxHash().toString(),
+                reason: fail.error.message
+            }));
+        this.log.warn(`Dropping ${failedTxs.length} txs from mempool due to failures during block building for slot ${this.targetSlot}`, {
+            slot: this.targetSlot,
+            checkpointNumber: this.checkpointNumber,
+            failures
+        });
         await this.p2pClient.handleFailedExecution(failedTxHashes);
     }
     /**
@@ -1680,8 +1737,7 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
    * tip advances locally. Gossip doesn't echo our own messages back, so without this the proposer
    * would never see its own proposed checkpoint and couldn't pipeline the next slot.
    *
-   * Only runs under proposer pipelining (the proposed tip is a pipelining-only concept) and is
-   * skipped whenever proposed blocks aren't pushed (`skipPushProposedBlocksToArchiver`, fisherman
+   * Skipped whenever proposed blocks aren't pushed (`skipPushProposedBlocksToArchiver`, fisherman
    * mode): the archiver derives the checkpoint archive from its stored blocks, so without them the
    * push would fail. All blocks were already added (and awaited) during block building, so this
    * needs no retry — they are guaranteed present by the time we get here.
@@ -1689,9 +1745,6 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         if (this.config.skipPushProposedBlocksToArchiver || this.config.fishermanMode) {
             return;
         }
-        if (!this.epochCache.isProposerPipeliningEnabled()) {
-            return;
-        }
         const startBlock = BlockNumber(this.syncedToBlockNumber + 1);
         this.log.debug(`Syncing proposed checkpoint ${this.checkpointNumber} to archiver`, {
             checkpointNumber: this.checkpointNumber,
@@ -1747,20 +1800,8 @@ _dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('Checkpoint
         }
         return false;
     }
-    /** Waits until a specific time within the current slot */ async waitUntilTimeInSlot(targetSecondsIntoSlot) {
-        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
-        const targetTimestamp = slotStartTimestamp + targetSecondsIntoSlot;
-        await sleepUntil(new Date(targetTimestamp * 1000), this.dateProvider.nowAsDate());
-    }
     /** Waits the polling interval for transactions. Extracted for test overriding. */ async waitForTxsPollingInterval() {
-        await sleep(TXS_POLLING_MS);
-    }
-    getSlotStartBuildTimestamp() {
-        return getSlotStartBuildTimestamp(this.slotNow, this.l1Constants);
-    }
-    getSecondsIntoSlot() {
-        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
-        return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
+        await this.awaitInterruptibleSleep(TXS_POLLING_MS);
     }
     getPublisher() {
         return this.publisher;