@aztec/archiver 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/config.ts

@@ -8,12 +8,7 @@ import {
   getConfigFromMappings,
   numberConfigHelper,
 } from '@aztec/foundation/config';
-import {
-  type ChainConfig,
-  type PipelineConfig,
-  chainConfigMappings,
-  pipelineConfigMappings,
-} from '@aztec/stdlib/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
 
 /**
@@ -26,13 +21,11 @@ import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
 export type ArchiverConfig = ArchiverSpecificConfig &
   L1ReaderConfig &
   L1ContractsConfig &
-  PipelineConfig & // required to pass through to epoch cache
   BlobClientConfig &
   ChainConfig;
 
 export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   ...blobClientConfigMapping,
-  ...pipelineConfigMappings,
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',

package/src/errors.ts

@@ -74,36 +74,6 @@ export class BlockAlreadyCheckpointedError extends Error {
   }
 }
 
-/** Thrown when logs are added for a tag whose last stored log has a higher block number than the new log. */
-export class OutOfOrderLogInsertionError extends Error {
-  constructor(
-    public readonly logType: 'private' | 'public',
-    public readonly tag: string,
-    public readonly lastBlockNumber: number,
-    public readonly newBlockNumber: number,
-  ) {
-    super(
-      `Out-of-order ${logType} log insertion for tag ${tag}: ` +
-        `last existing log is from block ${lastBlockNumber} but new log is from block ${newBlockNumber}`,
-    );
-    this.name = 'OutOfOrderLogInsertionError';
-  }
-}
-
-/** Thrown when L1 to L2 messages are requested for a checkpoint whose message tree hasn't been sealed yet. */
-export class L1ToL2MessagesNotReadyError extends Error {
-  constructor(
-    public readonly checkpointNumber: number,
-    public readonly inboxTreeInProgress: bigint,
-  ) {
-    super(
-      `Cannot get L1 to L2 messages for checkpoint ${checkpointNumber}: ` +
-        `inbox tree in progress is ${inboxTreeInProgress}, messages not yet sealed`,
-    );
-    this.name = 'L1ToL2MessagesNotReadyError';
-  }
-}
-
 /** Thrown when a proposed block conflicts with an already checkpointed block (different content). */
 export class CannotOverwriteCheckpointedBlockError extends Error {
   constructor(

package/src/factory.ts

@@ -8,13 +8,13 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { merge } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { DateProvider } from '@aztec/foundation/timer';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter } from '@aztec/stdlib/block';
 import { type ContractClassPublicWithCommitment, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
-import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
@@ -189,6 +189,8 @@ export async function registerProtocolContracts(store: KVArchiverDataStore) {
     const contractClassPublic: ContractClassPublicWithCommitment = {
       ...contract.contractClass,
       publicBytecodeCommitment,
+      privateFunctions: [],
+      utilityFunctions: [],
     };
 
     const publicFunctionSignatures = contract.artifact.functions

package/src/l1/calldata_retriever.ts

@@ -1,7 +1,6 @@
 import { MULTI_CALL_3_ADDRESS, type ViemCommitteeAttestations, type ViemHeader } from '@aztec/ethereum/contracts';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
-import { LruSet } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
@@ -45,7 +44,7 @@ type CheckpointData = {
  */
 export class CalldataRetriever {
   /** Tx hashes we've already logged for trace+debug failure (log once per tx per process). */
-  private static readonly traceFailureWarnedTxHashes = new LruSet<string>(1000);
+  private static readonly traceFailureWarnedTxHashes = new Set<string>();
 
   /** Clears the trace-failure warned set. For testing only. */
   static resetTraceFailureWarnedForTesting(): void {

package/src/l1/data_retrieval.ts

@@ -265,9 +265,6 @@ async function processCheckpointProposedLogs(
         checkpointNumber,
         expectedHashes,
       );
-      const { timestamp, parentBeaconBlockRoot } = await getL1Block(publicClient, log.l1BlockNumber);
-      const l1 = new L1PublishedData(log.l1BlockNumber, timestamp, log.l1BlockHash.toString());
-
       const checkpointBlobData = await getCheckpointBlobDataFromBlobs(
         blobClient,
         checkpoint.blockHash,
@@ -275,8 +272,12 @@ async function processCheckpointProposedLogs(
         checkpointNumber,
         logger,
         isHistoricalSync,
-        parentBeaconBlockRoot,
-        timestamp,
+      );
+
+      const l1 = new L1PublishedData(
+        log.l1BlockNumber,
+        await getL1BlockTime(publicClient, log.l1BlockNumber),
+        log.l1BlockHash.toString(),
       );
 
       retrievedCheckpoints.push({ ...checkpoint, checkpointBlobData, l1, chainId, version });
@@ -297,12 +298,9 @@ async function processCheckpointProposedLogs(
   return retrievedCheckpoints;
 }
 
-export async function getL1Block(
-  publicClient: ViemPublicClient,
-  blockNumber: bigint,
-): Promise<{ timestamp: bigint; parentBeaconBlockRoot: string | undefined }> {
+export async function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint> {
   const block = await publicClient.getBlock({ blockNumber, includeTransactions: false });
-  return { timestamp: block.timestamp, parentBeaconBlockRoot: block.parentBeaconBlockRoot };
+  return block.timestamp;
 }
 
 export async function getCheckpointBlobDataFromBlobs(
@@ -312,14 +310,8 @@ export async function getCheckpointBlobDataFromBlobs(
   checkpointNumber: CheckpointNumber,
   logger: Logger,
   isHistoricalSync: boolean,
-  parentBeaconBlockRoot?: string,
-  l1BlockTimestamp?: bigint,
 ): Promise<CheckpointBlobData> {
-  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, {
-    isHistoricalSync,
-    parentBeaconBlockRoot,
-    l1BlockTimestamp,
-  });
+  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, { isHistoricalSync });
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(checkpointNumber);
   }

package/src/modules/data_source_base.ts

@@ -165,21 +165,16 @@ export abstract class ArchiverDataSourceBase
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
-  public getPrivateLogsByTags(
-    tags: SiloedTag[],
-    page?: number,
-    upToBlockNumber?: BlockNumber,
-  ): Promise<TxScopedL2Log[][]> {
-    return this.store.getPrivateLogsByTags(tags, page, upToBlockNumber);
+  public getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
+    return this.store.getPrivateLogsByTags(tags, page);
   }
 
   public getPublicLogsByTagsFromContract(
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
-    upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]> {
-    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
+    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page);
   }
 
   public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {

package/src/modules/data_store_updater.ts

@@ -1,7 +1,12 @@
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { filterAsync } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import {
+  ContractClassPublishedEvent,
+  PrivateFunctionBroadcastedEvent,
+  UtilityFunctionBroadcastedEvent,
+} from '@aztec/protocol-contracts/class-registry';
 import {
   ContractInstancePublishedEvent,
   ContractInstanceUpdatedEvent,
@@ -10,12 +15,18 @@ import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import { type PublishedCheckpoint, validateCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type ContractClassPublicWithCommitment,
+  type ExecutablePrivateFunctionWithMembershipProof,
+  type UtilityFunctionWithMembershipProof,
   computeContractAddressFromInstance,
   computeContractClassId,
+  isValidPrivateFunctionMembershipProof,
+  isValidUtilityFunctionMembershipProof,
 } from '@aztec/stdlib/contract';
 import type { ContractClassLog, PrivateLog, PublicLog } from '@aztec/stdlib/logs';
 import type { UInt64 } from '@aztec/stdlib/types';
 
+import groupBy from 'lodash.groupby';
+
 import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
 import type { L2TipsCache } from '../store/l2_tips_cache.js';
 
@@ -46,7 +57,8 @@ export class ArchiverDataStoreUpdater {
   /**
    * Adds a proposed block to the store with contract class/instance extraction from logs.
    * This is an uncheckpointed block that has been proposed by the sequencer but not yet included in a checkpoint on L1.
-   * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events from the block logs.
+   * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
+   * and individually broadcasted functions from the block logs.
    *
    * @param block - The proposed L2 block to add.
    * @param pendingChainValidationStatus - Optional validation status to set.
@@ -78,7 +90,8 @@ export class ArchiverDataStoreUpdater {
    * Reconciles local blocks with incoming checkpoints from L1.
    * Adds new 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 from the checkpoint block logs.
+   * 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.
@@ -303,6 +316,9 @@ export class ArchiverDataStoreUpdater {
         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);
   }
@@ -421,4 +437,67 @@ export class ArchiverDataStoreUpdater {
     }
     return true;
   }
+
+  /**
+   * Stores the functions that were broadcasted individually.
+   *
+   * @dev Beware that there is not a delete variant of this, since they are added to contract classes
+   *      and will be deleted as part of the class if needed.
+   */
+  private async storeBroadcastedIndividualFunctions(
+    allLogs: ContractClassLog[],
+    _blockNum: BlockNumber,
+  ): Promise<boolean> {
+    // Filter out private and utility function broadcast events
+    const privateFnEvents = allLogs
+      .filter(log => PrivateFunctionBroadcastedEvent.isPrivateFunctionBroadcastedEvent(log))
+      .map(log => PrivateFunctionBroadcastedEvent.fromLog(log));
+    const utilityFnEvents = allLogs
+      .filter(log => UtilityFunctionBroadcastedEvent.isUtilityFunctionBroadcastedEvent(log))
+      .map(log => UtilityFunctionBroadcastedEvent.fromLog(log));
+
+    // Group all events by contract class id
+    for (const [classIdString, classEvents] of Object.entries(
+      groupBy([...privateFnEvents, ...utilityFnEvents], e => e.contractClassId.toString()),
+    )) {
+      const contractClassId = Fr.fromHexString(classIdString);
+      const contractClass = await this.store.getContractClass(contractClassId);
+      if (!contractClass) {
+        this.log.warn(`Skipping broadcasted functions as contract class ${contractClassId.toString()} was not found`);
+        continue;
+      }
+
+      // Split private and utility functions, and filter out invalid ones
+      const allFns = classEvents.map(e => e.toFunctionWithMembershipProof());
+      const privateFns = allFns.filter(
+        (fn): fn is ExecutablePrivateFunctionWithMembershipProof => 'utilityFunctionsTreeRoot' in fn,
+      );
+      const utilityFns = allFns.filter(
+        (fn): fn is UtilityFunctionWithMembershipProof => 'privateFunctionsArtifactTreeRoot' in fn,
+      );
+
+      const privateFunctionsWithValidity = await Promise.all(
+        privateFns.map(async fn => ({ fn, valid: await isValidPrivateFunctionMembershipProof(fn, contractClass) })),
+      );
+      const validPrivateFns = privateFunctionsWithValidity.filter(({ valid }) => valid).map(({ fn }) => fn);
+      const utilityFunctionsWithValidity = await Promise.all(
+        utilityFns.map(async fn => ({
+          fn,
+          valid: await isValidUtilityFunctionMembershipProof(fn, contractClass),
+        })),
+      );
+      const validUtilityFns = utilityFunctionsWithValidity.filter(({ valid }) => valid).map(({ fn }) => fn);
+      const validFnCount = validPrivateFns.length + validUtilityFns.length;
+      if (validFnCount !== allFns.length) {
+        this.log.warn(`Skipping ${allFns.length - validFnCount} invalid functions`);
+      }
+
+      // Store the functions in the contract class in a single operation
+      if (validFnCount > 0) {
+        this.log.verbose(`Storing ${validFnCount} functions for contract class ${contractClassId.toString()}`);
+      }
+      await this.store.addFunctions(contractClassId, validPrivateFns, validUtilityFns);
+    }
+    return true;
+  }
 }

package/src/modules/instrumentation.ts

@@ -1,9 +1,6 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { CheckpointData } from '@aztec/stdlib/checkpoint';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import {
   Attributes,
   type Gauge,
@@ -41,8 +38,6 @@ export class ArchiverInstrumentation {
 
   private blockProposalTxTargetCount: UpDownCounter;
 
-  private checkpointL1InclusionDelay: Histogram;
-
   private log = createLogger('archiver:instrumentation');
 
   private constructor(
@@ -90,8 +85,6 @@ export class ArchiverInstrumentation {
       },
     );
 
-    this.checkpointL1InclusionDelay = meter.createHistogram(Metrics.ARCHIVER_CHECKPOINT_L1_INCLUSION_DELAY);
-
     this.dbMetrics = new LmdbMetrics(
       meter,
       {
@@ -168,17 +161,4 @@ export class ArchiverInstrumentation {
       [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: usedTrace,
     });
   }
-
-  /**
-   * Records L1 inclusion timing for a checkpoint observed on L1 (seconds into the L2 slot).
-   */
-  public processCheckpointL1Timing(data: {
-    slotNumber: SlotNumber;
-    l1Timestamp: bigint;
-    l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>;
-  }): void {
-    const slotStartTs = getTimestampForSlot(data.slotNumber, data.l1Constants);
-    const inclusionDelaySeconds = Number(data.l1Timestamp - slotStartTs);
-    this.checkpointL1InclusionDelay.record(inclusionDelaySeconds);
-  }
 }

package/src/modules/l1_synchronizer.ts

@@ -3,7 +3,6 @@ import { EpochCache } from '@aztec/epoch-cache';
 import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1BlockId } from '@aztec/ethereum/l1-types';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
-import { asyncPool } from '@aztec/foundation/async-pool';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -246,13 +245,22 @@ export class ArchiverL1Synchronizer implements Traceable {
       const localFinalizedCheckpointNumber = await this.store.getFinalizedCheckpointNumber();
       if (localFinalizedCheckpointNumber !== finalizedCheckpointNumber) {
         await this.updater.setFinalizedCheckpointNumber(finalizedCheckpointNumber);
-        this.log.info(`Updated finalized chain to checkpoint ${finalizedCheckpointNumber}`, {
-          finalizedCheckpointNumber,
-          finalizedL1BlockNumber,
-        });
+        const finalizedL2BlockNumber = await this.store.getFinalizedL2BlockNumber();
+        this.log.info(
+          `Updated finalized chain to checkpoint ${finalizedCheckpointNumber} (L2 block ${finalizedL2BlockNumber})`,
+          {
+            finalizedCheckpointNumber,
+            previousFinalizedCheckpointNumber: localFinalizedCheckpointNumber,
+            finalizedL2BlockNumber,
+            finalizedL1BlockNumber,
+          },
+        );
+      }
+    } catch (err: any) {
+      // The rollup contract may not exist at the finalized L1 block right after deployment.
+      if (!err?.message?.includes('returned no data')) {
+        this.log.warn(`Failed to update finalized checkpoint: ${err}`);
       }
-    } catch (err) {
-      this.log.warn(`Failed to update finalized checkpoint: ${err}`);
     }
   }
 
@@ -334,20 +342,17 @@ export class ArchiverL1Synchronizer implements Traceable {
 
       const checkpointsToUnwind = localPendingCheckpointNumber - provenCheckpointNumber;
 
-      // Fetch checkpoints and blocks in bounded batches to avoid unbounded concurrent
-      // promises when the gap between local pending and proven checkpoint numbers is large.
-      const BATCH_SIZE = 10;
-      const indices = Array.from({ length: checkpointsToUnwind }, (_, i) => CheckpointNumber(i + pruneFrom));
-      const checkpoints = (await asyncPool(BATCH_SIZE, indices, idx => this.store.getCheckpointData(idx))).filter(
-        isDefined,
+      const checkpointPromises = Array.from({ length: checkpointsToUnwind })
+        .fill(0)
+        .map((_, i) => this.store.getCheckpointData(CheckpointNumber(i + pruneFrom)));
+      const checkpoints = await Promise.all(checkpointPromises);
+
+      const blockPromises = await Promise.all(
+        checkpoints
+          .filter(isDefined)
+          .map(cp => this.store.getBlocksForCheckpoint(CheckpointNumber(cp.checkpointNumber))),
       );
-      const newBlocks = (
-        await asyncPool(BATCH_SIZE, checkpoints, cp =>
-          this.store.getBlocksForCheckpoint(CheckpointNumber(cp.checkpointNumber)),
-        )
-      )
-        .filter(isDefined)
-        .flat();
+      const newBlocks = blockPromises.filter(isDefined).flat();
 
       // Emit an event for listening services to react to the chain prune
       this.events.emit(L2BlockSourceEvents.L2PruneUnproven, {
@@ -395,7 +400,6 @@ export class ArchiverL1Synchronizer implements Traceable {
     const localMessagesInserted = await this.store.getTotalL1ToL2MessageCount();
     const localLastMessage = await this.store.getLastL1ToL2Message();
     const remoteMessagesState = await this.inbox.getState({ blockNumber: currentL1BlockNumber });
-    await this.store.setInboxTreeInProgress(remoteMessagesState.treeInProgress);
 
     this.log.trace(`Retrieved remote inbox state at L1 block ${currentL1BlockNumber}.`, {
       localMessagesInserted,
@@ -830,14 +834,6 @@ export class ArchiverL1Synchronizer implements Traceable {
         );
       }
 
-      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;

package/src/store/block_store.ts

@@ -227,21 +227,34 @@ export class BlockStore {
     }
 
     return await this.db.transactionAsync(async () => {
-      // Check that the checkpoint immediately before the first block to be added is present in the store.
       const firstCheckpointNumber = checkpoints[0].checkpoint.number;
       const previousCheckpointNumber = await this.getLatestCheckpointNumber();
 
-      if (previousCheckpointNumber !== firstCheckpointNumber - 1 && !opts.force) {
+      // Handle already-stored checkpoints at the start of the batch.
+      // This can happen after an L1 reorg re-includes a checkpoint in a different L1 block.
+      // We accept them if archives match (same content) and update their L1 metadata.
+      if (!opts.force && firstCheckpointNumber <= previousCheckpointNumber) {
+        checkpoints = await this.skipOrUpdateAlreadyStoredCheckpoints(checkpoints, previousCheckpointNumber);
+        if (checkpoints.length === 0) {
+          return true;
+        }
+        // Re-check sequentiality after skipping
+        const newFirstNumber = checkpoints[0].checkpoint.number;
+        if (previousCheckpointNumber !== newFirstNumber - 1) {
+          throw new InitialCheckpointNumberNotSequentialError(newFirstNumber, previousCheckpointNumber);
+        }
+      } else if (previousCheckpointNumber !== firstCheckpointNumber - 1 && !opts.force) {
         throw new InitialCheckpointNumberNotSequentialError(firstCheckpointNumber, previousCheckpointNumber);
       }
 
       // Extract the previous checkpoint if there is one
+      const currentFirstCheckpointNumber = checkpoints[0].checkpoint.number;
       let previousCheckpointData: CheckpointData | undefined = undefined;
-      if (previousCheckpointNumber !== INITIAL_CHECKPOINT_NUMBER - 1) {
+      if (currentFirstCheckpointNumber - 1 !== INITIAL_CHECKPOINT_NUMBER - 1) {
         // There should be a previous checkpoint
-        previousCheckpointData = await this.getCheckpointData(previousCheckpointNumber);
+        previousCheckpointData = await this.getCheckpointData(CheckpointNumber(currentFirstCheckpointNumber - 1));
         if (previousCheckpointData === undefined) {
-          throw new CheckpointNotFoundError(previousCheckpointNumber);
+          throw new CheckpointNotFoundError(CheckpointNumber(currentFirstCheckpointNumber - 1));
         }
       }
 
@@ -331,6 +344,50 @@ export class BlockStore {
     });
   }
 
+  /**
+   * Handles checkpoints at the start of a batch that are already stored (e.g. due to L1 reorg).
+   * Verifies the archive root matches, updates L1 metadata, and returns only the new checkpoints.
+   */
+  private async skipOrUpdateAlreadyStoredCheckpoints(
+    checkpoints: PublishedCheckpoint[],
+    latestStored: CheckpointNumber,
+  ): Promise<PublishedCheckpoint[]> {
+    let i = 0;
+    for (; i < checkpoints.length && checkpoints[i].checkpoint.number <= latestStored; i++) {
+      const incoming = checkpoints[i];
+      const stored = await this.getCheckpointData(incoming.checkpoint.number);
+      if (!stored) {
+        // Should not happen if latestStored is correct, but be safe
+        break;
+      }
+      // Verify the checkpoint content matches (archive root)
+      if (!stored.archive.root.equals(incoming.checkpoint.archive.root)) {
+        throw new Error(
+          `Checkpoint ${incoming.checkpoint.number} already exists in store but with a different archive root. ` +
+            `Stored: ${stored.archive.root}, incoming: ${incoming.checkpoint.archive.root}`,
+        );
+      }
+      // Update L1 metadata and attestations for the already-stored checkpoint
+      this.#log.warn(
+        `Checkpoint ${incoming.checkpoint.number} already stored, updating L1 info ` +
+          `(L1 block ${stored.l1.blockNumber} -> ${incoming.l1.blockNumber})`,
+      );
+      await this.#checkpoints.set(incoming.checkpoint.number, {
+        header: incoming.checkpoint.header.toBuffer(),
+        archive: incoming.checkpoint.archive.toBuffer(),
+        checkpointOutHash: incoming.checkpoint.getCheckpointOutHash().toBuffer(),
+        l1: incoming.l1.toBuffer(),
+        attestations: incoming.attestations.map(a => a.toBuffer()),
+        checkpointNumber: incoming.checkpoint.number,
+        startBlock: incoming.checkpoint.blocks[0].number,
+        blockCount: incoming.checkpoint.blocks.length,
+      });
+      // Update the sync point to reflect the new L1 block
+      await this.#lastSynchedL1Block.set(incoming.l1.blockNumber);
+    }
+    return checkpoints.slice(i);
+  }
+
   private async addBlockToDatabase(block: L2Block, checkpointNumber: number, indexWithinCheckpoint: number) {
     const blockHash = await block.hash();