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

package/src/store/block_store.ts

@@ -1,5 +1,5 @@
 import { INITIAL_CHECKPOINT_NUMBER, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
@@ -350,6 +350,23 @@ export class BlockStore {
     await this.#blockArchiveIndex.set(block.archive.root.toString(), block.number);
   }
 
+  /** Deletes a block and all associated data (tx effects, indices). */
+  private async deleteBlock(block: L2BlockNew): Promise<void> {
+    // Delete the block from the main blocks map
+    await this.#blocks.delete(block.number);
+
+    // Delete all tx effects for this block
+    await Promise.all(block.body.txEffects.map(tx => this.#txEffects.delete(tx.txHash.toString())));
+
+    // Delete block txs mapping
+    const blockHash = (await block.hash()).toString();
+    await this.#blockTxs.delete(blockHash);
+
+    // Clean up indices
+    await this.#blockHashIndex.delete(blockHash);
+    await this.#blockArchiveIndex.delete(block.archive.root.toString());
+  }
+
   /**
    * Unwinds checkpoints from the database
    * @param from -  The tip of the chain, passed for verification purposes,
@@ -387,16 +404,11 @@ export class BlockStore {
             this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
             continue;
           }
-          await this.#blocks.delete(block.number);
-          await Promise.all(block.body.txEffects.map(tx => this.#txEffects.delete(tx.txHash.toString())));
-          const blockHash = (await block.hash()).toString();
-          await this.#blockTxs.delete(blockHash);
-
-          // Clean up indices
-          await this.#blockHashIndex.delete(blockHash);
-          await this.#blockArchiveIndex.delete(block.archive.root.toString());
 
-          this.#log.debug(`Unwound block ${blockNumber} ${blockHash} for checkpoint ${checkpointNumber}`);
+          await this.deleteBlock(block);
+          this.#log.debug(
+            `Unwound block ${blockNumber} ${(await block.hash()).toString()} for checkpoint ${checkpointNumber}`,
+          );
         }
       }
 
@@ -454,6 +466,61 @@ export class BlockStore {
     return converted.filter(isDefined);
   }
 
+  /**
+   * Gets all blocks that have the given slot number.
+   * Iterates backwards through blocks for efficiency since we usually query for the last slot.
+   * @param slotNumber - The slot number to search for.
+   * @returns All blocks with the given slot number, in ascending block number order.
+   */
+  async getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
+    const blocks: L2BlockNew[] = [];
+
+    // Iterate backwards through all blocks and filter by slot number
+    // This is more efficient since we usually query for the most recent slot
+    for await (const [blockNumber, blockStorage] of this.#blocks.entriesAsync({ reverse: true })) {
+      const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
+      const blockSlot = block?.header.globalVariables.slotNumber;
+      if (block && blockSlot === slotNumber) {
+        blocks.push(block);
+      } else if (blockSlot && blockSlot < slotNumber) {
+        break; // Blocks are stored in slot ascending order, so we can stop searching
+      }
+    }
+
+    // Reverse to return blocks in ascending order (block number order)
+    return blocks.reverse();
+  }
+
+  /**
+   * Removes all blocks with block number > blockNumber.
+   * @param blockNumber - The block number to remove after.
+   * @returns The removed blocks (for event emission).
+   */
+  async unwindBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
+    return await this.db.transactionAsync(async () => {
+      const removedBlocks: L2BlockNew[] = [];
+
+      // Get the latest block number to determine the range
+      const latestBlockNumber = await this.getLatestBlockNumber();
+
+      // Iterate from blockNumber + 1 to latestBlockNumber
+      for (let bn = blockNumber + 1; bn <= latestBlockNumber; bn++) {
+        const block = await this.getBlock(BlockNumber(bn));
+
+        if (block === undefined) {
+          this.#log.warn(`Cannot remove block ${bn} from the store since we don't have it`);
+          continue;
+        }
+
+        removedBlocks.push(block);
+        await this.deleteBlock(block);
+        this.#log.debug(`Removed block ${bn} ${(await block.hash()).toString()}`);
+      }
+
+      return removedBlocks;
+    });
+  }
+
   async getProvenBlockNumber(): Promise<BlockNumber> {
     const provenCheckpointNumber = await this.getProvenCheckpointNumber();
     if (provenCheckpointNumber === INITIAL_CHECKPOINT_NUMBER - 1) {
@@ -538,6 +605,7 @@ export class BlockStore {
     }
     return this.getCheckpointedBlock(BlockNumber(blockNumber));
   }
+
   async getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
     if (blockNumber === undefined) {
@@ -672,6 +740,7 @@ export class BlockStore {
     const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
     const blockHash = blockStorage.blockHash;
+    header.setHash(Fr.fromBuffer(blockHash));
     const blockHashString = bufferToHex(blockHash);
     const blockTxsBuffer = await this.#blockTxs.getAsync(blockHashString);
     if (blockTxsBuffer === undefined) {

package/src/store/kv_archiver_store.ts

@@ -1,5 +1,5 @@
 import type { L1BlockId } from '@aztec/ethereum/l1-types';
-import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
@@ -601,4 +601,22 @@ export class KVArchiverDataStore implements ContractDataSource {
   getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
     return this.#blockStore.getCheckpointData(checkpointNumber);
   }
+
+  /**
+   * Gets all blocks that have the given slot number.
+   * @param slotNumber - The slot number to search for.
+   * @returns All blocks with the given slot number.
+   */
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
+    return this.#blockStore.getBlocksForSlot(slotNumber);
+  }
+
+  /**
+   * Removes all blocks with block number > blockNumber.
+   * @param blockNumber - The block number to remove after.
+   * @returns The removed blocks (for event emission).
+   */
+  removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
+    return this.#blockStore.unwindBlocksAfter(blockNumber);
+  }
 }

package/src/store/log_store.ts

@@ -1,5 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } 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 { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -144,92 +145,127 @@ export class LogStore {
     return { privateTaggedLogs, publicTaggedLogs };
   }
 
-  /**
-   * Append new logs to the store's list.
-   * @param blocks - The blocks for which to add the logs.
-   * @returns True if the operation is successful.
-   */
-  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
-    const { privateTaggedLogs, publicTaggedLogs } = this.#extractTaggedLogs(blocks);
+  async #addPrivateLogs(blocks: L2BlockNew[]): Promise<void> {
+    const newBlocks = await filterAsync(
+      blocks,
+      async block => !(await this.#privateLogKeysByBlock.hasAsync(block.number)),
+    );
 
+    const { privateTaggedLogs } = this.#extractTaggedLogs(newBlocks);
     const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
-    const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
 
-    return this.db.transactionAsync(async () => {
-      const currentPrivateTaggedLogs = await Promise.all(
-        keysOfPrivateLogsToUpdate.map(async key => ({
-          tag: key,
-          logBuffers: await this.#privateLogsByTag.getAsync(key),
-        })),
-      );
-      currentPrivateTaggedLogs.forEach(taggedLogBuffer => {
-        if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-          privateTaggedLogs.set(
-            taggedLogBuffer.tag,
-            taggedLogBuffer.logBuffers!.concat(privateTaggedLogs.get(taggedLogBuffer.tag)!),
-          );
-        }
-      });
+    const currentPrivateTaggedLogs = await Promise.all(
+      keysOfPrivateLogsToUpdate.map(async key => ({
+        tag: key,
+        logBuffers: await this.#privateLogsByTag.getAsync(key),
+      })),
+    );
 
-      const currentPublicTaggedLogs = await Promise.all(
-        keysOfPublicLogsToUpdate.map(async key => ({
-          key,
-          logBuffers: await this.#publicLogsByContractAndTag.getAsync(key),
-        })),
-      );
-      currentPublicTaggedLogs.forEach(taggedLogBuffer => {
-        if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-          publicTaggedLogs.set(
-            taggedLogBuffer.key,
-            taggedLogBuffer.logBuffers!.concat(publicTaggedLogs.get(taggedLogBuffer.key)!),
-          );
-        }
-      });
+    for (const taggedLogBuffer of currentPrivateTaggedLogs) {
+      if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+        privateTaggedLogs.set(
+          taggedLogBuffer.tag,
+          taggedLogBuffer.logBuffers!.concat(privateTaggedLogs.get(taggedLogBuffer.tag)!),
+        );
+      }
+    }
+
+    for (const block of newBlocks) {
+      const privateTagsInBlock: string[] = [];
+      for (const [tag, logs] of privateTaggedLogs.entries()) {
+        await this.#privateLogsByTag.set(tag, logs);
+        privateTagsInBlock.push(tag);
+      }
+      await this.#privateLogKeysByBlock.set(block.number, privateTagsInBlock);
+    }
+  }
 
-      for (const block of blocks) {
-        const blockHash = await block.hash();
+  async #addPublicLogs(blocks: L2BlockNew[]): Promise<void> {
+    const newBlocks = await filterAsync(
+      blocks,
+      async block => !(await this.#publicLogKeysByBlock.hasAsync(block.number)),
+    );
 
-        const privateTagsInBlock: string[] = [];
-        for (const [tag, logs] of privateTaggedLogs.entries()) {
-          await this.#privateLogsByTag.set(tag, logs);
-          privateTagsInBlock.push(tag);
-        }
-        await this.#privateLogKeysByBlock.set(block.number, privateTagsInBlock);
+    const { publicTaggedLogs } = this.#extractTaggedLogs(newBlocks);
+    const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
 
-        const publicKeysInBlock: string[] = [];
-        for (const [key, logs] of publicTaggedLogs.entries()) {
-          await this.#publicLogsByContractAndTag.set(key, logs);
-          publicKeysInBlock.push(key);
-        }
-        await this.#publicLogKeysByBlock.set(block.number, publicKeysInBlock);
-
-        const publicLogsInBlock = block.body.txEffects
-          .map((txEffect, txIndex) =>
-            [
-              numToUInt32BE(txIndex),
-              numToUInt32BE(txEffect.publicLogs.length),
-              txEffect.publicLogs.map(log => log.toBuffer()),
-            ].flat(),
-          )
-          .flat();
-
-        const contractClassLogsInBlock = block.body.txEffects
-          .map((txEffect, txIndex) =>
-            [
-              numToUInt32BE(txIndex),
-              numToUInt32BE(txEffect.contractClassLogs.length),
-              txEffect.contractClassLogs.map(log => log.toBuffer()),
-            ].flat(),
-          )
-          .flat();
-
-        await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
-        await this.#contractClassLogsByBlock.set(
-          block.number,
-          this.#packWithBlockHash(blockHash, contractClassLogsInBlock),
+    const currentPublicTaggedLogs = await Promise.all(
+      keysOfPublicLogsToUpdate.map(async key => ({
+        tag: key,
+        logBuffers: await this.#publicLogsByContractAndTag.getAsync(key),
+      })),
+    );
+
+    for (const taggedLogBuffer of currentPublicTaggedLogs) {
+      if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+        publicTaggedLogs.set(
+          taggedLogBuffer.tag,
+          taggedLogBuffer.logBuffers!.concat(publicTaggedLogs.get(taggedLogBuffer.tag)!),
         );
       }
+    }
+
+    for (const block of newBlocks) {
+      const blockHash = await block.hash();
+      const publicTagsInBlock: string[] = [];
+      for (const [tag, logs] of publicTaggedLogs.entries()) {
+        await this.#publicLogsByContractAndTag.set(tag, logs);
+        publicTagsInBlock.push(tag);
+      }
+      await this.#publicLogKeysByBlock.set(block.number, publicTagsInBlock);
+
+      const publicLogsInBlock = block.body.txEffects
+        .map((txEffect, txIndex) =>
+          [
+            numToUInt32BE(txIndex),
+            numToUInt32BE(txEffect.publicLogs.length),
+            txEffect.publicLogs.map(log => log.toBuffer()),
+          ].flat(),
+        )
+        .flat();
+
+      await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+    }
+  }
 
+  async #addContractClassLogs(blocks: L2BlockNew[]): Promise<void> {
+    const newBlocks = await filterAsync(
+      blocks,
+      async block => !(await this.#contractClassLogsByBlock.hasAsync(block.number)),
+    );
+
+    for (const block of newBlocks) {
+      const blockHash = await block.hash();
+
+      const contractClassLogsInBlock = block.body.txEffects
+        .map((txEffect, txIndex) =>
+          [
+            numToUInt32BE(txIndex),
+            numToUInt32BE(txEffect.contractClassLogs.length),
+            txEffect.contractClassLogs.map(log => log.toBuffer()),
+          ].flat(),
+        )
+        .flat();
+
+      await this.#contractClassLogsByBlock.set(
+        block.number,
+        this.#packWithBlockHash(blockHash, contractClassLogsInBlock),
+      );
+    }
+  }
+
+  /**
+   * Append new logs to the store's list.
+   * @param blocks - The blocks for which to add the logs.
+   * @returns True if the operation is successful.
+   */
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+    return this.db.transactionAsync(async () => {
+      await Promise.all([
+        this.#addPrivateLogs(blocks),
+        this.#addPublicLogs(blocks),
+        this.#addContractClassLogs(blocks),
+      ]);
       return true;
     });
   }

package/src/test/fake_l1_state.ts

@@ -10,8 +10,9 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { CommitteeAttestation, CommitteeAttestationsAndSigners, L2BlockNew } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
 import {
   makeAndSignCommitteeAttestationsAndSigners,
@@ -39,6 +40,8 @@ export type FakeL1StateConfig = {
   rollupAddress: EthAddress;
   /** Inbox address for mock contracts. */
   inboxAddress: EthAddress;
+  /** Aztec slot duration in seconds */
+  slotDuration: number;
 };
 
 /** Options for adding a checkpoint. */
@@ -47,6 +50,8 @@ type AddCheckpointOptions = {
   l1BlockNumber: bigint;
   /** Number of L2 blocks in the checkpoint. Default: 1 */
   numBlocks?: number;
+  /** Or the actual blocks for the checkpoint */
+  blocks?: L2BlockNew[];
   /** Number of transactions per block. Default: 4 */
   txsPerBlock?: number;
   /** Max number of effects per tx (for generating large blobs). Default: undefined */
@@ -157,38 +162,32 @@ export class FakeL1State {
     });
   }
 
+  /**
+   * Creates blocks for a checkpoint without adding them to L1 state.
+   * Useful for creating blocks to pass to addBlock() for testing provisional block handling.
+   * Returns the blocks directly.
+   */
+  public async makeBlocks(checkpointNumber: CheckpointNumber, options: Partial<AddCheckpointOptions>) {
+    return (await this.makeCheckpointAndMessages(checkpointNumber, options)).checkpoint.blocks;
+  }
+
   /**
    * Creates and adds a checkpoint with its L1-to-L2 messages.
    * Returns both the checkpoint and the message leaves.
    * Auto-chains from lastArchive, auto-updates pending status if L1 block >= checkpoint's L1 block.
    */
-  async addCheckpoint(checkpointNumber: CheckpointNumber, options: AddCheckpointOptions): Promise<AddCheckpointResult> {
+  public async addCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    options: AddCheckpointOptions,
+  ): Promise<AddCheckpointResult> {
     this.log.warn(`Adding checkpoint ${checkpointNumber}`);
 
-    const {
-      l1BlockNumber,
-      numBlocks = 1,
-      txsPerBlock = 4,
-      maxEffects,
-      signers = [],
-      slotNumber,
-      previousArchive = this.lastArchive,
-      timestamp,
-      numL1ToL2Messages = 3,
-      messagesL1BlockNumber = l1BlockNumber - 3n,
-    } = options;
+    const { l1BlockNumber, signers = [], messagesL1BlockNumber = l1BlockNumber - 3n } = options;
 
     // Create the checkpoint using the stdlib helper
-    // Only pass slotNumber and timestamp if they're defined to avoid overwriting defaults
-    const { checkpoint, messages, lastArchive } = await mockCheckpointAndMessages(checkpointNumber, {
-      startBlockNumber: this.getNextBlockNumber(checkpointNumber),
-      numBlocks,
-      numTxsPerBlock: txsPerBlock,
-      numL1ToL2Messages,
-      previousArchive,
-      ...(slotNumber !== undefined ? { slotNumber } : {}),
-      ...(timestamp !== undefined ? { timestamp } : {}),
-      ...(maxEffects !== undefined ? { maxEffects } : {}),
+    const { checkpoint, messages, lastArchive } = await this.makeCheckpointAndMessages(checkpointNumber, {
+      ...options,
+      numL1ToL2Messages: options.numL1ToL2Messages ?? 3,
     });
 
     // Store the messages internally so they match the checkpoint's inHash
@@ -219,6 +218,45 @@ export class FakeL1State {
     return { checkpoint, messages };
   }
 
+  /** Creates a checkpoint and messages without adding them to L1 state. */
+  private makeCheckpointAndMessages(checkpointNumber: CheckpointNumber, options: Partial<AddCheckpointOptions>) {
+    const {
+      numBlocks = 1,
+      txsPerBlock = 4,
+      maxEffects,
+      slotNumber,
+      previousArchive = this.lastArchive,
+      timestamp,
+      l1BlockNumber,
+      numL1ToL2Messages = 0,
+      blocks,
+    } = options;
+
+    return mockCheckpointAndMessages(checkpointNumber, {
+      startBlockNumber: this.getNextBlockNumber(checkpointNumber),
+      numBlocks,
+      blocks,
+      numTxsPerBlock: txsPerBlock,
+      numL1ToL2Messages,
+      previousArchive,
+      slotNumber: slotNumber ?? (l1BlockNumber !== undefined ? this.getL2SlotAtL1Block(l1BlockNumber) : undefined),
+      timestamp: timestamp ?? (l1BlockNumber !== undefined ? this.getTimestampAtL1Block(l1BlockNumber) : undefined),
+      ...(maxEffects !== undefined ? { maxEffects } : {}),
+    });
+  }
+
+  /** Returns the L2 slot at the given L1 block (assuming all L1 blocks are mined) */
+  public getL2SlotAtL1Block(l1BlockNumber: bigint): SlotNumber {
+    const timestamp = this.getTimestampAtL1Block(l1BlockNumber);
+    return getSlotAtTimestamp(timestamp, this.config);
+  }
+
+  /** Returns the timestamp at the given L1 block (assuming all L1 blocks are mined) */
+  public getTimestampAtL1Block(l1BlockNumber: bigint): bigint {
+    const { l1GenesisTime, l1StartBlock, ethereumSlotDuration } = this.config;
+    return l1GenesisTime + (l1BlockNumber - l1StartBlock) * BigInt(ethereumSlotDuration);
+  }
+
   /**
    * Sets the current L1 block number.
    * Auto-updates pending checkpoint number based on visible checkpoints.

package/src/test/mock_l2_block_source.ts

@@ -255,6 +255,11 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(blocks);
   }
 
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
+    const blocks = this.l2Blocks.filter(b => b.header.globalVariables.slotNumber === slotNumber);
+    return Promise.resolve(blocks.map(b => b.toL2Block()));
+  }
+
   async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     const blocks = await this.getBlocksForEpoch(epochNumber);
     return blocks.map(b => b.getBlockHeader());