@aztec/archiver 0.0.1-commit.f295ac2 → 0.0.1-commit.f2ce05ee

package/src/archiver.ts

@@ -17,7 +17,7 @@ import {
   type ArchiverEmitter,
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
-  L2BlockNew,
+  L2Block,
   type L2BlockSink,
   type L2Tips,
   type ValidateCheckpointResult,
@@ -26,6 +26,7 @@ import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type L1RollupConstants,
   getEpochNumberAtTimestamp,
+  getSlotAtNextL1Block,
   getSlotAtTimestamp,
   getSlotRangeForEpoch,
   getTimestampRangeForEpoch,
@@ -46,7 +47,7 @@ export type { ArchiverEmitter };
 
 /** Request to add a block to the archiver, queued for processing by the sync loop. */
 type AddBlockRequest = {
-  block: L2BlockNew;
+  block: L2Block;
   resolve: () => void;
   reject: (err: Error) => void;
 };
@@ -68,7 +69,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   public readonly events: ArchiverEmitter;
 
   /** A loop in which we will be continually fetching new checkpoints. */
-  private runningPromise: RunningPromise;
+  protected runningPromise: RunningPromise;
 
   /** L1 synchronizer that handles fetching checkpoints and messages from L1. */
   private readonly synchronizer: ArchiverL1Synchronizer;
@@ -158,7 +159,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
 
     await this.blobClient.testSources();
     await this.synchronizer.testEthereumNodeSynced();
-    await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false);
+    await validateAndLogTraceAvailability(
+      this.debugClient,
+      this.config.ethereumAllowNoDebugHosts ?? false,
+      this.log.getBindings(),
+    );
 
     // Log initial state for the archiver
     const { l1StartBlock } = this.l1Constants;
@@ -187,7 +192,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
    * @param block - The L2 block to add.
    * @returns A promise that resolves when the block has been added to the store, or rejects on error.
    */
-  public addBlock(block: L2BlockNew): Promise<void> {
+  public addBlock(block: L2Block): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       this.blockQueue.push({ block, resolve, reject });
       this.log.debug(`Queued block ${block.number} for processing`);
@@ -212,10 +217,25 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     const queuedItems = this.blockQueue.splice(0, this.blockQueue.length);
     this.log.debug(`Processing ${queuedItems.length} queued block(s)`);
 
+    // Calculate slot threshold for validation
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    const slotAtNextL1Block =
+      l1Timestamp === undefined ? undefined : getSlotAtNextL1Block(l1Timestamp, this.l1Constants);
+
     // Process each block individually to properly resolve/reject each promise
     for (const { block, resolve, reject } of queuedItems) {
+      const blockSlot = block.header.globalVariables.slotNumber;
+      if (slotAtNextL1Block !== undefined && blockSlot < slotAtNextL1Block) {
+        this.log.warn(
+          `Rejecting proposed block ${block.number} for past slot ${blockSlot} (current is ${slotAtNextL1Block})`,
+          { block: block.toBlockInfo(), l1Timestamp, slotAtNextL1Block },
+        );
+        reject(new Error(`Block ${block.number} is for past slot ${blockSlot} (current is ${slotAtNextL1Block})`));
+        continue;
+      }
+
       try {
-        await this.updater.addBlocks([block]);
+        await this.updater.addProposedBlocks([block]);
         this.log.debug(`Added block ${block.number} to store`);
         resolve();
       } catch (err: any) {
@@ -323,8 +343,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   }
 
   public async isEpochComplete(epochNumber: EpochNumber): Promise<boolean> {
-    // The epoch is complete if the current L2 block is the last one in the epoch (or later)
-    const header = await this.getBlockHeader('latest');
+    // The epoch is complete if the current checkpointed L2 block is the last one in the epoch (or later).
+    // We use the checkpointed block number (synced from L1) instead of 'latest' to avoid returning true
+    // prematurely when proposed blocks have been pushed to the archiver but not yet checkpointed on L1.
+    const checkpointedBlockNumber = await this.getCheckpointedL2BlockNumber();
+    const header = checkpointedBlockNumber > 0 ? await this.getBlockHeader(checkpointedBlockNumber) : undefined;
     const slot = header ? header.globalVariables.slotNumber : undefined;
     const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
     if (slot && slot >= endSlot) {
@@ -355,8 +378,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     return this.initialSyncComplete;
   }
 
-  public unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
-    return this.updater.unwindCheckpoints(from, checkpointsToUnwind);
+  public removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
+    return this.updater.removeCheckpointsAfter(checkpointNumber);
   }
 
   /** Used by TXE to add checkpoints directly without syncing from L1. */
@@ -364,22 +387,18 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
-    await this.updater.setNewCheckpointData(checkpoints, pendingChainValidationStatus);
+    await this.updater.addCheckpoints(checkpoints, pendingChainValidationStatus);
     return true;
   }
 
   public async getL2Tips(): Promise<L2Tips> {
-    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
+    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
       this.getBlockNumber(),
       this.getProvenBlockNumber(),
-      this.getCheckpointedBlockNumber(),
+      this.getCheckpointedL2BlockNumber(),
+      this.getFinalizedL2BlockNumber(),
     ] as const);
 
-    // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-    // We just force it 2 epochs worth of proven data for now.
-    // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
-    const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1Constants.epochDuration * 2, 0));
-
     const beforeInitialblockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
 
     // Get the latest block header and checkpointed blocks for proven, finalised and checkpointed blocks
@@ -425,14 +444,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
     const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
       provenCheckpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
+        ? await this.getCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
         : [undefined],
       finalizedCheckpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
-        : [undefined],
-      checkpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1)
+        ? await this.getCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
         : [undefined],
+      checkpointedBlock !== undefined ? await this.getCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [undefined],
     ]);
 
     const initialcheckpointId: CheckpointId = {
@@ -490,13 +507,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     if (targetL2BlockNumber >= currentL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} must be less than current L2 block ${currentL2Block}`);
     }
-    const blocksToUnwind = currentL2Block - targetL2BlockNumber;
     const targetL2Block = await this.store.getCheckpointedBlock(targetL2BlockNumber);
     if (!targetL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
     }
     const targetL1BlockNumber = targetL2Block.l1.blockNumber;
-    const targetCheckpointNumber = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
+    const targetCheckpointNumber = targetL2Block.checkpointNumber;
     const targetL1Block = await this.publicClient.getBlock({
       blockNumber: targetL1BlockNumber,
       includeTransactions: false,
@@ -505,9 +521,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       throw new Error(`Missing L1 block ${targetL1BlockNumber}`);
     }
     const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
-    this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
-    await this.updater.unwindCheckpoints(CheckpointNumber(currentL2Block), blocksToUnwind);
-    this.log.info(`Unwinding L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
+    this.log.info(
+      `Removing checkpoints after checkpoint ${targetCheckpointNumber} (target block ${targetL2BlockNumber})`,
+    );
+    await this.updater.removeCheckpointsAfter(targetCheckpointNumber);
+    this.log.info(`Rolling back L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
     await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
     this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
     await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);

package/src/errors.ts

@@ -88,3 +88,15 @@ export class BlockNotFoundError extends Error {
     super(`Failed to find expected block number ${blockNumber}`);
   }
 }
+
+export class CannotOverwriteCheckpointedBlockError extends Error {
+  constructor(
+    public readonly blockNumber: number,
+    public readonly lastCheckpointedBlock: number,
+  ) {
+    super(
+      `Cannot add block ${blockNumber}: would overwrite checkpointed data (checkpointed up to block ${lastCheckpointedBlock})`,
+    );
+    this.name = 'CannotOverwriteCheckpointedBlockError';
+  }
+}

package/src/factory.ts

@@ -6,7 +6,6 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { merge } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
@@ -15,6 +14,7 @@ import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/prov
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter } from '@aztec/stdlib/block';
 import { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
@@ -31,13 +31,14 @@ export const ARCHIVER_STORE_NAME = 'archiver';
 /** Creates an archiver store. */
 export async function createArchiverStore(
   userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
+  l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
 ) {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
-  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
-  return new KVArchiverDataStore(store, config.maxLogs);
+  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
+  return new KVArchiverDataStore(store, config.maxLogs, l1Constants);
 }
 
 /**
@@ -52,7 +53,7 @@ export async function createArchiver(
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config);
+  const archiverStore = await createArchiverStore(config, { epochDuration: config.aztecEpochDuration });
   await registerProtocolContracts(archiverStore);
 
   // Create Ethereum clients
@@ -76,14 +77,21 @@ export async function createArchiver(
   const inbox = new InboxContract(publicClient, config.l1Contracts.inboxAddress);
 
   // Fetch L1 constants from rollup contract
-  const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot, slashingProposerAddress] =
-    await Promise.all([
-      rollup.getL1StartBlock(),
-      rollup.getL1GenesisTime(),
-      rollup.getProofSubmissionEpochs(),
-      rollup.getGenesisArchiveTreeRoot(),
-      rollup.getSlashingProposerAddress(),
-    ] as const);
+  const [
+    l1StartBlock,
+    l1GenesisTime,
+    proofSubmissionEpochs,
+    genesisArchiveRoot,
+    slashingProposerAddress,
+    targetCommitteeSize,
+  ] = await Promise.all([
+    rollup.getL1StartBlock(),
+    rollup.getL1GenesisTime(),
+    rollup.getProofSubmissionEpochs(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getSlashingProposerAddress(),
+    rollup.getTargetCommitteeSize(),
+  ] as const);
 
   const l1StartBlockHash = await publicClient
     .getBlock({ blockNumber: l1StartBlock, includeTransactions: false })
@@ -99,6 +107,7 @@ export async function createArchiver(
     slotDuration,
     ethereumSlotDuration,
     proofSubmissionEpochs: Number(proofSubmissionEpochs),
+    targetCommitteeSize,
     genesisArchiveRoot: Fr.fromString(genesisArchiveRoot.toString()),
   };
 
@@ -155,7 +164,8 @@ export async function createArchiver(
   return archiver;
 }
 
-async function registerProtocolContracts(store: KVArchiverDataStore) {
+/** Registers protocol contracts in the archiver store. */
+export async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();

package/src/l1/bin/retrieve-calldata.ts

@@ -3,8 +3,9 @@ import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/ty
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
-import { type Hex, createPublicClient, http } from 'viem';
+import { type Hex, createPublicClient, getAbiItem, http, toEventSelector } from 'viem';
 import { mainnet } from 'viem/chains';
 
 import { CalldataRetriever } from '../calldata_retriever.js';
@@ -111,38 +112,36 @@ async function main() {
       },
     );
 
-    // Extract L2 block number from transaction logs
-    logger.info('Decoding transaction to extract L2 block number...');
+    // Extract checkpoint number from transaction logs
+    logger.info('Decoding transaction to extract checkpoint number...');
     const receipt = await publicClient.getTransactionReceipt({ hash: txHash });
-    const l2BlockProposedEvent = receipt.logs.find(log => {
+
+    // Look for CheckpointProposed event (emitted when a checkpoint is proposed to the rollup)
+    // Event signature: CheckpointProposed(uint256 indexed checkpointNumber, bytes32 indexed archive, bytes32[], bytes32, bytes32)
+    // Hash: keccak256("CheckpointProposed(uint256,bytes32,bytes32[],bytes32,bytes32)")
+    const checkpointProposedEvent = receipt.logs.find(log => {
       try {
-        // Try to match the L2BlockProposed event
         return (
           log.address.toLowerCase() === rollupAddress.toString().toLowerCase() &&
-          log.topics[0] === '0x2f1d0e696fa5186494a2f2f89a0e0bcbb15d607f6c5eac4637e07e1e5e7d3c00' // L2BlockProposed event signature
+          log.topics[0] === toEventSelector(getAbiItem({ abi: RollupAbi, name: 'CheckpointProposed' }))
         );
       } catch {
         return false;
       }
     });
 
-    let l2BlockNumber: number;
-    if (l2BlockProposedEvent && l2BlockProposedEvent.topics[1]) {
-      // L2 block number is typically the first indexed parameter
-      l2BlockNumber = Number(BigInt(l2BlockProposedEvent.topics[1]));
-      logger.info(`L2 Block Number (from event): ${l2BlockNumber}`);
-    } else {
-      // Fallback: try to extract from transaction data or use a default
-      logger.warn('Could not extract L2 block number from event, using block number as fallback');
-      l2BlockNumber = Number(tx.blockNumber);
+    if (!checkpointProposedEvent || checkpointProposedEvent.topics[1] === undefined) {
+      throw new Error(`Checkpoint proposed event not found`);
     }
 
+    const checkpointNumber = CheckpointNumber.fromBigInt(BigInt(checkpointProposedEvent.topics[1]));
+
     logger.info('');
-    logger.info('Retrieving block header from rollup transaction...');
+    logger.info('Retrieving checkpoint from rollup transaction...');
     logger.info('');
 
     // For this script, we don't have blob hashes or expected hashes, so pass empty arrays/objects
-    const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber), {});
+    const result = await retriever.getCheckpointFromRollupTx(txHash, [], checkpointNumber, {});
 
     logger.info(' Successfully retrieved block header!');
     logger.info('');

package/src/l1/data_retrieval.ts

@@ -20,7 +20,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { Body, CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
@@ -69,7 +69,7 @@ export async function retrievedToPublishedCheckpoint({
   const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot!;
 
   const spongeBlob = SpongeBlob.init();
-  const l2Blocks: L2BlockNew[] = [];
+  const l2Blocks: L2Block[] = [];
   for (let i = 0; i < blocksBlobData.length; i++) {
     const blockBlobData = blocksBlobData[i];
     const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
@@ -100,7 +100,7 @@ export async function retrievedToPublishedCheckpoint({
       }),
     });
 
-    const body = Body.fromTxBlobData(checkpointBlobData.blocks[0].txs);
+    const body = Body.fromTxBlobData(blockBlobData.txs);
 
     const blobFields = encodeBlockBlobData(blockBlobData);
     await spongeBlob.absorb(blobFields);
@@ -119,7 +119,7 @@ export async function retrievedToPublishedCheckpoint({
 
     const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
 
-    l2Blocks.push(new L2BlockNew(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
+    l2Blocks.push(new L2Block(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
   }
 
   const lastBlock = l2Blocks.at(-1)!;

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;