@aztec/archiver 4.0.0-nightly.20260115 → 4.0.0-nightly.20260117

package/src/modules/data_store_updater.ts

@@ -1,4 +1,4 @@
-import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import {
@@ -32,6 +32,14 @@ enum Operation {
   Delete,
 }
 
+/** Result of adding checkpoints with information about any pruned blocks. */
+type ReconcileCheckpointsResult = {
+  /** Blocks that were pruned due to conflict with L1 checkpoints. */
+  prunedBlocks: L2BlockNew[] | undefined;
+  /** Last block number that was already inserted locally, or undefined if none. */
+  lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
+};
+
 /** Archiver helper module to handle updates to the data store. */
 export class ArchiverDataStoreUpdater {
   private readonly log = createLogger('archiver:store_updater');
@@ -47,10 +55,7 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */
-  public addBlocksWithContractData(
-    blocks: L2BlockNew[],
-    pendingChainValidationStatus?: ValidateCheckpointResult,
-  ): Promise<boolean> {
+  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
     return this.store.transactionAsync(async () => {
       await this.store.addBlocks(blocks);
 
@@ -68,32 +73,136 @@ export class ArchiverDataStoreUpdater {
   }
 
   /**
+   * Reconciles local blocks with incoming checkpoints from L1.
    * Adds checkpoints to the store with contract class/instance extraction from logs.
+   * Prunes any local blocks that conflict with checkpoint data (by comparing archive roots).
    * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
    * and individually broadcasted functions from the checkpoint block logs.
    *
    * @param checkpoints - The published checkpoints to add.
    * @param pendingChainValidationStatus - Optional validation status to set.
-   * @returns True if the operation is successful.
+   * @returns Result with information about any pruned blocks.
    */
-  public addCheckpointsWithContractData(
+  public setNewCheckpointData(
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
-  ): Promise<boolean> {
+  ): Promise<ReconcileCheckpointsResult> {
     return this.store.transactionAsync(async () => {
+      // Before adding checkpoints, check for conflicts with local blocks if any
+      const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
+
       await this.store.addCheckpoints(checkpoints);
-      const allBlocks = checkpoints.flatMap((ch: PublishedCheckpoint) => ch.checkpoint.blocks);
 
-      const opResults = await Promise.all([
+      // Filter out blocks that were already inserted via addBlocks() to avoid duplicating logs/contract data
+      const newBlocks = checkpoints
+        .flatMap((ch: PublishedCheckpoint) => ch.checkpoint.blocks)
+        .filter(b => lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
+
+      await Promise.all([
         // Update the pending chain validation status if provided
         pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
         // Add any logs emitted during the retrieved blocks
-        this.store.addLogs(allBlocks),
+        this.store.addLogs(newBlocks),
         // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-        ...allBlocks.map(block => this.addBlockDataToDB(block)),
+        ...newBlocks.map(block => this.addBlockDataToDB(block)),
       ]);
 
-      return opResults.every(Boolean);
+      return { prunedBlocks, lastAlreadyInsertedBlockNumber };
+    });
+  }
+
+  /**
+   * Checks for local proposed blocks that do not match the ones to be checkpointed and prunes them.
+   * This method handles multiple checkpoints but returns after pruning the first conflict found.
+   * This is correct because pruning from the first conflict point removes all subsequent blocks,
+   * and when checkpoints are added afterward, they include all the correct blocks.
+   */
+  private async pruneMismatchingLocalBlocks(checkpoints: PublishedCheckpoint[]): Promise<ReconcileCheckpointsResult> {
+    const [lastCheckpointedBlockNumber, lastBlockNumber] = await Promise.all([
+      this.store.getCheckpointedL2BlockNumber(),
+      this.store.getLatestBlockNumber(),
+    ]);
+
+    // Exit early if there are no local uncheckpointed blocks
+    if (lastBlockNumber === lastCheckpointedBlockNumber) {
+      return { prunedBlocks: undefined, lastAlreadyInsertedBlockNumber: undefined };
+    }
+
+    // Get all uncheckpointed local blocks
+    const uncheckpointedLocalBlocks = await this.store.getBlocks(
+      BlockNumber.add(lastCheckpointedBlockNumber, 1),
+      lastBlockNumber - lastCheckpointedBlockNumber,
+    );
+
+    let lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
+
+    for (const publishedCheckpoint of checkpoints) {
+      const checkpointBlocks = publishedCheckpoint.checkpoint.blocks;
+      const slot = publishedCheckpoint.checkpoint.slot;
+      const localBlocksInSlot = uncheckpointedLocalBlocks.filter(b => b.slot === slot);
+
+      if (checkpointBlocks.length === 0) {
+        this.log.warn(`Checkpoint ${publishedCheckpoint.checkpoint.number} for slot ${slot} has no blocks`);
+        continue;
+      }
+
+      // Find the first checkpoint block that conflicts with an existing local block and prune local afterwards
+      for (const checkpointBlock of checkpointBlocks) {
+        const blockNumber = checkpointBlock.number;
+        const existingBlock = localBlocksInSlot.find(b => b.number === blockNumber);
+        const blockInfos = {
+          existingBlock: existingBlock?.toBlockInfo(),
+          checkpointBlock: checkpointBlock.toBlockInfo(),
+        };
+
+        if (!existingBlock) {
+          this.log.verbose(`No local block found for checkpointed block number ${blockNumber}`, blockInfos);
+        } else if (existingBlock.archive.root.equals(checkpointBlock.archive.root)) {
+          this.log.verbose(`Block number ${blockNumber} already inserted and matches checkpoint`, blockInfos);
+          lastAlreadyInsertedBlockNumber = blockNumber;
+        } else {
+          this.log.warn(`Conflict detected at block ${blockNumber} between checkpointed and local block`, blockInfos);
+          const prunedBlocks = await this.removeBlocksAfter(BlockNumber(blockNumber - 1));
+          return { prunedBlocks, lastAlreadyInsertedBlockNumber };
+        }
+      }
+
+      // If local has more blocks than the checkpoint (e.g., local has [2,3,4] but checkpoint has [2,3]),
+      // we need to prune the extra local blocks so they match what was checkpointed
+      const lastCheckpointBlockNumber = checkpointBlocks.at(-1)!.number;
+      const lastLocalBlockNumber = localBlocksInSlot.at(-1)?.number;
+
+      if (lastLocalBlockNumber !== undefined && lastLocalBlockNumber > lastCheckpointBlockNumber) {
+        this.log.warn(
+          `Local chain for slot ${slot} ends at block ${lastLocalBlockNumber} but checkpoint ends at ${lastCheckpointBlockNumber}. Pruning blocks after block ${lastCheckpointBlockNumber}.`,
+        );
+        const prunedBlocks = await this.removeBlocksAfter(lastCheckpointBlockNumber);
+        return { prunedBlocks, lastAlreadyInsertedBlockNumber };
+      }
+    }
+
+    return { prunedBlocks: undefined, lastAlreadyInsertedBlockNumber };
+  }
+
+  /**
+   * Removes all blocks strictly after the specified block number and cleans up associated contract data.
+   * This handles removal of provisionally added blocks along with their contract classes/instances.
+   *
+   * @param blockNumber - Remove all blocks with number greater than this.
+   * @returns The removed blocks.
+   */
+  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
+    return this.store.transactionAsync(async () => {
+      // First get the blocks to be removed so we can clean up contract data
+      const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
+
+      // Clean up contract data and logs for the removed blocks
+      await Promise.all([
+        this.store.deleteLogs(removedBlocks),
+        ...removedBlocks.map(block => this.removeBlockDataFromDB(block)),
+      ]);
+
+      return removedBlocks;
     });
   }
 
@@ -106,10 +215,7 @@ export class ArchiverDataStoreUpdater {
    * @param checkpointsToUnwind - The number of checkpoints to unwind.
    * @returns True if the operation is successful.
    */
-  public async unwindCheckpointsWithContractData(
-    from: CheckpointNumber,
-    checkpointsToUnwind: number,
-  ): Promise<boolean> {
+  public async unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
     if (checkpointsToUnwind <= 0) {
       throw new Error(`Cannot unwind ${checkpointsToUnwind} blocks`);
     }
@@ -132,22 +238,8 @@ export class ArchiverDataStoreUpdater {
     const opResults = await Promise.all([
       // Prune rolls back to the last proven block, which is by definition valid
       this.store.setPendingChainValidationStatus({ valid: true }),
-      // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-      ...blocks.map(async block => {
-        const contractClassLogs = block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
-        // ContractInstancePublished event logs are broadcast in privateLogs.
-        const privateLogs = block.body.txEffects.flatMap(txEffect => txEffect.privateLogs);
-        const publicLogs = block.body.txEffects.flatMap(txEffect => txEffect.publicLogs);
-
-        return (
-          await Promise.all([
-            this.updatePublishedContractClasses(contractClassLogs, block.number, Operation.Delete),
-            this.updateDeployedContractInstances(privateLogs, block.number, Operation.Delete),
-            this.updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, Operation.Delete),
-          ])
-        ).every(Boolean);
-      }),
-
+      // Remove contract data for all blocks being unwound
+      ...blocks.map(block => this.removeBlockDataFromDB(block)),
       this.store.deleteLogs(blocks),
       this.store.unwindCheckpoints(from, checkpointsToUnwind),
     ]);
@@ -155,21 +247,30 @@ export class ArchiverDataStoreUpdater {
     return opResults.every(Boolean);
   }
 
-  /**
-   * Extracts and stores contract data from a single block.
-   */
-  private async addBlockDataToDB(block: L2BlockNew): Promise<boolean> {
+  /** Extracts and stores contract data from a single block. */
+  private addBlockDataToDB(block: L2BlockNew): Promise<boolean> {
+    return this.editContractBlockData(block, Operation.Store);
+  }
+
+  /** Removes contract data associated with a block. */
+  private removeBlockDataFromDB(block: L2BlockNew): Promise<boolean> {
+    return this.editContractBlockData(block, Operation.Delete);
+  }
+
+  /** Adds or remove contract data associated with a block. */
+  private async editContractBlockData(block: L2BlockNew, operation: Operation): Promise<boolean> {
     const contractClassLogs = block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
-    // ContractInstancePublished event logs are broadcast in privateLogs.
     const privateLogs = block.body.txEffects.flatMap(txEffect => txEffect.privateLogs);
     const publicLogs = block.body.txEffects.flatMap(txEffect => txEffect.publicLogs);
 
     return (
       await Promise.all([
-        this.updatePublishedContractClasses(contractClassLogs, block.number, Operation.Store),
-        this.updateDeployedContractInstances(privateLogs, block.number, Operation.Store),
-        this.updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, Operation.Store),
-        this.storeBroadcastedIndividualFunctions(contractClassLogs, block.number),
+        this.updatePublishedContractClasses(contractClassLogs, block.number, operation),
+        this.updateDeployedContractInstances(privateLogs, block.number, operation),
+        this.updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, operation),
+        operation === Operation.Store
+          ? this.storeBroadcastedIndividualFunctions(contractClassLogs, block.number)
+          : Promise.resolve(true),
       ])
     ).every(Boolean);
   }

package/src/modules/l1_synchronizer.ts

@@ -16,7 +16,7 @@ import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { isDefined } from '@aztec/foundation/types';
 import { type ArchiverEmitter, L2BlockSourceEvents, type ValidateCheckpointResult } from '@aztec/stdlib/block';
 import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { type L1RollupConstants, getEpochAtSlot, getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { type Traceable, type Tracer, execInSpan, trackSpan } from '@aztec/telemetry-client';
 
@@ -49,6 +49,7 @@ type RollupStatus = {
  */
 export class ArchiverL1Synchronizer implements Traceable {
   private l1BlockNumber: bigint | undefined;
+  private l1BlockHash: Buffer32 | undefined;
   private l1Timestamp: bigint | undefined;
 
   private readonly updater: ArchiverDataStoreUpdater;
@@ -64,7 +65,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       'registryAddress' | 'governanceProposerAddress' | 'slashFactoryAddress'
     > & { slashingProposerAddress: EthAddress },
     private readonly store: KVArchiverDataStore,
-    private readonly config: {
+    private config: {
       batchSize: number;
       skipValidateCheckpointAttestations?: boolean;
       maxAllowedEthClientDriftSeconds: number;
@@ -73,7 +74,7 @@ export class ArchiverL1Synchronizer implements Traceable {
     private readonly epochCache: EpochCache,
     private readonly dateProvider: DateProvider,
     private readonly instrumentation: ArchiverInstrumentation,
-    private readonly l1constants: L1RollupConstants & { l1StartBlockHash: Buffer32; genesisArchiveRoot: Fr },
+    private readonly l1Constants: L1RollupConstants & { l1StartBlockHash: Buffer32; genesisArchiveRoot: Fr },
     private readonly events: ArchiverEmitter,
     tracer: Tracer,
     private readonly log: Logger = createLogger('archiver:l1-sync'),
@@ -82,6 +83,15 @@ export class ArchiverL1Synchronizer implements Traceable {
     this.tracer = tracer;
   }
 
+  /** Sets new config */
+  public setConfig(newConfig: {
+    batchSize: number;
+    skipValidateCheckpointAttestations?: boolean;
+    maxAllowedEthClientDriftSeconds: number;
+  }) {
+    this.config = newConfig;
+  }
+
   /** Returns the last L1 block number that was synced. */
   public getL1BlockNumber(): bigint | undefined {
     return this.l1BlockNumber;
@@ -109,27 +119,36 @@ export class ArchiverL1Synchronizer implements Traceable {
 
   @trackSpan('Archiver.syncFromL1')
   public async syncFromL1(initialSyncComplete: boolean): Promise<void> {
-    /**
-     * We keep track of three "pointers" to L1 blocks:
-     * 1. the last L1 block that published an L2 block
-     * 2. the last L1 block that added L1 to L2 messages
-     * 3. the last L1 block that cancelled L1 to L2 messages
-     *
-     * We do this to deal with L1 data providers that are eventually consistent (e.g. Infura).
-     * We guard against seeing block X with no data at one point, and later, the provider processes the block and it has data.
-     * The archiver will stay back, until there's data on L1 that will move the pointers forward.
-     */
-    const { l1StartBlock, l1StartBlockHash } = this.l1constants;
-    const {
-      blocksSynchedTo = l1StartBlock,
-      messagesSynchedTo = { l1BlockNumber: l1StartBlock, l1BlockHash: l1StartBlockHash },
-    } = await this.store.getSynchPoint();
-
     const currentL1Block = await this.publicClient.getBlock({ includeTransactions: false });
     const currentL1BlockNumber = currentL1Block.number;
     const currentL1BlockHash = Buffer32.fromString(currentL1Block.hash);
+    const currentL1Timestamp = currentL1Block.timestamp;
 
-    this.log.trace(`Starting new archiver sync iteration`, {
+    if (this.l1BlockHash && currentL1BlockHash.equals(this.l1BlockHash)) {
+      this.log.trace(`No new L1 blocks since last sync at L1 block ${this.l1BlockNumber}`);
+      return;
+    }
+
+    // Warn if the latest L1 block timestamp is too old
+    const maxAllowedDelay = this.config.maxAllowedEthClientDriftSeconds;
+    const now = this.dateProvider.nowInSeconds();
+    if (maxAllowedDelay > 0 && Number(currentL1Timestamp) <= now - maxAllowedDelay) {
+      this.log.warn(
+        `Latest L1 block ${currentL1BlockNumber} timestamp ${currentL1Timestamp} is too old. Make sure your Ethereum node is synced.`,
+        { currentL1BlockNumber, currentL1Timestamp, now, maxAllowedDelay },
+      );
+    }
+
+    // Load sync point for blocks and messages defaulting to start block
+    const {
+      blocksSynchedTo = this.l1Constants.l1StartBlock,
+      messagesSynchedTo = {
+        l1BlockNumber: this.l1Constants.l1StartBlock,
+        l1BlockHash: this.l1Constants.l1StartBlockHash,
+      },
+    } = await this.store.getSynchPoint();
+
+    this.log.debug(`Starting new archiver sync iteration`, {
       blocksSynchedTo,
       messagesSynchedTo,
       currentL1BlockNumber,
@@ -156,29 +175,17 @@ export class ArchiverL1Synchronizer implements Traceable {
      */
 
     // ********** Events that are processed per L1 block **********
-    await this.handleL1ToL2Messages(messagesSynchedTo, currentL1BlockNumber, currentL1BlockHash);
-
-    // Get L1 timestamp for the current block
-    const currentL1Timestamp =
-      !this.l1Timestamp || !this.l1BlockNumber || this.l1BlockNumber !== currentL1BlockNumber
-        ? (await this.publicClient.getBlock({ blockNumber: currentL1BlockNumber })).timestamp
-        : this.l1Timestamp;
-
-    // Warn if the latest L1 block timestamp is too old
-    const maxAllowedDelay = this.config.maxAllowedEthClientDriftSeconds;
-    const now = this.dateProvider.nowInSeconds();
-    if (maxAllowedDelay > 0 && Number(currentL1Timestamp) <= now - maxAllowedDelay) {
-      this.log.warn(
-        `Latest L1 block ${currentL1BlockNumber} timestamp ${currentL1Timestamp} is too old. Make sure your Ethereum node is synced.`,
-        { currentL1BlockNumber, currentL1Timestamp, now, maxAllowedDelay },
-      );
-    }
+    await this.handleL1ToL2Messages(messagesSynchedTo, currentL1BlockNumber);
 
     // ********** Events that are processed per checkpoint **********
     if (currentL1BlockNumber > blocksSynchedTo) {
       // First we retrieve new checkpoints and L2 blocks and store them in the DB. This will also update the
       // pending chain validation status, proven checkpoint number, and synched L1 block number.
       const rollupStatus = await this.handleCheckpoints(blocksSynchedTo, currentL1BlockNumber, initialSyncComplete);
+
+      // Then we try pruning uncheckpointed blocks if a new slot was mined without checkpoints
+      await this.pruneUncheckpointedBlocks(currentL1Timestamp);
+
       // Then we prune the current epoch if it'd reorg on next submission.
       // Note that we don't do this before retrieving checkpoints because we may need to retrieve
       // checkpoints from more than 2 epochs ago, so we want to make sure we have the latest view of
@@ -213,18 +220,59 @@ export class ArchiverL1Synchronizer implements Traceable {
     // but the corresponding blocks have not been processed (see #12631).
     this.l1Timestamp = currentL1Timestamp;
     this.l1BlockNumber = currentL1BlockNumber;
+    this.l1BlockHash = currentL1BlockHash;
 
     const l1BlockNumberAtEnd = await this.publicClient.getBlockNumber();
-    this.log.trace(`Archiver sync iteration complete`, {
+    this.log.debug(`Archiver sync iteration complete`, {
       l1BlockNumberAtStart: currentL1BlockNumber,
       l1TimestampAtStart: currentL1Timestamp,
       l1BlockNumberAtEnd,
     });
   }
 
+  /** Prune all proposed local blocks that should have been checkpointed by now. */
+  private async pruneUncheckpointedBlocks(currentL1Timestamp: bigint) {
+    const [lastCheckpointedBlockNumber, lastProposedBlockNumber] = await Promise.all([
+      this.store.getCheckpointedL2BlockNumber(),
+      this.store.getLatestBlockNumber(),
+    ]);
+
+    // If there are no uncheckpointed blocks, we got nothing to do
+    if (lastProposedBlockNumber === lastCheckpointedBlockNumber) {
+      this.log.trace(`No uncheckpointed blocks to prune.`);
+      return;
+    }
+
+    // What's the slot of the first uncheckpointed block?
+    const firstUncheckpointedBlockNumber = BlockNumber(lastCheckpointedBlockNumber + 1);
+    const [firstUncheckpointedBlockHeader] = await this.store.getBlockHeaders(firstUncheckpointedBlockNumber, 1);
+    const firstUncheckpointedBlockSlot = firstUncheckpointedBlockHeader?.getSlot();
+
+    // What's the slot at the next L1 block? All blocks for slots strictly before this one should've been checkpointed by now.
+    const nextL1BlockTimestamp = currentL1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration);
+    const slotAtNextL1Block = getSlotAtTimestamp(nextL1BlockTimestamp, this.l1Constants);
+
+    // Prune provisional blocks from slots that have ended without being checkpointed
+    if (firstUncheckpointedBlockSlot !== undefined && firstUncheckpointedBlockSlot < slotAtNextL1Block) {
+      this.log.warn(
+        `Pruning blocks after block ${lastCheckpointedBlockNumber} due to slot ${firstUncheckpointedBlockSlot} not being checkpointed`,
+        { firstUncheckpointedBlockHeader: firstUncheckpointedBlockHeader.toInspect(), slotAtNextL1Block },
+      );
+      const prunedBlocks = await this.updater.removeBlocksAfter(lastCheckpointedBlockNumber);
+
+      if (prunedBlocks.length > 0) {
+        this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
+          type: L2BlockSourceEvents.L2PruneUncheckpointed,
+          slotNumber: firstUncheckpointedBlockSlot,
+          blocks: prunedBlocks,
+        });
+      }
+    }
+  }
+
   /** Queries the rollup contract on whether a prune can be executed on the immediate next L1 block. */
   private async canPrune(currentL1BlockNumber: bigint, currentL1Timestamp: bigint): Promise<boolean> {
-    const time = (currentL1Timestamp ?? 0n) + BigInt(this.l1constants.ethereumSlotDuration);
+    const time = (currentL1Timestamp ?? 0n) + BigInt(this.l1Constants.ethereumSlotDuration);
     const result = await this.rollup.canPruneAtTime(time, { blockNumber: currentL1BlockNumber });
     if (result) {
       this.log.debug(`Rollup contract allows pruning at L1 block ${currentL1BlockNumber} time ${time}`, {
@@ -257,7 +305,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       }
 
       const pruneFromSlotNumber = header.slotNumber;
-      const pruneFromEpochNumber: EpochNumber = getEpochAtSlot(pruneFromSlotNumber, this.l1constants);
+      const pruneFromEpochNumber: EpochNumber = getEpochAtSlot(pruneFromSlotNumber, this.l1Constants);
 
       const checkpointsToUnwind = localPendingCheckpointNumber - provenCheckpointNumber;
 
@@ -274,8 +322,8 @@ export class ArchiverL1Synchronizer implements Traceable {
       const newBlocks = blockPromises.filter(isDefined).flat();
 
       // Emit an event for listening services to react to the chain prune
-      this.events.emit(L2BlockSourceEvents.L2PruneDetected, {
-        type: L2BlockSourceEvents.L2PruneDetected,
+      this.events.emit(L2BlockSourceEvents.L2PruneUnproven, {
+        type: L2BlockSourceEvents.L2PruneUnproven,
         epochNumber: pruneFromEpochNumber,
         blocks: newBlocks,
       });
@@ -283,7 +331,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       this.log.debug(
         `L2 prune from ${provenCheckpointNumber + 1} to ${localPendingCheckpointNumber} will occur on next checkpoint submission.`,
       );
-      await this.updater.unwindCheckpointsWithContractData(localPendingCheckpointNumber, checkpointsToUnwind);
+      await this.updater.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
       this.log.warn(
         `Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` +
           `to ${provenCheckpointNumber} due to predicted reorg at L1 block ${currentL1BlockNumber}. ` +
@@ -299,7 +347,7 @@ export class ArchiverL1Synchronizer implements Traceable {
   }
 
   private nextRange(end: bigint, limit: bigint): [bigint, bigint] {
-    const batchSize = (this.config.batchSize * this.l1constants.slotDuration) / this.l1constants.ethereumSlotDuration;
+    const batchSize = (this.config.batchSize * this.l1Constants.slotDuration) / this.l1Constants.ethereumSlotDuration;
     const nextStart = end + 1n;
     const nextEnd = nextStart + BigInt(batchSize);
     if (nextEnd > limit) {
@@ -309,11 +357,7 @@ export class ArchiverL1Synchronizer implements Traceable {
   }
 
   @trackSpan('Archiver.handleL1ToL2Messages')
-  private async handleL1ToL2Messages(
-    messagesSyncPoint: L1BlockId,
-    currentL1BlockNumber: bigint,
-    _currentL1BlockHash: Buffer32,
-  ): Promise<void> {
+  private async handleL1ToL2Messages(messagesSyncPoint: L1BlockId, currentL1BlockNumber: bigint): Promise<void> {
     this.log.trace(`Handling L1 to L2 messages from ${messagesSyncPoint.l1BlockNumber} to ${currentL1BlockNumber}.`);
     if (currentL1BlockNumber <= messagesSyncPoint.l1BlockNumber) {
       return;
@@ -370,11 +414,8 @@ export class ArchiverL1Synchronizer implements Traceable {
 
     do {
       [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
-      this.log.trace(`Retrieving L1 to L2 messages between L1 blocks ${searchStartBlock} and ${searchEndBlock}.`);
+      this.log.trace(`Retrieving L1 to L2 messages in L1 blocks ${searchStartBlock}-${searchEndBlock}`);
       const messages = await retrieveL1ToL2Messages(this.inbox, searchStartBlock, searchEndBlock);
-      this.log.verbose(
-        `Retrieved ${messages.length} new L1 to L2 messages between L1 blocks ${searchStartBlock} and ${searchEndBlock}.`,
-      );
       const timer = new Timer();
       await this.store.addL1ToL2Messages(messages);
       const perMsg = timer.ms() / messages.length;
@@ -406,7 +447,7 @@ export class ArchiverL1Synchronizer implements Traceable {
   private async retrieveL1ToL2Message(leaf: Fr): Promise<InboxMessage | undefined> {
     const currentL1BlockNumber = await this.publicClient.getBlockNumber();
     let searchStartBlock: bigint = 0n;
-    let searchEndBlock: bigint = this.l1constants.l1StartBlock - 1n;
+    let searchEndBlock: bigint = this.l1Constants.l1StartBlock - 1n;
 
     do {
       [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
@@ -455,7 +496,7 @@ export class ArchiverL1Synchronizer implements Traceable {
     // Update the syncpoint so the loop below reprocesses the changed messages. We go to the block before
     // the last common one, so we force reprocessing it, in case new messages were added on that same L1 block
     // after the last common message.
-    const syncPointL1BlockNumber = commonMsg ? commonMsg.l1BlockNumber - 1n : this.l1constants.l1StartBlock;
+    const syncPointL1BlockNumber = commonMsg ? commonMsg.l1BlockNumber - 1n : this.l1Constants.l1StartBlock;
     const syncPointL1BlockHash = await this.getL1BlockHash(syncPointL1BlockNumber);
     messagesSyncPoint = { l1BlockNumber: syncPointL1BlockNumber, l1BlockHash: syncPointL1BlockHash };
     await this.store.setMessageSynchedL1Block(messagesSyncPoint);
@@ -545,7 +586,7 @@ export class ArchiverL1Synchronizer implements Traceable {
           await this.store.setProvenCheckpointNumber(provenCheckpointNumber);
           this.log.info(`Updated proven chain to checkpoint ${provenCheckpointNumber}`, { provenCheckpointNumber });
           const provenSlotNumber = localCheckpointForDestinationProvenCheckpointNumber.header.slotNumber;
-          const provenEpochNumber: EpochNumber = getEpochAtSlot(provenSlotNumber, this.l1constants);
+          const provenEpochNumber: EpochNumber = getEpochAtSlot(provenSlotNumber, this.l1Constants);
           const lastBlockNumberInCheckpoint =
             localCheckpointForDestinationProvenCheckpointNumber.startBlock +
             localCheckpointForDestinationProvenCheckpointNumber.numBlocks -
@@ -635,7 +676,7 @@ export class ArchiverL1Synchronizer implements Traceable {
         }
 
         const checkpointsToUnwind = localPendingCheckpointNumber - tipAfterUnwind;
-        await this.updater.unwindCheckpointsWithContractData(localPendingCheckpointNumber, checkpointsToUnwind);
+        await this.updater.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
 
         this.log.warn(
           `Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` +
@@ -695,7 +736,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       for (const published of publishedCheckpoints) {
         const validationResult = this.config.skipValidateCheckpointAttestations
           ? { valid: true as const }
-          : await validateCheckpointAttestations(published, this.epochCache, this.l1constants, this.log);
+          : await validateCheckpointAttestations(published, this.epochCache, this.l1Constants, this.log);
 
         // Only 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.
@@ -764,22 +805,42 @@ export class ArchiverL1Synchronizer implements Traceable {
       try {
         const updatedValidationResult =
           rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
-        const [processDuration] = await elapsed(() =>
-          execInSpan(this.tracer, 'Archiver.addCheckpoints', () =>
-            this.updater.addCheckpointsWithContractData(validCheckpoints, updatedValidationResult),
+        const [processDuration, result] = await elapsed(() =>
+          execInSpan(this.tracer, 'Archiver.setCheckpointData', () =>
+            this.updater.setNewCheckpointData(validCheckpoints, updatedValidationResult),
           ),
         );
         this.instrumentation.processNewBlocks(
           processDuration / validCheckpoints.length,
           validCheckpoints.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.warn(
+            `Pruned ${result.prunedBlocks.length} mismatching blocks for checkpoint ${prunedCheckpointNumber}`,
+            { prunedBlocks: result.prunedBlocks.map(b => b.toBlockInfo()), prunedSlotNumber, prunedCheckpointNumber },
+          );
+
+          // 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.store.getCheckpointData(CheckpointNumber(previousCheckpointNumber))
             : undefined;
-          const updatedL1SyncPoint = previousCheckpoint?.l1.blockNumber ?? this.l1constants.l1StartBlock;
+          const updatedL1SyncPoint = previousCheckpoint?.l1.blockNumber ?? this.l1Constants.l1StartBlock;
           await this.store.setCheckpointSynchedL1BlockNumber(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.`,