@aztec/archiver 0.0.1-commit.03f7ef2 → 0.0.1-commit.1142ef1

package/src/archiver/archiver_store_test_suite.ts

@@ -20,10 +20,9 @@ import {
   EthAddress,
   L2BlockHash,
   L2BlockNew,
-  type ValidateBlockResult,
-  randomBlockInfo,
+  type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint, randomCheckpointInfo } from '@aztec/stdlib/checkpoint';
 import {
   type ContractClassPublic,
   type ContractInstanceWithAddress,
@@ -2276,17 +2275,13 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 2,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[2 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[0]),
-              isFromPublic: false,
+              logData: makePrivateLog(tags[0]).getEmittedFields(),
             }),
           ],
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[1]),
-              isFromPublic: false,
+              logData: makePrivateLog(tags[1]).getEmittedFields(),
             }),
           ],
         ]);
@@ -2312,15 +2307,11 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[0]),
-              isFromPublic: false,
+              logData: makePrivateLog(tags[0]).getEmittedFields(),
             }),
             expect.objectContaining({
               blockNumber: newBlockNumber,
-              blockHash: L2BlockHash.fromField(await newCheckpoint.checkpoint.blocks[0].header.hash()),
-              log: newLog,
-              isFromPublic: false,
+              logData: newLog.getEmittedFields(),
             }),
           ],
         ]);
@@ -2338,9 +2329,7 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[1]),
-              isFromPublic: false,
+              logData: makePrivateLog(tags[1]).getEmittedFields(),
             }),
           ],
         ]);
@@ -2425,17 +2414,13 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 2,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[2 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePublicLog(tags[0]),
-              isFromPublic: true,
+              logData: makePublicLog(tags[0]).getEmittedFields(),
             }),
           ],
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePublicLog(tags[1]),
-              isFromPublic: true,
+              logData: makePublicLog(tags[1]).getEmittedFields(),
             }),
           ],
         ]);
@@ -2461,15 +2446,11 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePublicLog(tags[0]),
-              isFromPublic: true,
+              logData: makePublicLog(tags[0]).getEmittedFields(),
             }),
             expect.objectContaining({
               blockNumber: newBlockNumber,
-              blockHash: L2BlockHash.fromField(await newCheckpoint.checkpoint.blocks[0].header.hash()),
-              log: newLog,
-              isFromPublic: true,
+              logData: newLog.getEmittedFields(),
             }),
           ],
         ]);
@@ -2487,9 +2468,7 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePublicLog(tags[1]),
-              isFromPublic: true,
+              logData: makePublicLog(tags[1]).getEmittedFields(),
             }),
           ],
         ]);
@@ -2776,7 +2755,7 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve a valid validation status', async () => {
-        const validStatus: ValidateBlockResult = { valid: true };
+        const validStatus: ValidateCheckpointResult = { valid: true };
 
         await store.setPendingChainValidationStatus(validStatus);
         const retrievedStatus = await store.getPendingChainValidationStatus();
@@ -2785,9 +2764,9 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve an invalid validation status with insufficient attestations', async () => {
-        const invalidStatus: ValidateBlockResult = {
+        const invalidStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(1),
+          checkpoint: randomCheckpointInfo(1),
           committee: [EthAddress.random(), EthAddress.random()],
           epoch: EpochNumber(123),
           seed: 456n,
@@ -2803,9 +2782,9 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve an invalid validation status with invalid attestation', async () => {
-        const invalidStatus: ValidateBlockResult = {
+        const invalidStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(2),
+          checkpoint: randomCheckpointInfo(2),
           committee: [EthAddress.random()],
           attestors: [EthAddress.random()],
           epoch: EpochNumber(789),
@@ -2822,10 +2801,10 @@ export function describeArchiverDataStore(
       });
 
       it('should overwrite existing status when setting a new one', async () => {
-        const firstStatus: ValidateBlockResult = { valid: true };
-        const secondStatus: ValidateBlockResult = {
+        const firstStatus: ValidateCheckpointResult = { valid: true };
+        const secondStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(3),
+          checkpoint: randomCheckpointInfo(3),
           committee: [EthAddress.random()],
           epoch: EpochNumber(999),
           seed: 888n,
@@ -2842,9 +2821,9 @@ export function describeArchiverDataStore(
       });
 
       it('should handle empty committee and attestations arrays', async () => {
-        const statusWithEmptyArrays: ValidateBlockResult = {
+        const statusWithEmptyArrays: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(4),
+          checkpoint: randomCheckpointInfo(4),
           committee: [],
           epoch: EpochNumber(0),
           seed: 0n,

package/src/archiver/config.ts

@@ -46,8 +46,8 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
     description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
-  skipValidateBlockAttestations: {
-    description: 'Whether to skip validating block attestations (use only for testing).',
+  skipValidateCheckpointAttestations: {
+    description: 'Skip validating checkpoint attestations (for testing purposes only)',
     ...booleanConfigHelper(false),
   },
   maxAllowedEthClientDriftSeconds: {

package/src/archiver/instrumentation.ts

@@ -10,7 +10,6 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 export class ArchiverInstrumentation {
@@ -45,81 +44,33 @@ export class ArchiverInstrumentation {
     this.tracer = telemetry.getTracer('Archiver');
     const meter = telemetry.getMeter('Archiver');
 
-    this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT, {
-      description: 'The height of the latest block processed by the archiver',
-      valueType: ValueType.INT,
-    });
+    this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT);
 
-    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
-      description: 'The height of the latest L1 block processed by the archiver',
-      valueType: ValueType.INT,
-    });
+    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT);
 
-    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TOTAL_TXS, {
-      description: 'The total number of transactions',
-      valueType: ValueType.INT,
-    });
+    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TOTAL_TXS);
 
-    this.proofsSubmittedCount = meter.createUpDownCounter(Metrics.ARCHIVER_ROLLUP_PROOF_COUNT, {
-      description: 'Number of proofs submitted',
-      valueType: ValueType.INT,
-    });
+    this.proofsSubmittedCount = meter.createUpDownCounter(Metrics.ARCHIVER_ROLLUP_PROOF_COUNT);
 
-    this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY, {
-      unit: 'ms',
-      description: 'Time after a block is submitted until its proof is published',
-      valueType: ValueType.INT,
-    });
+    this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY);
 
-    this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK, {
-      unit: 'ms',
-      description: 'Duration to sync a block',
-      valueType: ValueType.INT,
-    });
+    this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK);
 
-    this.syncBlockCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_BLOCK_COUNT, {
-      description: 'Number of blocks synced from L1',
-      valueType: ValueType.INT,
-    });
+    this.syncBlockCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_BLOCK_COUNT);
 
-    this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK, {
-      description: 'The mana consumed by blocks',
-      valueType: ValueType.DOUBLE,
-      unit: 'Mmana',
-    });
+    this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK);
 
-    this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK, {
-      description: 'The block tx count',
-      valueType: ValueType.INT,
-      unit: 'tx',
-    });
+    this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK);
 
-    this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE, {
-      unit: 'ms',
-      description: 'Duration to sync a message',
-      valueType: ValueType.INT,
-    });
+    this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE);
 
-    this.syncMessageCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_MESSAGE_COUNT, {
-      description: 'Number of L1 to L2 messages synced',
-      valueType: ValueType.INT,
-    });
+    this.syncMessageCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_MESSAGE_COUNT);
 
-    this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION, {
-      unit: 'ms',
-      description: 'Duration to sync a message',
-      valueType: ValueType.INT,
-    });
+    this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION);
 
-    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
-      description: 'Number of prunes detected',
-      valueType: ValueType.INT,
-    });
+    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT);
 
-    this.blockProposalTxTargetCount = meter.createUpDownCounter(Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT, {
-      description: 'Number of block proposals by tx target',
-      valueType: ValueType.INT,
-    });
+    this.blockProposalTxTargetCount = meter.createUpDownCounter(Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT);
 
     this.dbMetrics = new LmdbMetrics(
       meter,

package/src/archiver/kv_archiver_store/block_store.ts

@@ -14,9 +14,9 @@ import {
   CommitteeAttestation,
   L2BlockHash,
   L2BlockNew,
-  type ValidateBlockResult,
-  deserializeValidateBlockResult,
-  serializeValidateBlockResult,
+  type ValidateCheckpointResult,
+  deserializeValidateCheckpointResult,
+  serializeValidateCheckpointResult,
 } from '@aztec/stdlib/block';
 import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
@@ -503,6 +503,34 @@ export class BlockStore {
     );
   }
 
+  /**
+   * Gets up to `limit` amount of Checkpointed L2 blocks starting from `from`.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 blocks
+   */
+  async *getCheckpointedBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<CheckpointedL2Block> {
+    const checkpointCache = new Map<CheckpointNumber, CheckpointStorage>();
+    for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
+      const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
+      if (block) {
+        const checkpoint =
+          checkpointCache.get(CheckpointNumber(blockStorage.checkpointNumber)) ??
+          (await this.#checkpoints.getAsync(blockStorage.checkpointNumber));
+        if (checkpoint) {
+          checkpointCache.set(CheckpointNumber(blockStorage.checkpointNumber), checkpoint);
+          const checkpointedBlock = new CheckpointedL2Block(
+            CheckpointNumber(checkpoint.checkpointNumber),
+            block,
+            L1PublishedData.fromBuffer(checkpoint.l1),
+            checkpoint.attestations.map(buf => CommitteeAttestation.fromBuffer(buf)),
+          );
+          yield checkpointedBlock;
+        }
+      }
+    }
+  }
+
   async getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
     if (blockNumber === undefined) {
@@ -799,21 +827,21 @@ export class BlockStore {
    * Gets the pending chain validation status.
    * @returns The validation status or undefined if not set.
    */
-  async getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+  async getPendingChainValidationStatus(): Promise<ValidateCheckpointResult | undefined> {
     const buffer = await this.#pendingChainValidationStatus.getAsync();
     if (!buffer) {
       return undefined;
     }
-    return deserializeValidateBlockResult(buffer);
+    return deserializeValidateCheckpointResult(buffer);
   }
 
   /**
    * Sets the pending chain validation status.
    * @param status - The validation status to store.
    */
-  async setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+  async setPendingChainValidationStatus(status: ValidateCheckpointResult | undefined): Promise<void> {
     if (status) {
-      const buffer = serializeValidateBlockResult(status);
+      const buffer = serializeValidateCheckpointResult(status);
       await this.#pendingChainValidationStatus.set(buffer);
     } else {
       await this.#pendingChainValidationStatus.delete();

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -6,7 +6,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
@@ -234,6 +234,10 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
+  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
+    return toArray(this.#blockStore.getCheckpointedBlocks(from, limit));
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks headers starting from `from`.
    *
@@ -410,11 +414,11 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#messageStore.removeL1ToL2Messages(startIndex);
   }
 
-  public getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+  public getPendingChainValidationStatus(): Promise<ValidateCheckpointResult | undefined> {
     return this.#blockStore.getPendingChainValidationStatus();
   }
 
-  public setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+  public setPendingChainValidationStatus(status: ValidateCheckpointResult | undefined): Promise<void> {
     return this.#blockStore.setPendingChainValidationStatus(status);
   }
 

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,4 +1,4 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
@@ -57,21 +57,16 @@ export class LogStore {
    * @param block - The L2 block to extract logs from.
    * @returns An object containing the private and public tagged logs for the block.
    */
-  async #extractTaggedLogsFromBlock(block: L2BlockNew) {
-    const blockHash = L2BlockHash.fromField(await block.hash());
+  #extractTaggedLogsFromBlock(block: L2BlockNew) {
     // SiloedTag (as string) -> array of log buffers.
     const privateTaggedLogs = new Map<string, Buffer[]>();
     // "{contractAddress}_{tag}" (as string) -> array of log buffers.
     const publicTaggedLogs = new Map<string, Buffer[]>();
-    const dataStartIndexForBlock =
-      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
-      block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
 
-    block.body.txEffects.forEach((txEffect, txIndex) => {
+    block.body.txEffects.forEach(txEffect => {
       const txHash = txEffect.txHash;
-      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
 
-      txEffect.privateLogs.forEach((log, logIndex) => {
+      txEffect.privateLogs.forEach(log => {
         // Private logs use SiloedTag (already siloed by kernel)
         const tag = log.fields[0];
         this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
@@ -80,18 +75,17 @@ export class LogStore {
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
-            dataStartIndexForTx,
-            logIndex,
             block.number,
-            blockHash,
             block.timestamp,
-            log,
+            log.getEmittedFields(),
+            txEffect.noteHashes,
+            txEffect.nullifiers[0],
           ).toBuffer(),
         );
         privateTaggedLogs.set(tag.toString(), currentLogs);
       });
 
-      txEffect.publicLogs.forEach((log, logIndex) => {
+      txEffect.publicLogs.forEach(log => {
         // Public logs use Tag directly (not siloed) and are stored with contract address
         const tag = log.fields[0];
         const contractAddress = log.contractAddress;
@@ -104,12 +98,11 @@ export class LogStore {
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
-            dataStartIndexForTx,
-            logIndex,
             block.number,
-            blockHash,
             block.timestamp,
-            log,
+            log.getEmittedFields(),
+            txEffect.noteHashes,
+            txEffect.nullifiers[0],
           ).toBuffer(),
         );
         publicTaggedLogs.set(key, currentLogs);
@@ -125,10 +118,11 @@ export class LogStore {
    * @returns A map from tag (as string) to an array of serialized private logs belonging to that tag, and a map from
    * "{contractAddress}_{tag}" (as string) to an array of serialized public logs belonging to that key.
    */
-  async #extractTaggedLogs(
-    blocks: L2BlockNew[],
-  ): Promise<{ privateTaggedLogs: Map<string, Buffer[]>; publicTaggedLogs: Map<string, Buffer[]> }> {
-    const taggedLogsInBlocks = await Promise.all(blocks.map(block => this.#extractTaggedLogsFromBlock(block)));
+  #extractTaggedLogs(blocks: L2BlockNew[]): {
+    privateTaggedLogs: Map<string, Buffer[]>;
+    publicTaggedLogs: Map<string, Buffer[]>;
+  } {
+    const taggedLogsInBlocks = blocks.map(block => this.#extractTaggedLogsFromBlock(block));
 
     // Now we merge the maps from each block into a single map.
     const privateTaggedLogs = taggedLogsInBlocks.reduce((acc, { privateTaggedLogs }) => {
@@ -155,8 +149,8 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  async addLogs(blocks: L2BlockNew[]): Promise<boolean> {
-    const { privateTaggedLogs, publicTaggedLogs } = await this.#extractTaggedLogs(blocks);
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+    const { privateTaggedLogs, publicTaggedLogs } = this.#extractTaggedLogs(blocks);
 
     const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
     const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());

package/src/archiver/l1/calldata_retriever.ts

@@ -72,7 +72,7 @@ export class CalldataRetriever {
    */
   async getCheckpointFromRollupTx(
     txHash: `0x${string}`,
-    blobHashes: Buffer[],
+    _blobHashes: Buffer[],
     checkpointNumber: CheckpointNumber,
     expectedHashes: {
       attestationsHash?: Hex;
@@ -459,7 +459,7 @@ export class CalldataRetriever {
       // Use ConsensusPayload to compute the digest - this ensures we match the exact logic
       // used by the network for signing and verification
       const consensusPayload = new ConsensusPayload(header, archiveRoot);
-      const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
+      const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
       const computedPayloadDigest = keccak256(payloadToSign);
 
       // Compare as buffers to avoid case-sensitivity and string comparison issues

package/src/archiver/l1/validate_trace.ts

@@ -165,7 +165,7 @@ export async function validateAndLogTraceAvailability(
   client: ViemPublicDebugClient,
   ethereumAllowNoDebugHosts: boolean,
 ): Promise<void> {
-  logger.info('Validating trace/debug method availability...');
+  logger.debug('Validating trace/debug method availability...');
 
   const availability = await validateTraceAvailability(client);
 

package/src/archiver/validation.ts

@@ -4,15 +4,15 @@ import { compactArray } from '@aztec/foundation/collection';
 import type { Logger } from '@aztec/foundation/log';
 import {
   type AttestationInfo,
-  type ValidateBlockNegativeResult,
-  type ValidateBlockResult,
+  type ValidateCheckpointNegativeResult,
+  type ValidateCheckpointResult,
   getAttestationInfoFromPayload,
 } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { ConsensusPayload } from '@aztec/stdlib/p2p';
 
-export type { ValidateBlockResult };
+export type { ValidateCheckpointResult };
 
 /**
  * Extracts attestation information from a published checkpoint.
@@ -35,7 +35,7 @@ export async function validateCheckpointAttestations(
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
-): Promise<ValidateBlockResult> {
+): Promise<ValidateCheckpointResult> {
   const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
   const attestors = compactArray(attestorInfos.map(info => ('address' in info ? info.address : undefined)));
   const { checkpoint, attestations } = publishedCheckpoint;
@@ -63,10 +63,10 @@ export async function validateCheckpointAttestations(
 
   const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
 
-  const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
+  const failedValidationResult = <TReason extends ValidateCheckpointNegativeResult['reason']>(reason: TReason) => ({
     valid: false as const,
     reason,
-    block: checkpoint.blocks[0].toBlockInfo(),
+    checkpoint: checkpoint.toCheckpointInfo(),
     committee,
     seed,
     epoch,

package/src/test/mock_l1_to_l2_message_source.ts

@@ -1,6 +1,6 @@
-import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import type { L2Tips } from '@aztec/stdlib/block';
+import type { CheckpointId, L2BlockId, L2TipId, L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 /**
@@ -33,9 +33,15 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
 
   getL2Tips(): Promise<L2Tips> {
     const number = this.blockNumber;
-    const tip = { number: BlockNumber(number), hash: new Fr(number).toString() };
+    const blockId: L2BlockId = { number: BlockNumber(number), hash: new Fr(number).toString() };
+    const checkpointId: CheckpointId = {
+      number: CheckpointNumber(number),
+      hash: new Fr(number + 1).toString(),
+    };
+    const tip: L2TipId = { block: blockId, checkpoint: checkpointId };
     return Promise.resolve({
-      latest: tip,
+      proposed: blockId,
+      checkpointed: tip,
       proven: tip,
       finalized: tip,
     });