@aztec/archiver 0.0.1-commit.1bea0213 → 0.0.1-commit.217f559981

package/src/l1/validate_trace.ts

@@ -1,5 +1,5 @@
 import type { ViemPublicDebugClient } from '@aztec/ethereum/types';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 
 import type { Hex } from 'viem';
 import type { ZodSchema } from 'zod';
@@ -7,8 +7,6 @@ import type { ZodSchema } from 'zod';
 import { callTraceSchema } from './debug_tx.js';
 import { traceTransactionResponseSchema } from './trace_tx.js';
 
-const logger = createLogger('aztec:archiver:validate_trace');
-
 /**
  * Helper function to test a trace method with validation
  *
@@ -17,6 +15,7 @@ const logger = createLogger('aztec:archiver:validate_trace');
  * @param schema - Zod schema to validate the response
  * @param method - Name of the RPC method ('debug_traceTransaction' or 'trace_transaction')
  * @param blockType - Type of block being tested ('recent' or 'old')
+ * @param logger - Logger instance
  * @returns true if the method works and validation passes, false otherwise
  */
 async function testTraceMethod(
@@ -25,6 +24,7 @@ async function testTraceMethod(
   schema: ZodSchema,
   method: 'debug_traceTransaction' | 'trace_transaction',
   blockType: string,
+  logger: Logger,
 ): Promise<boolean> {
   try {
     // Make request with appropriate params based on method name
@@ -59,9 +59,14 @@ export interface TraceAvailability {
  * Validates the availability of debug/trace methods on the Ethereum client.
  *
  * @param client - The Viem public debug client
+ * @param bindings - Optional logger bindings for context
  * @returns Object indicating which trace methods are available for recent and old blocks
  */
-export async function validateTraceAvailability(client: ViemPublicDebugClient): Promise<TraceAvailability> {
+export async function validateTraceAvailability(
+  client: ViemPublicDebugClient,
+  bindings?: LoggerBindings,
+): Promise<TraceAvailability> {
+  const logger = createLogger('archiver:validate_trace', bindings);
   const result: TraceAvailability = {
     debugTraceRecent: false,
     traceTransactionRecent: false,
@@ -95,6 +100,7 @@ export async function validateTraceAvailability(client: ViemPublicDebugClient):
       callTraceSchema,
       'debug_traceTransaction',
       'recent',
+      logger,
     );
 
     // Test trace_transaction with recent block
@@ -104,6 +110,7 @@ export async function validateTraceAvailability(client: ViemPublicDebugClient):
       traceTransactionResponseSchema,
       'trace_transaction',
       'recent',
+      logger,
     );
 
     // Get a block from 512 blocks ago
@@ -132,7 +139,14 @@ export async function validateTraceAvailability(client: ViemPublicDebugClient):
     const oldTxHash = oldBlock.transactions[0] as Hex;
 
     // Test debug_traceTransaction with old block
-    result.debugTraceOld = await testTraceMethod(client, oldTxHash, callTraceSchema, 'debug_traceTransaction', 'old');
+    result.debugTraceOld = await testTraceMethod(
+      client,
+      oldTxHash,
+      callTraceSchema,
+      'debug_traceTransaction',
+      'old',
+      logger,
+    );
 
     // Test trace_transaction with old block
     result.traceTransactionOld = await testTraceMethod(
@@ -141,6 +155,7 @@ export async function validateTraceAvailability(client: ViemPublicDebugClient):
       traceTransactionResponseSchema,
       'trace_transaction',
       'old',
+      logger,
     );
   } catch (error) {
     logger.warn(`Error validating debug_traceTransaction and trace_transaction availability: ${error}`);
@@ -159,15 +174,18 @@ function hasTxs(block: { transactions?: Hex[] }): boolean {
  *
  * @param client - The Viem public debug client
  * @param ethereumAllowNoDebugHosts - If false, throws an error when no trace methods are available
+ * @param bindings - Optional logger bindings for context
  * @throws Error if ethereumAllowNoDebugHosts is false and no trace methods are available
  */
 export async function validateAndLogTraceAvailability(
   client: ViemPublicDebugClient,
   ethereumAllowNoDebugHosts: boolean,
+  bindings?: LoggerBindings,
 ): Promise<void> {
+  const logger = createLogger('archiver:validate_trace', bindings);
   logger.debug('Validating trace/debug method availability...');
 
-  const availability = await validateTraceAvailability(client);
+  const availability = await validateTraceAvailability(client, bindings);
 
   // Check if we have support for old blocks (either debug or trace)
   const hasOldBlockSupport = availability.debugTraceOld || availability.traceTransactionOld;

package/src/modules/data_source_base.ts

@@ -1,11 +1,12 @@
+import { range } from '@aztec/foundation/array';
 import { BlockNumber, CheckpointNumber, type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { isDefined } from '@aztec/foundation/types';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, CommitteeAttestation, L2Block, type L2Tips } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { type BlockData, type BlockHash, CheckpointedL2Block, L2Block, type L2Tips } from '@aztec/stdlib/block';
+import { Checkpoint, type CheckpointData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
@@ -17,7 +18,6 @@ import type { BlockHeader, IndexedTxEffect, TxHash, TxReceipt } from '@aztec/std
 import type { UInt64 } from '@aztec/stdlib/types';
 
 import type { ArchiverDataSource } from '../interfaces.js';
-import type { CheckpointData } from '../store/block_store.js';
 import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
 import type { ValidateCheckpointResult } from './validation.js';
 
@@ -114,14 +114,14 @@ export abstract class ArchiverDataSourceBase
     if (!checkpointData) {
       return undefined;
     }
-    return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
+    return BlockNumber(checkpointData.startBlock + checkpointData.blockCount - 1);
   }
 
   public getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
     return this.store.getCheckpointedBlocks(from, limit);
   }
 
-  public getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+  public getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined> {
     return this.store.getBlockHeaderByHash(blockHash);
   }
 
@@ -129,6 +129,14 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlockHeaderByArchive(archive);
   }
 
+  public getBlockData(number: BlockNumber): Promise<BlockData | undefined> {
+    return this.store.getBlockData(number);
+  }
+
+  public getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined> {
+    return this.store.getBlockDataByArchive(archive);
+  }
+
   public async getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
@@ -223,28 +231,21 @@ export abstract class ArchiverDataSourceBase
 
   public async getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]> {
     const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
-    const blocks = (
-      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
-    ).filter(isDefined);
-
-    const fullCheckpoints: PublishedCheckpoint[] = [];
-    for (let i = 0; i < checkpoints.length; i++) {
-      const blocksForCheckpoint = blocks[i];
-      const checkpoint = checkpoints[i];
-      const fullCheckpoint = new Checkpoint(
-        checkpoint.archive,
-        checkpoint.header,
-        blocksForCheckpoint,
-        checkpoint.checkpointNumber,
-      );
-      const publishedCheckpoint = new PublishedCheckpoint(
-        fullCheckpoint,
-        checkpoint.l1,
-        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
-      );
-      fullCheckpoints.push(publishedCheckpoint);
+    return Promise.all(checkpoints.map(ch => this.getPublishedCheckpointFromCheckpointData(ch)));
+  }
+
+  private async getPublishedCheckpointFromCheckpointData(checkpoint: CheckpointData): Promise<PublishedCheckpoint> {
+    const blocksForCheckpoint = await this.store.getBlocksForCheckpoint(checkpoint.checkpointNumber);
+    if (!blocksForCheckpoint) {
+      throw new Error(`Blocks for checkpoint ${checkpoint.checkpointNumber} not found`);
     }
-    return fullCheckpoints;
+    const fullCheckpoint = new Checkpoint(
+      checkpoint.archive,
+      checkpoint.header,
+      blocksForCheckpoint,
+      checkpoint.checkpointNumber,
+    );
+    return new PublishedCheckpoint(fullCheckpoint, checkpoint.l1, checkpoint.attestations);
   }
 
   public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
@@ -252,84 +253,44 @@ export abstract class ArchiverDataSourceBase
   }
 
   public async getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
-    if (!this.l1Constants) {
-      throw new Error('L1 constants not set');
-    }
-
-    const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: CheckpointedL2Block[] = [];
-
-    // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-    // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-    let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-    const slot = (b: CheckpointData) => b.header.slotNumber;
-    while (checkpoint && slot(checkpoint) >= start) {
-      if (slot(checkpoint) <= end) {
-        // push the blocks on backwards
-        const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
-        for (let i = endBlock; i >= checkpoint.startBlock; i--) {
-          const checkpointedBlock = await this.getCheckpointedBlock(BlockNumber(i));
-          if (checkpointedBlock) {
-            blocks.push(checkpointedBlock);
-          }
-        }
-      }
-      checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
-    }
-
-    return blocks.reverse();
+    const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+    const blocks = await Promise.all(
+      checkpointsData.flatMap(checkpoint =>
+        range(checkpoint.blockCount, checkpoint.startBlock).map(blockNumber =>
+          this.getCheckpointedBlock(BlockNumber(blockNumber)),
+        ),
+      ),
+    );
+    return blocks.filter(isDefined);
   }
 
   public async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
-    if (!this.l1Constants) {
-      throw new Error('L1 constants not set');
-    }
-
-    const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: BlockHeader[] = [];
-
-    // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-    // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-    let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-    const slot = (b: CheckpointData) => b.header.slotNumber;
-    while (checkpoint && slot(checkpoint) >= start) {
-      if (slot(checkpoint) <= end) {
-        // push the blocks on backwards
-        const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
-        for (let i = endBlock; i >= checkpoint.startBlock; i--) {
-          const block = await this.getBlockHeader(BlockNumber(i));
-          if (block) {
-            blocks.push(block);
-          }
-        }
-      }
-      checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
-    }
-    return blocks.reverse();
+    const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+    const blocks = await Promise.all(
+      checkpointsData.flatMap(checkpoint =>
+        range(checkpoint.blockCount, checkpoint.startBlock).map(blockNumber =>
+          this.getBlockHeader(BlockNumber(blockNumber)),
+        ),
+      ),
+    );
+    return blocks.filter(isDefined);
   }
 
   public async getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+    return Promise.all(
+      checkpointsData.map(data => this.getPublishedCheckpointFromCheckpointData(data).then(p => p.checkpoint)),
+    );
+  }
+
+  /** Returns checkpoint data for all checkpoints whose slot falls within the given epoch. */
+  public getCheckpointsDataForEpoch(epochNumber: EpochNumber): Promise<CheckpointData[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const checkpoints: Checkpoint[] = [];
-
-    // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-    // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-    let checkpointData = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-    const slot = (b: CheckpointData) => b.header.slotNumber;
-    while (checkpointData && slot(checkpointData) >= start) {
-      if (slot(checkpointData) <= end) {
-        // push the checkpoints on backwards
-        const [checkpoint] = await this.getCheckpoints(checkpointData.checkpointNumber, 1);
-        checkpoints.push(checkpoint.checkpoint);
-      }
-      checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
-    }
-
-    return checkpoints.reverse();
+    return this.store.getCheckpointDataForSlotRange(start, end);
   }
 
   public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
@@ -347,7 +308,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlocks(from, limit);
   }
 
-  public getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByHash(blockHash);
   }
 
@@ -355,7 +316,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getCheckpointedBlockByArchive(archive);
   }
 
-  public async getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+  public async getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
     return checkpointedBlock?.block;
   }

package/src/modules/data_store_updater.ts

@@ -25,6 +25,7 @@ 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';
 
 /** Operation type for contract data updates. */
 enum Operation {
@@ -44,7 +45,10 @@ type ReconcileCheckpointsResult = {
 export class ArchiverDataStoreUpdater {
   private readonly log = createLogger('archiver:store_updater');
 
-  constructor(private store: KVArchiverDataStore) {}
+  constructor(
+    private store: KVArchiverDataStore,
+    private l2TipsCache?: L2TipsCache,
+  ) {}
 
   /**
    * Adds proposed blocks to the store with contract class/instance extraction from logs.
@@ -56,11 +60,11 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */
-  public addProposedBlocks(
+  public async addProposedBlocks(
     blocks: L2Block[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
-    return this.store.transactionAsync(async () => {
+    const result = await this.store.transactionAsync(async () => {
       await this.store.addProposedBlocks(blocks);
 
       const opResults = await Promise.all([
@@ -72,8 +76,10 @@ export class ArchiverDataStoreUpdater {
         ...blocks.map(block => this.addContractDataToDb(block)),
       ]);
 
+      await this.l2TipsCache?.refresh();
       return opResults.every(Boolean);
     });
+    return result;
   }
 
   /**
@@ -87,11 +93,11 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns Result with information about any pruned blocks.
    */
-  public addCheckpoints(
+  public async addCheckpoints(
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<ReconcileCheckpointsResult> {
-    return this.store.transactionAsync(async () => {
+    const result = await this.store.transactionAsync(async () => {
       // Before adding checkpoints, check for conflicts with local blocks if any
       const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
 
@@ -111,8 +117,10 @@ export class ArchiverDataStoreUpdater {
         ...newBlocks.map(block => this.addContractDataToDb(block)),
       ]);
 
+      await this.l2TipsCache?.refresh();
       return { prunedBlocks, lastAlreadyInsertedBlockNumber };
     });
+    return result;
   }
 
   /**
@@ -197,8 +205,8 @@ export class ArchiverDataStoreUpdater {
    * @returns The removed blocks.
    * @throws Error if any block to be removed is checkpointed.
    */
-  public removeUncheckpointedBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
-    return this.store.transactionAsync(async () => {
+  public async removeUncheckpointedBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+    const result = await this.store.transactionAsync(async () => {
       // Verify we're only removing uncheckpointed blocks
       const lastCheckpointedBlockNumber = await this.store.getCheckpointedL2BlockNumber();
       if (blockNumber < lastCheckpointedBlockNumber) {
@@ -207,8 +215,11 @@ export class ArchiverDataStoreUpdater {
         );
       }
 
-      return await this.removeBlocksAfter(blockNumber);
+      const result = await this.removeBlocksAfter(blockNumber);
+      await this.l2TipsCache?.refresh();
+      return result;
     });
+    return result;
   }
 
   /**
@@ -238,17 +249,31 @@ export class ArchiverDataStoreUpdater {
    * @returns True if the operation is successful.
    */
   public async removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
-    const { blocksRemoved = [] } = await this.store.removeCheckpointsAfter(checkpointNumber);
-
-    const opResults = await Promise.all([
-      // Prune rolls back to the last proven block, which is by definition valid
-      this.store.setPendingChainValidationStatus({ valid: true }),
-      // Remove contract data for all blocks being removed
-      ...blocksRemoved.map(block => this.removeContractDataFromDb(block)),
-      this.store.deleteLogs(blocksRemoved),
-    ]);
+    return await this.store.transactionAsync(async () => {
+      const { blocksRemoved = [] } = await this.store.removeCheckpointsAfter(checkpointNumber);
+
+      const opResults = await Promise.all([
+        // Prune rolls back to the last proven block, which is by definition valid
+        this.store.setPendingChainValidationStatus({ valid: true }),
+        // Remove contract data for all blocks being removed
+        ...blocksRemoved.map(block => this.removeContractDataFromDb(block)),
+        this.store.deleteLogs(blocksRemoved),
+      ]);
 
-    return opResults.every(Boolean);
+      await this.l2TipsCache?.refresh();
+      return opResults.every(Boolean);
+    });
+  }
+
+  /**
+   * Updates the proven checkpoint number and refreshes the L2 tips cache.
+   * @param checkpointNumber - The checkpoint number to set as proven.
+   */
+  public async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber): Promise<void> {
+    await this.store.transactionAsync(async () => {
+      await this.store.setProvenCheckpointNumber(checkpointNumber);
+      await this.l2TipsCache?.refresh();
+    });
   }
 
   /** Extracts and stores contract data from a single block. */

package/src/modules/instrumentation.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import type { L2Block } from '@aztec/stdlib/block';
+import type { CheckpointData } from '@aztec/stdlib/checkpoint';
 import {
   Attributes,
   type Gauge,
@@ -10,12 +11,14 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 export class ArchiverInstrumentation {
   public readonly tracer: Tracer;
 
   private blockHeight: Gauge;
+  private checkpointHeight: Gauge;
   private txCount: UpDownCounter;
   private l1BlockHeight: Gauge;
   private proofsSubmittedDelay: Histogram;
@@ -46,17 +49,21 @@ export class ArchiverInstrumentation {
 
     this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT);
 
+    this.checkpointHeight = meter.createGauge(Metrics.ARCHIVER_CHECKPOINT_HEIGHT);
+
     this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT);
 
-    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TOTAL_TXS);
+    this.txCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_TOTAL_TXS);
 
-    this.proofsSubmittedCount = meter.createUpDownCounter(Metrics.ARCHIVER_ROLLUP_PROOF_COUNT);
+    this.proofsSubmittedCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_ROLLUP_PROOF_COUNT, {
+      [Attributes.PROOF_TIMED_OUT]: [true, false],
+    });
 
     this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY);
 
     this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK);
 
-    this.syncBlockCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_BLOCK_COUNT);
+    this.syncBlockCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_BLOCK_COUNT);
 
     this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK);
 
@@ -64,13 +71,19 @@ export class ArchiverInstrumentation {
 
     this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE);
 
-    this.syncMessageCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_MESSAGE_COUNT);
+    this.syncMessageCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_MESSAGE_COUNT);
 
     this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION);
 
-    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT);
+    this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT);
 
-    this.blockProposalTxTargetCount = meter.createUpDownCounter(Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT);
+    this.blockProposalTxTargetCount = createUpDownCounterWithDefault(
+      meter,
+      Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT,
+      {
+        [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: [true, false],
+      },
+    );
 
     this.dbMetrics = new LmdbMetrics(
       meter,
@@ -84,10 +97,6 @@ export class ArchiverInstrumentation {
   public static async new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
     const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
 
-    instance.syncBlockCount.add(0);
-    instance.syncMessageCount.add(0);
-    instance.pruneCount.add(0);
-
     await instance.telemetry.flush();
 
     return instance;
@@ -100,6 +109,7 @@ export class ArchiverInstrumentation {
   public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
     this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
+    this.checkpointHeight.record(Math.max(...blocks.map(b => b.checkpointNumber)));
     this.syncBlockCount.add(blocks.length);
 
     for (const block of blocks) {
@@ -122,8 +132,10 @@ export class ArchiverInstrumentation {
     this.pruneDuration.record(Math.ceil(duration));
   }
 
-  public updateLastProvenBlock(blockNumber: number) {
-    this.blockHeight.record(blockNumber, { [Attributes.STATUS]: 'proven' });
+  public updateLastProvenCheckpoint(checkpoint: CheckpointData) {
+    const lastBlockNumberInCheckpoint = checkpoint.startBlock + checkpoint.blockCount - 1;
+    this.blockHeight.record(lastBlockNumberInCheckpoint, { [Attributes.STATUS]: 'proven' });
+    this.checkpointHeight.record(checkpoint.checkpointNumber, { [Attributes.STATUS]: 'proven' });
   }
 
   public processProofsVerified(logs: { proverId: string; l2BlockNumber: bigint; delay: bigint }[]) {

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, getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { type L1RollupConstants, getEpochAtSlot, getSlotAtNextL1Block } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { type Traceable, type Tracer, execInSpan, trackSpan } from '@aztec/telemetry-client';
 
@@ -28,6 +28,7 @@ import {
   retrievedToPublishedCheckpoint,
 } from '../l1/data_retrieval.js';
 import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { L2TipsCache } from '../store/l2_tips_cache.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
 import { ArchiverDataStoreUpdater } from './data_store_updater.js';
 import type { ArchiverInstrumentation } from './instrumentation.js';
@@ -77,9 +78,10 @@ export class ArchiverL1Synchronizer implements Traceable {
     private readonly l1Constants: L1RollupConstants & { l1StartBlockHash: Buffer32; genesisArchiveRoot: Fr },
     private readonly events: ArchiverEmitter,
     tracer: Tracer,
+    l2TipsCache?: L2TipsCache,
     private readonly log: Logger = createLogger('archiver:l1-sync'),
   ) {
-    this.updater = new ArchiverDataStoreUpdater(this.store);
+    this.updater = new ArchiverDataStoreUpdater(this.store, l2TipsCache);
     this.tracer = tracer;
   }
 
@@ -249,8 +251,7 @@ export class ArchiverL1Synchronizer implements Traceable {
     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);
+    const slotAtNextL1Block = getSlotAtNextL1Block(currentL1Timestamp, this.l1Constants);
 
     // Prune provisional blocks from slots that have ended without being checkpointed
     if (firstUncheckpointedBlockSlot !== undefined && firstUncheckpointedBlockSlot < slotAtNextL1Block) {
@@ -551,7 +552,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       if (provenCheckpointNumber === 0) {
         const localProvenCheckpointNumber = await this.store.getProvenCheckpointNumber();
         if (localProvenCheckpointNumber !== provenCheckpointNumber) {
-          await this.store.setProvenCheckpointNumber(provenCheckpointNumber);
+          await this.updater.setProvenCheckpointNumber(provenCheckpointNumber);
           this.log.info(`Rolled back proven chain to checkpoint ${provenCheckpointNumber}`, { provenCheckpointNumber });
         }
       }
@@ -583,13 +584,13 @@ export class ArchiverL1Synchronizer implements Traceable {
       ) {
         const localProvenCheckpointNumber = await this.store.getProvenCheckpointNumber();
         if (localProvenCheckpointNumber !== provenCheckpointNumber) {
-          await this.store.setProvenCheckpointNumber(provenCheckpointNumber);
+          await this.updater.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 lastBlockNumberInCheckpoint =
             localCheckpointForDestinationProvenCheckpointNumber.startBlock +
-            localCheckpointForDestinationProvenCheckpointNumber.numBlocks -
+            localCheckpointForDestinationProvenCheckpointNumber.blockCount -
             1;
 
           this.events.emit(L2BlockSourceEvents.L2BlockProven, {
@@ -598,7 +599,7 @@ export class ArchiverL1Synchronizer implements Traceable {
             slotNumber: provenSlotNumber,
             epochNumber: provenEpochNumber,
           });
-          this.instrumentation.updateLastProvenBlock(lastBlockNumberInCheckpoint);
+          this.instrumentation.updateLastProvenCheckpoint(localCheckpointForDestinationProvenCheckpointNumber);
         } else {
           this.log.trace(`Proven checkpoint ${provenCheckpointNumber} already stored.`);
         }