@aztec/validator-client 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/dest/proposal_handler.js

@@ -65,6 +65,7 @@ function _ts_dispose_resources(env) {
 }
 import { encodeCheckpointBlobDataFromBlocks, getBlobsPerL1Block } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import { validateFeeAssetPriceModifier } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { pick } from '@aztec/foundation/collection';
@@ -73,13 +74,31 @@ import { TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
-import { validateCheckpoint } from '@aztec/stdlib/checkpoint';
-import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { getPreviousCheckpointOutHashes, validateCheckpoint } from '@aztec/stdlib/checkpoint';
+import { getEpochAtSlot, getLastL1SlotTimestampForL2Slot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import { accumulateCheckpointOutHashes, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { ReExFailedTxsError, ReExInitialStateMismatchError, ReExStateMismatchError, ReExTimeoutError, TransactionsNotAvailableError } from '@aztec/stdlib/validators';
 import { getTelemetryClient } from '@aztec/telemetry-client';
+/**
+ * Mapping from a checkpoint-proposal validation failure reason to the tracker outcome that
+ * `handleCheckpointProposal` should record. `undefined` means do not record (signature
+ * couldn't be verified, or the checkpoint is already on L1 so the question is moot).
+ */ /* eslint-disable camelcase */ const CHECKPOINT_VALIDATION_REASON_TO_OUTCOME = {
+    invalid_signature: undefined,
+    invalid_fee_asset_price_modifier: 'invalid',
+    checkpoint_already_published: undefined,
+    last_block_not_found: 'unvalidated',
+    block_fetch_error: 'unvalidated',
+    no_blocks_for_slot: 'unvalidated',
+    last_block_archive_mismatch: 'invalid',
+    too_many_blocks_in_checkpoint: 'invalid',
+    checkpoint_header_mismatch: 'invalid',
+    archive_mismatch: 'invalid',
+    out_hash_mismatch: 'invalid',
+    checkpoint_validation_failed: 'invalid'
+};
 /** Handles block and checkpoint proposals for both validator and non-validator nodes. */ export class ProposalHandler {
     checkpointsBuilder;
     worldState;
@@ -90,14 +109,19 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
     epochCache;
     config;
     blobClient;
+    reexecutionTracker;
     metrics;
     dateProvider;
     log;
     tracer;
-    /** Cached last checkpoint validation result to avoid double-validation on validator nodes. */ lastCheckpointValidationResult;
+    /** Cached last checkpoint validation result to avoid double-validation on validator nodes.
+   *  Keyed by signed-payload hash so two proposals at the same (slot, archive) but with a
+   *  different `feeAssetPriceModifier` (or any other signed field) are validated independently. */ lastCheckpointValidationResult;
     /** Archiver reference for setting proposed checkpoints (pipelining). Set via register(). */ archiver;
     /** Returns current validator addresses for own-proposal detection. Set via register(). */ getOwnValidatorAddresses;
-    constructor(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, blobClient, metrics, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator:proposal-handler')){
+    /** P2P proposal pool access for deciding when retained proposals should block archiver processing. */ p2pClient;
+    checkpointProposalValidationFailureCallback;
+    constructor(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, blobClient, reexecutionTracker, metrics, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator:proposal-handler')){
         this.checkpointsBuilder = checkpointsBuilder;
         this.worldState = worldState;
         this.blockSource = blockSource;
@@ -107,6 +131,7 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         this.epochCache = epochCache;
         this.config = config;
         this.blobClient = blobClient;
+        this.reexecutionTracker = reexecutionTracker;
         this.metrics = metrics;
         this.dateProvider = dateProvider;
         this.log = log;
@@ -115,13 +140,37 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         }
         this.tracer = telemetry.getTracer('ProposalHandler');
     }
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    setCheckpointProposalValidationFailureCallback(callback) {
+        this.checkpointProposalValidationFailureCallback = callback;
+    }
+    /**
+   * Records the proposer's own checkpoint proposal as a `valid` outcome in the re-execution
+   * tracker. Without this, the node's own checkpoint proposals never flow through
+   * `handleCheckpointProposal` (proposers don't validate their own proposals), so its sentinel
+   * sees no outcome for slots where it was the proposer and reports itself as inactive.
+   *
+   * `archive` should be the locally-computed archive (NOT the broadcast archive, which may have
+   * been deliberately corrupted in tests via `broadcastInvalidBlockProposal` /
+   * `broadcastInvalidCheckpointProposalOnly`). Recording the local archive correctly models the
+   * proposer's own view of its own work.
+   */ recordOwnCheckpointProposalAsValid(slot, archive, checkpointNumber) {
+        this.reexecutionTracker.recordOutcome(slot, archive, 'valid', checkpointNumber);
+    }
     /**
    * Registers handlers for block and checkpoint proposals on the p2p client.
+   * Records the p2p client so validation can inspect retained proposals.
    * Block proposals are registered for non-validator nodes (validators register their own enhanced handler).
    * The all-nodes checkpoint proposal handler is always registered for validation, caching, and pipelining.
    * @param archiver - Archiver reference for setting proposed checkpoints (pipelining)
    * @param getOwnValidatorAddresses - Returns current validator addresses for own-proposal detection
    */ register(p2pClient, shouldReexecute, archiver, getOwnValidatorAddresses) {
+        this.p2pClient = p2pClient;
         this.archiver = archiver;
         this.getOwnValidatorAddresses = getOwnValidatorAddresses;
         // Non-validator handler that processes or re-executes for monitoring but does not attest.
@@ -165,19 +214,30 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                     archive: proposal.archive.toString(),
                     proposer: proposal.getSender()?.toString()
                 };
-                // For own proposals, skip validation — the proposer already built and validated the checkpoint
+                if (this.config.skipCheckpointProposalValidation) {
+                    this.log.warn(`Skipping checkpoint proposal validation for slot ${proposal.slotNumber}`, proposalInfo);
+                    return undefined;
+                }
+                if (await this.epochCache.isEscapeHatchOpenAtSlot(proposal.slotNumber)) {
+                    this.log.warn(`Escape hatch open for slot ${proposal.slotNumber}, skipping checkpoint proposal validation`, proposalInfo);
+                    return undefined;
+                }
+                // For own proposals, skip validation and return: the proposer already built and validated the
+                // checkpoint, and the sequencer's checkpoint proposal job pushed the proposed checkpoint to the
+                // archiver from local data before broadcasting. Gossipsub doesn't echo our own messages back, so
+                // this branch is normally unreachable — it remains as defense if an own proposal arrives by some
+                // other path.
                 const proposer = proposal.getSender();
                 const ownAddresses = this.getOwnValidatorAddresses?.();
                 const isOwnProposal = proposer && ownAddresses?.some((addr)=>addr === proposer.toString());
                 if (isOwnProposal) {
                     this.log.debug(`Skipping validation for own checkpoint proposal at slot ${proposal.slotNumber}`);
-                    if (this.archiver && this.epochCache.isProposerPipeliningEnabled()) {
-                        await this.setProposedCheckpointFromBlocks(proposal);
-                    }
                     return undefined;
                 }
                 const result = await this.handleCheckpointProposal(proposal, proposalInfo);
-                if (result.isValid && this.archiver && this.epochCache.isProposerPipeliningEnabled()) {
+                if (!result.isValid) {
+                    await this.checkpointProposalValidationFailureCallback?.(proposal, result, proposalInfo);
+                } else if (this.archiver) {
                     const set = await this.setProposedCheckpointFromValidation(proposal);
                     if (set) {
                         this.metrics?.recordCheckpointProposalToPipelinedStateDuration(pipeliningTimer.ms());
@@ -202,7 +262,7 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
             this.log.warn(`Received proposal with invalid signature for slot ${slotNumber}`);
             return {
                 isValid: false,
-                reason: 'invalid_proposal'
+                reason: 'invalid_signature'
             };
         }
         const proposalInfo = {
@@ -225,23 +285,22 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 reason: 'invalid_proposal'
             };
         }
-        // Ensure the block source is synced before checking for existing blocks,
-        // since a proposed checkpoint prune may remove blocks we'd otherwise find.
-        // This affects mostly the block_number_already_exists check, since a pending
-        // checkpoint prune could remove a block that would conflict with this proposal.
-        // When pipelining is enabled, the proposer builds ahead of L1 submission, so the
-        // block source won't have synced to the proposed slot yet. Skip the sync wait to
-        // avoid eating into the attestation window.
-        if (!this.epochCache.isProposerPipeliningEnabled()) {
-            const blockSourceSync = await this.waitForBlockSourceSync(slotNumber);
-            if (!blockSourceSync) {
-                this.log.warn(`Block source is not synced, skipping processing`, proposalInfo);
-                return {
-                    isValid: false,
-                    reason: 'block_source_not_synced'
-                };
-            }
+        const retainedSlotValidation = await this.validateNewBlockInSlot(proposal);
+        if (!retainedSlotValidation.isValid) {
+            this.log.info(`Block proposal conflicts with retained proposals, skipping archiver processing`, {
+                ...proposalInfo,
+                indexWithinCheckpoint: proposal.indexWithinCheckpoint,
+                reason: retainedSlotValidation.reason
+            });
+            return {
+                isValid: false,
+                blockNumber: proposal.blockNumber,
+                reason: retainedSlotValidation.reason
+            };
         }
+        // The proposer builds ahead of L1 submission under pipelining, so the block source won't have
+        // synced to the proposed slot yet. We deliberately do not wait for it to sync here, to avoid
+        // eating into the attestation window.
         // Check that the parent proposal is a block we know, otherwise reexecution would fail.
         // If we don't find it immediately, we keep retrying for a while; it may be we still
         // need to process other block proposals to get to it.
@@ -269,7 +328,9 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         const blockNumber = parentBlock === 'genesis' ? BlockNumber(INITIAL_L2_BLOCK_NUM) : BlockNumber(parentBlock.header.getBlockNumber() + 1);
         proposalInfo.blockNumber = blockNumber;
         // Check that this block number does not exist already
-        const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
+        const existingBlock = await this.blockSource.getBlockData({
+            number: blockNumber
+        });
         if (existingBlock) {
             this.log.warn(`Block number ${blockNumber} already exists, skipping processing`, proposalInfo);
             return {
@@ -284,6 +345,8 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
             pinnedPeer: proposalSender,
             deadline: this.getReexecutionDeadline(slotNumber, config)
         });
+        // Record the tx-collection outcome on the re-execution tracker
+        this.reexecutionTracker.recordTxsCollected(slotNumber, proposal.indexWithinCheckpoint, missingTxs.length === 0);
         // If reexecution is disabled, bail. We were just interested in triggering tx collection.
         if (!shouldReexecute) {
             this.log.info(`Received valid block ${blockNumber} proposal at index ${proposal.indexWithinCheckpoint} on slot ${slotNumber}`, proposalInfo);
@@ -331,9 +394,18 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 reason: 'txs_not_available'
             };
         }
-        // Collect the out hashes of all the checkpoints before this one in the same epoch
+        // Collect the out hashes of all the checkpoints before this one in the same epoch.
+        // Mirror the proposer-side fallback: under pipelining the immediately-preceding cp may not
+        // yet be on L1, in which case the helper grafts the locally-known proposed cp's outHash.
         const epoch = getEpochAtSlot(slotNumber, this.epochCache.getL1Constants());
-        const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch)).filter((c)=>c.checkpointNumber < checkpointNumber).map((c)=>c.checkpointOutHash);
+        const previousCheckpointOutHashes = await getPreviousCheckpointOutHashes({
+            blockSource: this.blockSource,
+            epoch,
+            checkpointNumber,
+            l1Constants: this.epochCache.getL1Constants(),
+            pipeliningEnabled: true,
+            log: this.log
+        });
         // Try re-executing the transactions in the proposal if needed
         let reexecutionResult;
         try {
@@ -363,6 +435,33 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
             reexecutionResult
         };
     }
+    async validateNewBlockInSlot(blockProposal) {
+        if (!this.p2pClient) {
+            return {
+                isValid: true
+            };
+        }
+        const { blockProposals, checkpointProposals } = await this.p2pClient.getProposalsForSlot(blockProposal.slotNumber);
+        if (checkpointProposals.length === 0) {
+            return {
+                isValid: true
+            };
+        } else if (checkpointProposals.length > 1) {
+            return {
+                isValid: false,
+                reason: 'checkpoint_proposal_equivocation'
+            };
+        } else {
+            const checkpointProposal = checkpointProposals[0];
+            const terminalBlock = blockProposals.find((block)=>block.archive.equals(checkpointProposal.archive));
+            return terminalBlock !== undefined && blockProposal.indexWithinCheckpoint > terminalBlock.indexWithinCheckpoint ? {
+                isValid: false,
+                reason: 'block_proposal_beyond_checkpoint'
+            } : {
+                isValid: true
+            };
+        }
+    }
     async getParentBlock(proposal) {
         const parentArchive = proposal.blockHeader.lastArchive.root;
         const config = this.checkpointsBuilder.getConfig();
@@ -374,7 +473,11 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         const currentTime = this.dateProvider.now();
         const timeoutDurationMs = deadline.getTime() - currentTime;
         try {
-            return await this.blockSource.getBlockDataByArchive(parentArchive) ?? (timeoutDurationMs <= 0 ? undefined : await retryUntil(()=>this.blockSource.syncImmediate().then(()=>this.blockSource.getBlockDataByArchive(parentArchive)), 'force archiver sync', timeoutDurationMs / 1000, 0.5));
+            return await this.blockSource.getBlockData({
+                archive: parentArchive
+            }) ?? (timeoutDurationMs <= 0 ? undefined : await retryUntil(()=>this.blockSource.syncImmediate().then(()=>this.blockSource.getBlockData({
+                        archive: parentArchive
+                    })), 'force archiver sync', timeoutDurationMs / 1000, 0.5));
         } catch (err) {
             if (err instanceof TimeoutError) {
                 this.log.debug(`Timed out getting parent block by archive root`, {
@@ -519,38 +622,10 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
     getReexecutionDeadline(slotNumber, config) {
         // Under proposer pipelining, the proposal slot may be ahead of wall clock time.
         // Reexecution budgets should still be bounded by the current slot we are in now.
-        const wallclockSlot = slotNumber - this.epochCache.pipeliningOffset();
+        const wallclockSlot = slotNumber - PROPOSER_PIPELINING_SLOT_OFFSET;
         const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(wallclockSlot + 1), config));
         return new Date(nextSlotTimestampSeconds * 1000);
     }
-    /** Waits for the block source to sync L1 data up to at least the slot before the given one. */ async waitForBlockSourceSync(slot) {
-        const deadline = this.getReexecutionDeadline(slot, this.checkpointsBuilder.getConfig());
-        const timeoutMs = deadline.getTime() - this.dateProvider.now();
-        if (slot === 0) {
-            return true;
-        }
-        // Make a quick check before triggering an archiver sync
-        // If we are pipelining and have a pending checkpoint number stored, we will allow the block proposal to be for a slot further
-        const syncedSlot = await this.blockSource.getSyncedL2SlotNumber();
-        if (syncedSlot !== undefined && syncedSlot + 1 + this.epochCache.pipeliningOffset() >= slot) {
-            return true;
-        }
-        try {
-            // Trigger an immediate sync of the block source, and wait until it reports being synced to the required slot
-            return await retryUntil(async ()=>{
-                await this.blockSource.syncImmediate();
-                const updatedSyncedSlot = await this.blockSource.getSyncedL2SlotNumber();
-                return updatedSyncedSlot !== undefined && updatedSyncedSlot + 1 >= slot;
-            }, 'wait for block source sync', timeoutMs / 1000, 0.5);
-        } catch (err) {
-            if (err instanceof TimeoutError) {
-                this.log.warn(`Timed out waiting for block source to sync to slot ${slot}`);
-                return false;
-            } else {
-                throw err;
-            }
-        }
-    }
     getReexecuteFailureReason(err) {
         if (err instanceof TransactionsNotAvailableError) {
             return 'txs_not_available';
@@ -577,7 +652,7 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
             // If we do not have all of the transactions, then we should fail
             if (txs.length !== txHashes.length) {
                 const foundTxHashes = txs.map((tx)=>tx.getTxHash());
-                const missingTxHashes = txHashes.filter((txHash)=>!foundTxHashes.includes(txHash));
+                const missingTxHashes = txHashes.filter((txHash)=>!foundTxHashes.some((h)=>h.equals(txHash)));
                 throw new TransactionsNotAvailableError(missingTxHashes);
             }
             const timer = new Timer();
@@ -673,44 +748,48 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
    * Used by both the all-nodes callback (via register) and the validator client (via delegation).
    */ async handleCheckpointProposal(proposal, proposalInfo) {
         const slot = proposal.slotNumber;
-        // Check cache: same archive+slot means we already validated this proposal
-        if (this.lastCheckpointValidationResult && this.lastCheckpointValidationResult.archive.equals(proposal.archive) && this.lastCheckpointValidationResult.slotNumber === slot) {
+        const payloadHash = proposal.getPayloadHash();
+        // Check cache: same signed-payload hash means we already validated this exact proposal.
+        if (this.lastCheckpointValidationResult && this.lastCheckpointValidationResult.payloadHash === payloadHash) {
             this.log.debug(`Returning cached validation result for checkpoint proposal at slot ${slot}`, proposalInfo);
             return this.lastCheckpointValidationResult.result;
         }
         const proposer = proposal.getSender();
+        let result;
         if (!proposer) {
             this.log.warn(`Received checkpoint proposal with invalid signature for slot ${proposal.slotNumber}`);
-            const result = {
+            result = {
                 isValid: false,
                 reason: 'invalid_signature'
             };
-            this.lastCheckpointValidationResult = {
-                archive: proposal.archive,
-                slotNumber: slot,
-                result
-            };
-            return result;
-        }
-        if (!validateFeeAssetPriceModifier(proposal.feeAssetPriceModifier)) {
+        } else if (!validateFeeAssetPriceModifier(proposal.feeAssetPriceModifier)) {
             this.log.warn(`Received checkpoint proposal with invalid feeAssetPriceModifier ${proposal.feeAssetPriceModifier} for slot ${proposal.slotNumber}`);
-            const result = {
+            result = {
                 isValid: false,
                 reason: 'invalid_fee_asset_price_modifier'
             };
-            this.lastCheckpointValidationResult = {
-                archive: proposal.archive,
-                slotNumber: slot,
-                result
-            };
-            return result;
+        } else {
+            result = await this.validateCheckpointProposal(proposal, proposalInfo);
         }
-        const result = await this.validateCheckpointProposal(proposal, proposalInfo);
         this.lastCheckpointValidationResult = {
-            archive: proposal.archive,
-            slotNumber: slot,
+            payloadHash,
             result
         };
+        // Record the outcome on the re-execution tracker.
+        const outcome = result.isValid ? 'valid' : CHECKPOINT_VALIDATION_REASON_TO_OUTCOME[result.reason];
+        if (outcome !== undefined) {
+            this.reexecutionTracker.recordOutcome(slot, proposal.archive, outcome, result.checkpointNumber);
+        }
+        // Drop tracker entries for checkpoints that have reached L1 finality.
+        try {
+            const tips = await this.blockSource.getL2Tips();
+            const finalizedCheckpointNumber = tips.finalized.checkpoint.number;
+            if (finalizedCheckpointNumber > 0) {
+                this.reexecutionTracker.removeBefore(CheckpointNumber(finalizedCheckpointNumber + 1));
+            }
+        } catch (err) {
+            this.log.error(`Error pruning reexecution tracker`, err, proposalInfo);
+        }
         // Upload blobs to filestore if validation passed (fire and forget)
         if (result.isValid) {
             this.tryUploadBlobsForCheckpoint(proposal, proposalInfo);
@@ -728,16 +807,23 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         };
         try {
             const slot = proposal.slotNumber;
-            // Timeout block syncing at the start of the next slot
-            const config = this.checkpointsBuilder.getConfig();
-            const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
-            const timeoutSeconds = Math.max(1, nextSlotTimestampSeconds - Math.floor(this.dateProvider.now() / 1000));
+            // Block-sync deadline = the L1 publish deadline, i.e. the latest moment the proposer can submit
+            // this checkpoint and still have it land on L1 in the target slot. That is 12s (one Ethereum
+            // slot) before the last L1 block of the target slot, which is later than the target-slot start
+            // used for block re-execution. Keeping validation/attestation alive until then lets validators
+            // keep attesting right up to the proposer's real publish cutoff.
+            const l1Constants = this.epochCache.getL1Constants();
+            const publishDeadlineSeconds = Number(getLastL1SlotTimestampForL2Slot(slot, l1Constants)) - l1Constants.ethereumSlotDuration;
+            const deadline = new Date(publishDeadlineSeconds * 1000);
+            const timeoutSeconds = Math.max(1, Math.floor((deadline.getTime() - this.dateProvider.now()) / 1000));
             // Wait for last block to sync by archive
-            let lastBlockHeader;
+            let lastBlockData;
             try {
-                lastBlockHeader = await retryUntil(async ()=>{
+                lastBlockData = await retryUntil(async ()=>{
                     await this.blockSource.syncImmediate();
-                    return this.blockSource.getBlockHeaderByArchive(proposal.archive);
+                    return await this.blockSource.getBlockData({
+                        archive: proposal.archive
+                    });
                 }, `waiting for block with archive ${proposal.archive.toString()} for slot ${slot}`, timeoutSeconds, 0.5);
             } catch (err) {
                 if (err instanceof TimeoutError) {
@@ -753,20 +839,36 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                     reason: 'block_fetch_error'
                 };
             }
-            if (!lastBlockHeader) {
+            if (!lastBlockData) {
                 this.log.warn(`Last block not found for checkpoint proposal`, proposalInfo);
                 return {
                     isValid: false,
                     reason: 'last_block_not_found'
                 };
             }
+            // Refuse to attest if the block's enclosing checkpoint has already been published to L1.
+            const existingCheckpoint = await this.blockSource.getCheckpointData({
+                number: lastBlockData.checkpointNumber
+            });
+            if (existingCheckpoint) {
+                this.log.warn(`Refusing to attest to checkpoint proposal whose checkpoint is already on L1`, {
+                    ...proposalInfo,
+                    checkpointNumber: lastBlockData.checkpointNumber
+                });
+                return {
+                    isValid: false,
+                    reason: 'checkpoint_already_published',
+                    checkpointNumber: lastBlockData.checkpointNumber
+                };
+            }
             // Get all full blocks for the slot and checkpoint
             const blocks = await this.blockSource.getBlocksForSlot(slot);
             if (blocks.length === 0) {
                 this.log.warn(`No blocks found for slot ${slot}`, proposalInfo);
                 return {
                     isValid: false,
-                    reason: 'no_blocks_for_slot'
+                    reason: 'no_blocks_for_slot',
+                    checkpointNumber: lastBlockData.checkpointNumber
                 };
             }
             // Ensure the last block for this slot matches the archive in the checkpoint proposal
@@ -774,7 +876,21 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 this.log.warn(`Last block archive mismatch for checkpoint proposal`, proposalInfo);
                 return {
                     isValid: false,
-                    reason: 'last_block_archive_mismatch'
+                    reason: 'last_block_archive_mismatch',
+                    checkpointNumber: lastBlockData.checkpointNumber
+                };
+            }
+            const maxBlocksPerCheckpoint = this.config.maxBlocksPerCheckpoint;
+            if (maxBlocksPerCheckpoint !== undefined && blocks.length > maxBlocksPerCheckpoint) {
+                this.log.warn(`Checkpoint proposal exceeds maxBlocksPerCheckpoint`, {
+                    ...proposalInfo,
+                    blocksInProposal: blocks.length,
+                    maxBlocksPerCheckpoint
+                });
+                return {
+                    isValid: false,
+                    reason: 'too_many_blocks_in_checkpoint',
+                    checkpointNumber: lastBlockData.checkpointNumber
                 };
             }
             this.log.debug(`Found ${blocks.length} blocks for slot ${slot}`, {
@@ -787,9 +903,17 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
             const checkpointNumber = firstBlock.checkpointNumber;
             // Get L1-to-L2 messages for this checkpoint
             const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-            // Collect the out hashes of all the checkpoints before this one in the same epoch
+            // Collect the out hashes of all the checkpoints before this one in the same epoch.
+            // See note on the analogous block-proposal site: the helper handles pipelining lag.
             const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
-            const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch)).filter((c)=>c.checkpointNumber < checkpointNumber).map((c)=>c.checkpointOutHash);
+            const previousCheckpointOutHashes = await getPreviousCheckpointOutHashes({
+                blockSource: this.blockSource,
+                epoch,
+                checkpointNumber,
+                l1Constants: this.epochCache.getL1Constants(),
+                pipeliningEnabled: true,
+                log: this.log
+            });
             // Fork world state at the block before the first block
             const parentBlockNumber = BlockNumber(firstBlock.number - 1);
             const fork = _ts_add_disposable_resource(env, await this.checkpointsBuilder.getFork(parentBlockNumber), true);
@@ -806,7 +930,8 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 });
                 return {
                     isValid: false,
-                    reason: 'checkpoint_header_mismatch'
+                    reason: 'checkpoint_header_mismatch',
+                    checkpointNumber
                 };
             }
             // Compare archive root with proposal
@@ -818,7 +943,8 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 });
                 return {
                     isValid: false,
-                    reason: 'archive_mismatch'
+                    reason: 'archive_mismatch',
+                    checkpointNumber
                 };
             }
             // Check that the accumulated epoch out hash matches the value in the proposal.
@@ -839,7 +965,8 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 });
                 return {
                     isValid: false,
-                    reason: 'out_hash_mismatch'
+                    reason: 'out_hash_mismatch',
+                    checkpointNumber
                 };
             }
             // Final round of validations on the checkpoint, just in case.
@@ -855,7 +982,8 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
                 this.log.warn(`Checkpoint validation failed: ${err}`, proposalInfo);
                 return {
                     isValid: false,
-                    reason: 'checkpoint_validation_failed'
+                    reason: 'checkpoint_validation_failed',
+                    checkpointNumber
                 };
             }
             this.log.verbose(`Checkpoint proposal validation successful for slot ${slot}`, proposalInfo);
@@ -890,7 +1018,9 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
     }
     /** Uploads blobs for a checkpoint to the filestore. */ async uploadBlobsForCheckpoint(proposal, proposalInfo) {
         try {
-            const lastBlockHeader = await this.blockSource.getBlockHeaderByArchive(proposal.archive);
+            const lastBlockHeader = (await this.blockSource.getBlockData({
+                archive: proposal.archive
+            }))?.header;
             if (!lastBlockHeader) {
                 this.log.warn(`Failed to get last block header for blob upload`, proposalInfo);
                 return;
@@ -920,14 +1050,16 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         if (!this.archiver) {
             return false;
         }
-        const blockData = await this.blockSource.getBlockDataByArchive(proposal.archive);
+        const blockData = await this.blockSource.getBlockData({
+            archive: proposal.archive
+        });
         if (!blockData) {
             this.log.debug(`Block data not found for checkpoint proposal archive, cannot set proposed checkpoint`, {
                 archive: proposal.archive.toString()
             });
             return false;
         }
-        await this.archiver.setProposedCheckpoint({
+        await this.archiver.addProposedCheckpoint({
             header: proposal.checkpointHeader,
             checkpointNumber: blockData.checkpointNumber,
             startBlock: BlockNumber(blockData.header.getBlockNumber() - blockData.indexWithinCheckpoint),
@@ -937,38 +1069,4 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
         });
         return true;
     }
-    /**
-   * Sets proposed checkpoint from blocks for own proposals (skips full validation).
-   * Retries fetching block data since the checkpoint proposal often arrives before the last block
-   * finishes re-execution.
-   */ async setProposedCheckpointFromBlocks(proposal) {
-        if (!this.archiver) {
-            return false;
-        }
-        let blockData = await this.blockSource.getBlockDataByArchive(proposal.archive);
-        if (!blockData) {
-            // The checkpoint proposal often arrives before the last block finishes re-execution.
-            // Retry until we find the data or give up at the end of the slot.
-            const nextSlot = this.epochCache.getSlotNow() + 1;
-            const timeOfNextSlot = getTimestampForSlot(SlotNumber(nextSlot), await this.archiver.getL1Constants());
-            const timeoutSeconds = Math.max(1, Number(timeOfNextSlot) - Math.floor(this.dateProvider.now() / 1000));
-            blockData = await retryUntil(()=>this.blockSource.getBlockDataByArchive(proposal.archive), 'block data for own checkpoint proposal', timeoutSeconds, 0.25).catch(()=>undefined);
-        }
-        if (blockData) {
-            await this.archiver.setProposedCheckpoint({
-                header: proposal.checkpointHeader,
-                checkpointNumber: blockData.checkpointNumber,
-                startBlock: BlockNumber(blockData.header.getBlockNumber() - blockData.indexWithinCheckpoint),
-                blockCount: blockData.indexWithinCheckpoint + 1,
-                totalManaUsed: proposal.checkpointHeader.totalManaUsed.toBigInt(),
-                feeAssetPriceModifier: proposal.feeAssetPriceModifier
-            });
-            return true;
-        } else {
-            this.log.debug(`Block data not found for own checkpoint proposal archive, cannot set proposed checkpoint`, {
-                archive: proposal.archive.toString()
-            });
-            return false;
-        }
-    }
 }