@aztec-labs/archiver 6.0.0-rc.1 → 6.0.0-rc.3

package/dest/modules/l1_synchronizer.js

@@ -391,7 +391,7 @@ import { InitialCheckpointNumberNotSequentialError } from '../errors.js';
 import { getCheckpointBlobDataFromBlobs, retrieveCheckpointCalldataFromRollup, retrievedToPublishedCheckpoint } from '../l1/data_retrieval.js';
 import { ArchiverDataStoreUpdater, blockLeafCount } from './data_store_updater.js';
 import { InboxMessageSynchronizer } from './inbox_message_synchronizer.js';
-import { validateCheckpointAttestationsFromCalldata } from './validation.js';
+import { resolveCheckpointAttestationsFromCalldata } from './validation.js';
 /** Bounded Inbox message sync passes (a recovery step each) taken within one archiver sync iteration. */ const MAX_MESSAGE_SYNC_PASSES_PER_ITERATION = 3;
 _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpochPrune'), _dec2 = trackSpan('Archiver.syncL1ToL2Messages'), _dec3 = trackSpan('Archiver.handleCheckpoints');
 /**
@@ -1059,209 +1059,246 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
                 searchStartBlock,
                 searchEndBlock
             });
-            // Check if the last checkpoint matches a local pending entry (so we can skip blob fetch).
-            // We only check the last one; if it matches, the blob fetch is skipped for that entry.
-            // TODO(palla/pipelining): We may have more than a single checkpoint to promote
-            const lastCalldataCheckpoint = calldataCheckpoints[calldataCheckpoints.length - 1];
-            const promoteResult = await this.tryBuildPublishedCheckpointFromProposed(lastCalldataCheckpoint);
-            const checkpointToPromote = promoteResult && !('diverged' in promoteResult) ? promoteResult : undefined;
-            const evictProposedFrom = promoteResult && 'diverged' in promoteResult ? promoteResult.fromCheckpointNumber : undefined;
-            // Validate attestations from CALLDATA before fetching any blobs. A checkpoint with invalid
-            // attestations (or one descending from a rejected ancestor) is rejected here without fetching its
-            // blobs, so a malformed blob does not throw during decode before the rejection path runs and
-            // stall sync. The signed consensus payload (header, archive root, fee asset price
-            // modifier) is fully available from calldata.
-            const checkpointsToIngest = [];
-            for (const calldataCheckpoint of calldataCheckpoints){
-                // Check the attestations uploaded by the publisher to L1 are correct.
-                // Rollup contract does not validate attestations to save on gas, so this
-                // falls on the nodes to verify offchain and skip those checkpoints.
-                const validationResult = this.config.skipValidateCheckpointAttestations ? {
-                    valid: true
-                } : await validateCheckpointAttestationsFromCalldata(calldataCheckpoint, this.epochCache, this.l1Constants, this.getSignatureContext(), this.log);
-                // Also skip the checkpoint if it builds on a previously-rejected ancestor. Without
-                // this, addCheckpoints would throw InitialCheckpointNumberNotSequentialError when the
-                // ancestor was skipped earlier (e.g. due to invalid attestations), the catch handler
-                // would roll back the L1 sync point, and the next iteration would re-fetch and re-throw.
-                const rejectedAncestor = await this.stores.blocks.getRejectedCheckpointByArchiveRoot(calldataCheckpoint.header.lastArchiveRoot);
-                // Update the validation result if it has changed, so we can keep track of the first invalid checkpoint
-                // in case there is a sequence of more than one invalid checkpoint, as we need to invalidate the first one.
-                // There is an exception though: if a checkpoint is invalidated and replaced with another invalid checkpoint,
-                // we need to update the validation result, since we need to be able to invalidate the new one.
-                // See test 'chain progresses if an invalid checkpoint is invalidated with an invalid one' for more info.
-                // Do not update the validation result if there is a rejected ancestor, since in that case we want to keep the
-                // original invalidation, as the new checkpoint is extending from a previous invalid one.
-                const validStatusChanged = rollupStatus.validationResult?.valid !== validationResult.valid;
-                const invalidStatusWithSameCheckpointNumber = !validationResult.valid && rollupStatus.validationResult && !rollupStatus.validationResult.valid && rollupStatus.validationResult.checkpoint.checkpointNumber === validationResult.checkpoint.checkpointNumber;
-                if (!rejectedAncestor && (validStatusChanged || invalidStatusWithSameCheckpointNumber)) {
-                    rollupStatus.validationResult = validationResult;
-                }
-                if (!validationResult.valid) {
-                    this.log.warn(`Skipping checkpoint ${calldataCheckpoint.checkpointNumber} due to invalid attestations`, {
-                        checkpointNumber: calldataCheckpoint.checkpointNumber,
-                        l1BlockNumber: calldataCheckpoint.l1.blockNumber,
-                        ...pick(validationResult, 'reason')
-                    });
-                    // Emit event for invalid checkpoint detection
-                    this.events.emit(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, {
-                        type: L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+            // Screening below records rejected checkpoints as it goes, and each such write advances the L1 sync point past
+            // the rejected checkpoint's L1 block before the batch's valid checkpoints are persisted. If anything in the batch
+            // throws before the batch is persisted, the sync point is restored to where it stood before the batch, so the
+            // next iteration processes the whole batch again instead of skipping its valid checkpoints. Once the batch is
+            // persisted the sync point is left alone: replaying it would refetch blobs for checkpoints already stored,
+            // including promoted ones this node never fetched blobs for, and stall if those blobs are unavailable.
+            const syncPointBeforeBatch = await this.stores.blocks.getSynchedL1BlockNumber();
+            let batchPersisted = false;
+            try {
+                // Decode and validate attestations from CALLDATA before fetching any blobs, so a checkpoint with invalid
+                // attestations is rejected without decoding a possibly malformed blob. Runs even when validation is
+                // disabled, since promotion and persistence need the decoded attestations.
+                const resolvedCheckpoints = await asyncPool(10, calldataCheckpoints, async (calldataCheckpoint)=>{
+                    const { attestations, validationResult } = await resolveCheckpointAttestationsFromCalldata(calldataCheckpoint, this.epochCache, this.l1Constants, this.getSignatureContext(), this.log);
+                    return {
+                        checkpoint: {
+                            ...calldataCheckpoint,
+                            attestations
+                        },
                         validationResult
-                    });
-                    // Persist a rejected-ancestor entry so any later checkpoint that builds on this one
-                    // is detected and skipped (rather than tripping the addCheckpoints consecutive-number
-                    // check and causing the sync point to roll back in a loop).
-                    await this.stores.blocks.addRejectedCheckpoint({
-                        checkpointNumber: calldataCheckpoint.checkpointNumber,
-                        archiveRoot: calldataCheckpoint.archiveRoot,
-                        parentArchiveRoot: calldataCheckpoint.header.lastArchiveRoot,
-                        slotNumber: calldataCheckpoint.header.slotNumber,
-                        l1: calldataCheckpoint.l1,
-                        reason: 'invalid-attestations'
-                    });
-                    continue;
-                }
-                if (rejectedAncestor) {
-                    const descendantInfo = {
-                        archive: calldataCheckpoint.archiveRoot,
-                        lastArchive: calldataCheckpoint.header.lastArchiveRoot,
-                        slotNumber: calldataCheckpoint.header.slotNumber,
-                        checkpointNumber: calldataCheckpoint.checkpointNumber,
-                        timestamp: calldataCheckpoint.header.timestamp
                     };
-                    this.log.warn(`Skipping checkpoint ${calldataCheckpoint.checkpointNumber} as it is a descendant of ` + `rejected checkpoint ${rejectedAncestor.checkpointNumber} (${rejectedAncestor.reason})`, {
-                        checkpointNumber: calldataCheckpoint.checkpointNumber,
-                        l1BlockNumber: calldataCheckpoint.l1.blockNumber,
-                        l1BlockHash: calldataCheckpoint.l1.blockHash,
-                        ancestorCheckpointNumber: rejectedAncestor.checkpointNumber,
-                        ancestorArchiveRoot: rejectedAncestor.archiveRoot.toString(),
-                        ancestorReason: rejectedAncestor.reason
-                    });
-                    this.events.emit(L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected, {
-                        type: L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected,
-                        checkpoint: descendantInfo,
-                        ancestorArchiveRoot: rejectedAncestor.archiveRoot,
-                        ancestorCheckpointNumber: rejectedAncestor.checkpointNumber
+                });
+                // Check if the last checkpoint matches a local pending entry (so we can skip blob fetch).
+                // We only check the last one; if it matches, the blob fetch is skipped for that entry.
+                // TODO(palla/pipelining): We may have more than a single checkpoint to promote
+                const lastCalldataCheckpoint = resolvedCheckpoints[resolvedCheckpoints.length - 1].checkpoint;
+                const promoteResult = await this.tryBuildPublishedCheckpointFromProposed(lastCalldataCheckpoint);
+                const checkpointToPromote = promoteResult && !('diverged' in promoteResult) ? promoteResult : undefined;
+                const evictProposedFrom = promoteResult && 'diverged' in promoteResult ? promoteResult.fromCheckpointNumber : undefined;
+                const checkpointsToIngest = [];
+                for (const { checkpoint: calldataCheckpoint, validationResult: resolvedValidationResult } of resolvedCheckpoints){
+                    // Check the attestations uploaded by the publisher to L1 are correct.
+                    // Rollup contract does not validate attestations to save on gas, so this
+                    // falls on the nodes to verify offchain and skip those checkpoints.
+                    const validationResult = this.config.skipValidateCheckpointAttestations ? {
+                        valid: true
+                    } : resolvedValidationResult;
+                    // Also skip the checkpoint if it builds on a previously-rejected ancestor. Without
+                    // this, addCheckpoints would throw InitialCheckpointNumberNotSequentialError when the
+                    // ancestor was skipped earlier (e.g. due to invalid attestations), the catch handler
+                    // would roll back the L1 sync point, and the next iteration would re-fetch and re-throw.
+                    const rejectedAncestor = await this.stores.blocks.getRejectedCheckpointByArchiveRoot(calldataCheckpoint.header.lastArchiveRoot);
+                    // Update the validation result if it has changed, so we can keep track of the first invalid checkpoint
+                    // in case there is a sequence of more than one invalid checkpoint, as we need to invalidate the first one.
+                    // There is an exception though: if a checkpoint is invalidated and replaced with another invalid checkpoint,
+                    // we need to update the validation result, since we need to be able to invalidate the new one.
+                    // See test 'chain progresses if an invalid checkpoint is invalidated with an invalid one' for more info.
+                    // Do not update the validation result if there is a rejected ancestor, since in that case we want to keep the
+                    // original invalidation, as the new checkpoint is extending from a previous invalid one.
+                    const validStatusChanged = rollupStatus.validationResult?.valid !== validationResult.valid;
+                    const invalidStatusWithSameCheckpointNumber = !validationResult.valid && rollupStatus.validationResult && !rollupStatus.validationResult.valid && rollupStatus.validationResult.checkpoint.checkpointNumber === validationResult.checkpoint.checkpointNumber;
+                    if (!rejectedAncestor && (validStatusChanged || invalidStatusWithSameCheckpointNumber)) {
+                        rollupStatus.validationResult = validationResult;
+                    }
+                    if (!validationResult.valid) {
+                        this.log.warn(`Skipping checkpoint ${calldataCheckpoint.checkpointNumber} due to invalid attestations`, {
+                            checkpointNumber: calldataCheckpoint.checkpointNumber,
+                            l1BlockNumber: calldataCheckpoint.l1.blockNumber,
+                            ...pick(validationResult, 'reason')
+                        });
+                        // Emit event for invalid checkpoint detection
+                        this.events.emit(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, {
+                            type: L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+                            validationResult
+                        });
+                        // Persist a rejected-ancestor entry so any later checkpoint that builds on this one
+                        // is detected and skipped (rather than tripping the addCheckpoints consecutive-number
+                        // check and causing the sync point to roll back in a loop).
+                        await this.stores.blocks.addRejectedCheckpoint({
+                            checkpointNumber: calldataCheckpoint.checkpointNumber,
+                            archiveRoot: calldataCheckpoint.archiveRoot,
+                            parentArchiveRoot: calldataCheckpoint.header.lastArchiveRoot,
+                            slotNumber: calldataCheckpoint.header.slotNumber,
+                            l1: calldataCheckpoint.l1,
+                            reason: 'invalid-attestations'
+                        });
+                        continue;
+                    }
+                    if (rejectedAncestor) {
+                        const descendantInfo = {
+                            archive: calldataCheckpoint.archiveRoot,
+                            lastArchive: calldataCheckpoint.header.lastArchiveRoot,
+                            slotNumber: calldataCheckpoint.header.slotNumber,
+                            checkpointNumber: calldataCheckpoint.checkpointNumber,
+                            timestamp: calldataCheckpoint.header.timestamp
+                        };
+                        this.log.warn(`Skipping checkpoint ${calldataCheckpoint.checkpointNumber} as it is a descendant of ` + `rejected checkpoint ${rejectedAncestor.checkpointNumber} (${rejectedAncestor.reason})`, {
+                            checkpointNumber: calldataCheckpoint.checkpointNumber,
+                            l1BlockNumber: calldataCheckpoint.l1.blockNumber,
+                            l1BlockHash: calldataCheckpoint.l1.blockHash,
+                            ancestorCheckpointNumber: rejectedAncestor.checkpointNumber,
+                            ancestorArchiveRoot: rejectedAncestor.archiveRoot.toString(),
+                            ancestorReason: rejectedAncestor.reason
+                        });
+                        this.events.emit(L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected, {
+                            type: L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected,
+                            checkpoint: descendantInfo,
+                            ancestorArchiveRoot: rejectedAncestor.archiveRoot,
+                            ancestorCheckpointNumber: rejectedAncestor.checkpointNumber
+                        });
+                        // Persist this chainpoint as rejected as well, so we can construct a chain of
+                        // skipped checkpoints starting from the first one with invalid attestations.
+                        await this.stores.blocks.addRejectedCheckpoint({
+                            checkpointNumber: calldataCheckpoint.checkpointNumber,
+                            archiveRoot: calldataCheckpoint.archiveRoot,
+                            parentArchiveRoot: calldataCheckpoint.header.lastArchiveRoot,
+                            slotNumber: calldataCheckpoint.header.slotNumber,
+                            l1: calldataCheckpoint.l1,
+                            reason: 'descends-from-invalid-attestations'
+                        });
+                        continue;
+                    }
+                    checkpointsToIngest.push(calldataCheckpoint);
+                }
+                // Fetch blobs in parallel only for the surviving (attestation-valid, non-descendant) checkpoints,
+                // then build the full published checkpoints. The last calldata checkpoint may be promotable from a
+                // local proposed block (checkpointToPromote), in which case it carries no blob to fetch. A missing or
+                // undecodable blob throws and propagates, and the batch guard restores the L1 sync point so the fetch is retried.
+                const toFetchBlobs = checkpointToPromote ? checkpointsToIngest.filter((c)=>c.checkpointNumber !== checkpointToPromote.checkpoint.number) : checkpointsToIngest;
+                const blobFetched = await asyncPool(10, toFetchBlobs, async (checkpoint)=>retrievedToPublishedCheckpoint({
+                        ...checkpoint,
+                        checkpointBlobData: await getCheckpointBlobDataFromBlobs(this.blobClient, checkpoint.l1.blockHash, checkpoint.blobHashes, checkpoint.checkpointNumber, this.log, !initialSyncComplete, checkpoint.parentBeaconBlockRoot, checkpoint.l1.timestamp)
+                    }));
+                // Index the built checkpoints by number so we can ingest them in calldata order, slotting in the
+                // promoted checkpoint (built from a local proposed block rather than blobs).
+                const publishedByNumber = new Map(blobFetched.map((publishedCheckpoint)=>[
+                        publishedCheckpoint.checkpoint.number,
+                        publishedCheckpoint
+                    ]));
+                if (checkpointToPromote) {
+                    publishedByNumber.set(checkpointToPromote.checkpoint.number, checkpointToPromote);
+                }
+                const validCheckpoints = [];
+                for (const calldataCheckpoint of checkpointsToIngest){
+                    const published = publishedByNumber.get(calldataCheckpoint.checkpointNumber);
+                    validCheckpoints.push(published);
+                    this.log.debug(`Ingesting new checkpoint ${published.checkpoint.number} with ${published.checkpoint.blocks.length} blocks`, {
+                        checkpointHash: published.checkpoint.hash(),
+                        l1BlockNumber: published.l1.blockNumber,
+                        ...published.checkpoint.header.toInspect(),
+                        blocks: published.checkpoint.blocks.map((b)=>b.getStats())
                     });
-                    // Persist this chainpoint as rejected as well, so we can construct a chain of
-                    // skipped checkpoints starting from the first one with invalid attestations.
-                    await this.stores.blocks.addRejectedCheckpoint({
-                        checkpointNumber: calldataCheckpoint.checkpointNumber,
-                        archiveRoot: calldataCheckpoint.archiveRoot,
-                        parentArchiveRoot: calldataCheckpoint.header.lastArchiveRoot,
-                        slotNumber: calldataCheckpoint.header.slotNumber,
-                        l1: calldataCheckpoint.l1,
-                        reason: 'descends-from-invalid-attestations'
+                }
+                for (const published of validCheckpoints){
+                    this.instrumentation.processCheckpointL1Timing({
+                        slotNumber: published.checkpoint.header.slotNumber,
+                        l1Timestamp: published.l1.timestamp,
+                        l1Constants: this.l1Constants
                     });
-                    continue;
                 }
-                checkpointsToIngest.push(calldataCheckpoint);
-            }
-            // Fetch blobs in parallel only for the surviving (attestation-valid, non-descendant) checkpoints,
-            // then build the full published checkpoints. The last calldata checkpoint may be promotable from a
-            // local proposed block (checkpointToPromote), in which case it carries no blob to fetch. A missing or
-            // undecodable blob throws and propagates, rolling back the L1 sync point so the fetch is retried.
-            const toFetchBlobs = checkpointToPromote ? checkpointsToIngest.filter((c)=>c.checkpointNumber !== checkpointToPromote.checkpoint.number) : checkpointsToIngest;
-            const blobFetched = await asyncPool(10, toFetchBlobs, async (checkpoint)=>retrievedToPublishedCheckpoint({
-                    ...checkpoint,
-                    checkpointBlobData: await getCheckpointBlobDataFromBlobs(this.blobClient, checkpoint.l1.blockHash, checkpoint.blobHashes, checkpoint.checkpointNumber, this.log, !initialSyncComplete, checkpoint.parentBeaconBlockRoot, checkpoint.l1.timestamp)
-                }));
-            // Index the built checkpoints by number so we can ingest them in calldata order, slotting in the
-            // promoted checkpoint (built from a local proposed block rather than blobs).
-            const publishedByNumber = new Map(blobFetched.map((publishedCheckpoint)=>[
-                    publishedCheckpoint.checkpoint.number,
-                    publishedCheckpoint
-                ]));
-            if (checkpointToPromote) {
-                publishedByNumber.set(checkpointToPromote.checkpoint.number, checkpointToPromote);
-            }
-            const validCheckpoints = [];
-            for (const calldataCheckpoint of checkpointsToIngest){
-                const published = publishedByNumber.get(calldataCheckpoint.checkpointNumber);
-                validCheckpoints.push(published);
-                this.log.debug(`Ingesting new checkpoint ${published.checkpoint.number} with ${published.checkpoint.blocks.length} blocks`, {
-                    checkpointHash: published.checkpoint.hash(),
-                    l1BlockNumber: published.l1.blockNumber,
-                    ...published.checkpoint.header.toInspect(),
-                    blocks: published.checkpoint.blocks.map((b)=>b.getStats())
-                });
-            }
-            for (const published of validCheckpoints){
-                this.instrumentation.processCheckpointL1Timing({
-                    slotNumber: published.checkpoint.header.slotNumber,
-                    l1Timestamp: published.l1.timestamp,
-                    l1Constants: this.l1Constants
-                });
-            }
-            try {
-                const updatedValidationResult = rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
-                // Split valid checkpoints: the promoted one (if any) is persisted via the proposed-promotion path,
-                // the rest via addCheckpoints. Both paths run within the same store transaction for atomicity.
-                const [[maybeValidCheckpointToPromote], checkpointsToAdd] = partition(validCheckpoints, (c)=>c.checkpoint.number === checkpointToPromote?.checkpoint.number);
-                const [processDuration, result] = await elapsed(()=>execInSpan(this.tracer, 'Archiver.addCheckpoints', ()=>this.updater.addCheckpoints(checkpointsToAdd, updatedValidationResult, maybeValidCheckpointToPromote && {
-                            l1: lastCalldataCheckpoint.l1,
-                            attestations: lastCalldataCheckpoint.attestations,
-                            verbatimAttestations: lastCalldataCheckpoint.verbatimAttestations,
-                            checkpoint: maybeValidCheckpointToPromote
-                        }, evictProposedFrom)));
-                if (validCheckpoints.length > 0) {
-                    this.instrumentation.processNewCheckpointedBlocks(processDuration / validCheckpoints.length, validCheckpoints.flatMap((c)=>c.checkpoint.blocks));
+                try {
+                    const updatedValidationResult = rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
+                    // Split valid checkpoints: the promoted one (if any) is persisted via the proposed-promotion path,
+                    // the rest via addCheckpoints. Both paths run within the same store transaction for atomicity.
+                    const [[maybeValidCheckpointToPromote], checkpointsToAdd] = partition(validCheckpoints, (c)=>c.checkpoint.number === checkpointToPromote?.checkpoint.number);
+                    const [processDuration, result] = await elapsed(()=>execInSpan(this.tracer, 'Archiver.addCheckpoints', async ()=>{
+                            const addResult = await this.updater.addCheckpoints(checkpointsToAdd, updatedValidationResult, maybeValidCheckpointToPromote && {
+                                l1: lastCalldataCheckpoint.l1,
+                                attestations: lastCalldataCheckpoint.attestations,
+                                verbatimAttestations: lastCalldataCheckpoint.verbatimAttestations,
+                                checkpoint: maybeValidCheckpointToPromote
+                            }, evictProposedFrom);
+                            // Set before the span wrappers finish, so a throw while closing the span doesn't count as unpersisted.
+                            batchPersisted = true;
+                            return addResult;
+                        }));
+                    if (validCheckpoints.length > 0) {
+                        this.instrumentation.processNewCheckpointedBlocks(processDuration / validCheckpoints.length, validCheckpoints.flatMap((c)=>c.checkpoint.blocks));
+                    }
+                    // Record blocks newly fetched from L1 checkpoint payloads as added. The promoted checkpoint (if any) is
+                    // excluded: its blocks were already in local archiver storage (added via the proposed-block path) so the
+                    // block stream does not need them re-downloaded.
+                    blocksAdded.push(...checkpointsToAdd.flatMap((c)=>c.checkpoint.blocks));
+                    // If blocks were pruned due to conflict with L1 checkpoints, emit event
+                    if (result.prunedBlocks && result.prunedBlocks.length > 0) {
+                        const prunedCheckpointNumber = result.prunedBlocks[0].checkpointNumber;
+                        const prunedSlotNumber = result.prunedBlocks[0].header.globalVariables.slotNumber;
+                        this.log.info(`Pruned ${result.prunedBlocks.length} mismatching blocks for checkpoint ${prunedCheckpointNumber}`, {
+                            prunedBlocks: result.prunedBlocks.map((b)=>b.toBlockInfo()),
+                            prunedSlotNumber,
+                            prunedCheckpointNumber
+                        });
+                        this.instrumentation.recordPrune('l1_conflict');
+                        // Emit event for listening services to react to the prune.
+                        // Note: slotNumber comes from the first pruned block. If pruned blocks theoretically spanned multiple slots,
+                        // only one slot number would be reported (though in practice all blocks in a checkpoint span a single slot).
+                        this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
+                            type: L2BlockSourceEvents.L2PruneUncheckpointed,
+                            slotNumber: prunedSlotNumber,
+                            blocks: result.prunedBlocks
+                        });
+                    }
+                } catch (err) {
+                    if (err instanceof InitialCheckpointNumberNotSequentialError) {
+                        const { previousCheckpointNumber, newCheckpointNumber } = err;
+                        const previousCheckpoint = previousCheckpointNumber ? await this.stores.blocks.getCheckpointData(CheckpointNumber(previousCheckpointNumber)) : undefined;
+                        const lastFinalizedCheckpoint = await this.stores.blocks.getCheckpointData(await this.stores.blocks.getFinalizedCheckpointNumber());
+                        const updatedL1SyncPoint = previousCheckpoint?.l1.blockNumber ?? lastFinalizedCheckpoint?.l1.blockNumber ?? this.l1Constants.l1StartBlock;
+                        await this.stores.blocks.setSynchedL1BlockNumber(updatedL1SyncPoint);
+                        this.log.warn(`Attempting to insert checkpoint ${newCheckpointNumber} with previous block ${previousCheckpointNumber}. Rolling back L1 sync point to ${updatedL1SyncPoint} to try and fetch the missing blocks.`, {
+                            previousCheckpointNumber,
+                            previousCheckpoint: previousCheckpoint?.header.toInspect(),
+                            lastFinalizedCheckpoint: lastFinalizedCheckpoint?.header.toInspect(),
+                            l1StartBlock: this.l1Constants.l1StartBlock,
+                            newCheckpointNumber,
+                            updatedL1SyncPoint
+                        });
+                    }
+                    throw err;
                 }
-                // Record blocks newly fetched from L1 checkpoint payloads as added. The promoted checkpoint (if any) is
-                // excluded: its blocks were already in local archiver storage (added via the proposed-block path) so the
-                // block stream does not need them re-downloaded.
-                blocksAdded.push(...checkpointsToAdd.flatMap((c)=>c.checkpoint.blocks));
-                // If blocks were pruned due to conflict with L1 checkpoints, emit event
-                if (result.prunedBlocks && result.prunedBlocks.length > 0) {
-                    const prunedCheckpointNumber = result.prunedBlocks[0].checkpointNumber;
-                    const prunedSlotNumber = result.prunedBlocks[0].header.globalVariables.slotNumber;
-                    this.log.info(`Pruned ${result.prunedBlocks.length} mismatching blocks for checkpoint ${prunedCheckpointNumber}`, {
-                        prunedBlocks: result.prunedBlocks.map((b)=>b.toBlockInfo()),
-                        prunedSlotNumber,
-                        prunedCheckpointNumber
-                    });
-                    this.instrumentation.recordPrune('l1_conflict');
-                    // Emit event for listening services to react to the prune.
-                    // Note: slotNumber comes from the first pruned block. If pruned blocks theoretically spanned multiple slots,
-                    // only one slot number would be reported (though in practice all blocks in a checkpoint span a single slot).
-                    this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
-                        type: L2BlockSourceEvents.L2PruneUncheckpointed,
-                        slotNumber: prunedSlotNumber,
-                        blocks: result.prunedBlocks
+                for (const checkpoint of validCheckpoints){
+                    this.log.info(`Downloaded checkpoint ${checkpoint.checkpoint.number}`, {
+                        checkpointHash: checkpoint.checkpoint.hash(),
+                        checkpointNumber: checkpoint.checkpoint.number,
+                        blockCount: checkpoint.checkpoint.blocks.length,
+                        txCount: checkpoint.checkpoint.blocks.reduce((acc, b)=>acc + b.body.txEffects.length, 0),
+                        header: checkpoint.checkpoint.header.toInspect(),
+                        archiveRoot: checkpoint.checkpoint.archive.root.toString(),
+                        archiveNextLeafIndex: checkpoint.checkpoint.archive.nextAvailableLeafIndex
                     });
                 }
+                lastRetrievedCheckpoint = validCheckpoints.at(-1) ?? lastRetrievedCheckpoint;
+                // The last checkpoint seen on L1 this batch (valid or rejected), tracked from calldata since
+                // rejected checkpoints are no longer built into PublishedCheckpoints.
+                lastSeenCheckpoint = lastCalldataCheckpoint;
             } catch (err) {
-                if (err instanceof InitialCheckpointNumberNotSequentialError) {
-                    const { previousCheckpointNumber, newCheckpointNumber } = err;
-                    const previousCheckpoint = previousCheckpointNumber ? await this.stores.blocks.getCheckpointData(CheckpointNumber(previousCheckpointNumber)) : undefined;
-                    const lastFinalizedCheckpoint = await this.stores.blocks.getCheckpointData(await this.stores.blocks.getFinalizedCheckpointNumber());
-                    const updatedL1SyncPoint = previousCheckpoint?.l1.blockNumber ?? lastFinalizedCheckpoint?.l1.blockNumber ?? this.l1Constants.l1StartBlock;
-                    await this.stores.blocks.setSynchedL1BlockNumber(updatedL1SyncPoint);
-                    this.log.warn(`Attempting to insert checkpoint ${newCheckpointNumber} with previous block ${previousCheckpointNumber}. Rolling back L1 sync point to ${updatedL1SyncPoint} to try and fetch the missing blocks.`, {
-                        previousCheckpointNumber,
-                        previousCheckpoint: previousCheckpoint?.header.toInspect(),
-                        lastFinalizedCheckpoint: lastFinalizedCheckpoint?.header.toInspect(),
-                        l1StartBlock: this.l1Constants.l1StartBlock,
-                        newCheckpointNumber,
-                        updatedL1SyncPoint
+                const restoreTo = syncPointBeforeBatch ?? this.l1Constants.l1StartBlock;
+                const currentSyncPoint = await this.stores.blocks.getSynchedL1BlockNumber();
+                // Only ever lower it, so a deeper rewind made while handling the error (e.g. on a checkpoint gap) is kept.
+                if (!batchPersisted && currentSyncPoint !== undefined && currentSyncPoint > restoreTo) {
+                    this.log.warn(`Restoring L1 sync point to ${restoreTo} after failing to process checkpoints`, {
+                        currentSyncPoint,
+                        restoreTo,
+                        searchStartBlock,
+                        searchEndBlock
                     });
+                    await this.stores.blocks.setSynchedL1BlockNumber(restoreTo);
                 }
                 throw err;
             }
-            for (const checkpoint of validCheckpoints){
-                this.log.info(`Downloaded checkpoint ${checkpoint.checkpoint.number}`, {
-                    checkpointHash: checkpoint.checkpoint.hash(),
-                    checkpointNumber: checkpoint.checkpoint.number,
-                    blockCount: checkpoint.checkpoint.blocks.length,
-                    txCount: checkpoint.checkpoint.blocks.reduce((acc, b)=>acc + b.body.txEffects.length, 0),
-                    header: checkpoint.checkpoint.header.toInspect(),
-                    archiveRoot: checkpoint.checkpoint.archive.root.toString(),
-                    archiveNextLeafIndex: checkpoint.checkpoint.archive.nextAvailableLeafIndex
-                });
-            }
-            lastRetrievedCheckpoint = validCheckpoints.at(-1) ?? lastRetrievedCheckpoint;
-            // The last checkpoint seen on L1 this batch (valid or rejected), tracked from calldata since
-            // rejected checkpoints are no longer built into PublishedCheckpoints.
-            lastSeenCheckpoint = lastCalldataCheckpoint;
         }while (searchEndBlock < currentL1BlockNumber)
         // Important that we update AFTER inserting the blocks.
         await this.updateProvenCheckpoint(rollupStatus.provenCheckpointNumber, provenArchive);

package/dest/modules/validation.d.ts

@@ -3,7 +3,7 @@ import type { ViemCommitteeAttestations } from '@aztec-labs/ethereum/contracts';
 import { type CheckpointNumber } from '@aztec-labs/foundation/branded-types';
 import type { Fr } from '@aztec-labs/foundation/curves/bn254';
 import type { Logger } from '@aztec-labs/foundation/log';
-import { type AttestationInfo, type CommitteeAttestation, type ValidateCheckpointResult } from '@aztec-labs/stdlib/block';
+import { type AttestationInfo, CommitteeAttestation, type ValidateCheckpointResult } from '@aztec-labs/stdlib/block';
 import type { CheckpointInfo, PublishedCheckpoint } from '@aztec-labs/stdlib/checkpoint';
 import { type L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
 import { ConsensusPayload, type CoordinationSignatureContext } from '@aztec-labs/stdlib/p2p';
@@ -20,21 +20,27 @@ export type CalldataCheckpointForAttestations = {
     archiveRoot: Fr;
     feeAssetPriceModifier: bigint;
     header: CheckpointHeader;
-    attestations: CommitteeAttestation[];
     /** The exact packed attestations tuple from L1 calldata, carried verbatim for byte-faithful invalidation. */
     verbatimAttestations: ViemCommitteeAttestations;
 };
+/** A checkpoint's attestations decoded for its epoch committee, and their validation result. */
+export type ResolvedCheckpointAttestations = {
+    /** Empty if the epoch has an open escape hatch or no committee. */
+    attestations: CommitteeAttestation[];
+    validationResult: ValidateCheckpointResult;
+};
 /**
- * Validates the attestations of a checkpoint from L1 calldata only, without fetching or decoding its blobs.
- * The signed consensus payload (header, archive root, fee asset price modifier) is fully available from
- * calldata, so an invalid-attestation checkpoint can be rejected before any (possibly malformed) blob is
- * fetched and decoded.
+ * Decodes and validates the attestations of a checkpoint from L1 calldata only, so an invalid checkpoint can be
+ * rejected before its blobs are fetched. The tuple is decoded against the epoch's committee size, and not at all
+ * during an escape hatch, where the proposer may post an arbitrary tuple.
+ *
+ * @throws CheckpointAttestationsDecodeError if the tuple does not decode for the epoch committee.
  */
-export declare function validateCheckpointAttestationsFromCalldata(checkpoint: CalldataCheckpointForAttestations, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, signatureContext: CoordinationSignatureContext, logger?: Logger): Promise<ValidateCheckpointResult>;
+export declare function resolveCheckpointAttestationsFromCalldata(checkpoint: CalldataCheckpointForAttestations, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, signatureContext: CoordinationSignatureContext, logger?: Logger): Promise<ResolvedCheckpointAttestations>;
 /**
  * Core attestation validation over a consensus payload, its attestations, and checkpoint metadata --
  * independent of whether the checkpoint's blocks have been decoded from blobs. Returns true if the
  * attestations are valid and sufficient, false otherwise.
  */
 export declare function validateAttestations(payload: ConsensusPayload, attestations: CommitteeAttestation[], verbatimAttestations: ViemCommitteeAttestations, checkpointInfo: CheckpointInfo, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateCheckpointResult>;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZXMvdmFsaWRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMxRCxPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFlLE1BQU0sc0NBQXNDLENBQUM7QUFFMUYsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFOUQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDekQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUNwQixvQkFBb0IsRUFFcEIsS0FBSyx3QkFBd0IsRUFFOUIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RixPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBaUMsTUFBTSxrQ0FBa0MsQ0FBQztBQUN6RyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyw0QkFBNEIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzdGLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFJbEUsWUFBWSxFQUFFLHdCQUF3QixFQUFFLENBQUM7QUFFekM7OztHQUdHO0FBQ0gsd0JBQWdCLHlDQUF5QyxDQUN2RCxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsRUFBRSxtQkFBbUIsRUFDakQsZ0JBQWdCLEVBQUUsNEJBQTRCLEdBQzdDLGVBQWUsRUFBRSxDQUduQjtBQUVELDhGQUE4RjtBQUM5RixNQUFNLE1BQU0saUNBQWlDLEdBQUc7SUFDOUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsV0FBVyxFQUFFLEVBQUUsQ0FBQztJQUNoQixxQkFBcUIsRUFBRSxNQUFNLENBQUM7SUFDOUIsTUFBTSxFQUFFLGdCQUFnQixDQUFDO0lBQ3pCLDZHQUE2RztJQUM3RyxvQkFBb0IsRUFBRSx5QkFBeUIsQ0FBQztDQUNqRCxDQUFDO0FBRUYsZ0dBQWdHO0FBQ2hHLE1BQU0sTUFBTSw4QkFBOEIsR0FBRztJQUMzQyxtRUFBbUU7SUFDbkUsWUFBWSxFQUFFLG9CQUFvQixFQUFFLENBQUM7SUFDckMsZ0JBQWdCLEVBQUUsd0JBQXdCLENBQUM7Q0FDNUMsQ0FBQztBQUVGOzs7Ozs7R0FNRztBQUNILHdCQUFzQix5Q0FBeUMsQ0FDN0QsVUFBVSxFQUFFLGlDQUFpQyxFQUM3QyxVQUFVLEVBQUUsVUFBVSxFQUN0QixTQUFTLEVBQUUsSUFBSSxDQUFDLGlCQUFpQixFQUFFLGVBQWUsQ0FBQyxFQUNuRCxnQkFBZ0IsRUFBRSw0QkFBNEIsRUFDOUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxHQUNkLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQyxDQWtEekM7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQXNCLG9CQUFvQixDQUN4QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQ3pCLFlBQVksRUFBRSxvQkFBb0IsRUFBRSxFQUNwQyxvQkFBb0IsRUFBRSx5QkFBeUIsRUFDL0MsY0FBYyxFQUFFLGNBQWMsRUFDOUIsVUFBVSxFQUFFLFVBQVUsRUFDdEIsU0FBUyxFQUFFLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxlQUFlLENBQUMsRUFDbkQsTUFBTSxDQUFDLEVBQUUsTUFBTSxHQUNkLE9BQU8sQ0FBQyx3QkFBd0IsQ0FBQyxDQTJCbkMifQ==

package/dest/modules/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,sCAAsC,CAAC;AAE1F,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAEzB,KAAK,wBAAwB,EAE9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,KAAK,iBAAiB,EAAiC,MAAM,kCAAkC,CAAC;AACzG,OAAO,EAAE,gBAAgB,EAAE,KAAK,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CACvD,EAAE,UAAU,EAAE,YAAY,EAAE,EAAE,mBAAmB,EACjD,gBAAgB,EAAE,4BAA4B,GAC7C,eAAe,EAAE,CAGnB;AAED,8FAA8F;AAC9F,MAAM,MAAM,iCAAiC,GAAG;IAC9C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,WAAW,EAAE,EAAE,CAAC;IAChB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,6GAA6G;IAC7G,oBAAoB,EAAE,yBAAyB,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACxD,UAAU,EAAE,iCAAiC,EAC7C,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,gBAAgB,EAAE,4BAA4B,EAC9C,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CAuBnC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,gBAAgB,EACzB,YAAY,EAAE,oBAAoB,EAAE,EACpC,oBAAoB,EAAE,yBAAyB,EAC/C,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA4FnC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,sCAAsC,CAAC;AAE1F,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,KAAK,eAAe,EACpB,oBAAoB,EAEpB,KAAK,wBAAwB,EAE9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,KAAK,iBAAiB,EAAiC,MAAM,kCAAkC,CAAC;AACzG,OAAO,EAAE,gBAAgB,EAAE,KAAK,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAIlE,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CACvD,EAAE,UAAU,EAAE,YAAY,EAAE,EAAE,mBAAmB,EACjD,gBAAgB,EAAE,4BAA4B,GAC7C,eAAe,EAAE,CAGnB;AAED,8FAA8F;AAC9F,MAAM,MAAM,iCAAiC,GAAG;IAC9C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,WAAW,EAAE,EAAE,CAAC;IAChB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,6GAA6G;IAC7G,oBAAoB,EAAE,yBAAyB,CAAC;CACjD,CAAC;AAEF,gGAAgG;AAChG,MAAM,MAAM,8BAA8B,GAAG;IAC3C,mEAAmE;IACnE,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,gBAAgB,EAAE,wBAAwB,CAAC;CAC5C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,yCAAyC,CAC7D,UAAU,EAAE,iCAAiC,EAC7C,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,gBAAgB,EAAE,4BAA4B,EAC9C,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,8BAA8B,CAAC,CAkDzC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,gBAAgB,EACzB,YAAY,EAAE,oBAAoB,EAAE,EACpC,oBAAoB,EAAE,yBAAyB,EAC/C,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA2BnC"}