@aztec/archiver 0.0.1-commit.2ed92850 → 0.0.1-commit.3469e52

package/src/modules/instrumentation.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import {
   Attributes,
   type Gauge,
@@ -97,7 +97,7 @@ export class ArchiverInstrumentation {
     return this.telemetry.isEnabled();
   }
 
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
+  public processNewBlocks(syncTimePerBlock: number, blocks: L2BlockNew[]) {
     this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
     this.syncBlockCount.add(blocks.length);

package/src/modules/l1_synchronizer.ts

@@ -258,7 +258,7 @@ export class ArchiverL1Synchronizer implements Traceable {
         `Pruning blocks after block ${lastCheckpointedBlockNumber} due to slot ${firstUncheckpointedBlockSlot} not being checkpointed`,
         { firstUncheckpointedBlockHeader: firstUncheckpointedBlockHeader.toInspect(), slotAtNextL1Block },
       );
-      const prunedBlocks = await this.updater.removeUncheckpointedBlocksAfter(lastCheckpointedBlockNumber);
+      const prunedBlocks = await this.updater.removeBlocksAfter(lastCheckpointedBlockNumber);
 
       if (prunedBlocks.length > 0) {
         this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
@@ -331,10 +331,10 @@ export class ArchiverL1Synchronizer implements Traceable {
       this.log.debug(
         `L2 prune from ${provenCheckpointNumber + 1} to ${localPendingCheckpointNumber} will occur on next checkpoint submission.`,
       );
-      await this.updater.removeCheckpointsAfter(provenCheckpointNumber);
+      await this.updater.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
       this.log.warn(
-        `Removed ${count(checkpointsToUnwind, 'checkpoint')} after checkpoint ${provenCheckpointNumber} ` +
-          `due to predicted reorg at L1 block ${currentL1BlockNumber}. ` +
+        `Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` +
+          `to ${provenCheckpointNumber} due to predicted reorg at L1 block ${currentL1BlockNumber}. ` +
           `Updated latest checkpoint is ${await this.store.getSynchedCheckpointNumber()}.`,
       );
       this.instrumentation.processPrune(timer.ms());
@@ -675,11 +675,11 @@ export class ArchiverL1Synchronizer implements Traceable {
           tipAfterUnwind--;
         }
 
-        const checkpointsToRemove = localPendingCheckpointNumber - tipAfterUnwind;
-        await this.updater.removeCheckpointsAfter(CheckpointNumber(tipAfterUnwind));
+        const checkpointsToUnwind = localPendingCheckpointNumber - tipAfterUnwind;
+        await this.updater.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
 
         this.log.warn(
-          `Removed ${count(checkpointsToRemove, 'checkpoint')} after checkpoint ${tipAfterUnwind} ` +
+          `Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` +
             `due to mismatched checkpoint hashes at L1 block ${currentL1BlockNumber}. ` +
             `Updated L2 latest checkpoint is ${await this.store.getSynchedCheckpointNumber()}.`,
         );
@@ -806,8 +806,8 @@ export class ArchiverL1Synchronizer implements Traceable {
         const updatedValidationResult =
           rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
         const [processDuration, result] = await elapsed(() =>
-          execInSpan(this.tracer, 'Archiver.addCheckpoints', () =>
-            this.updater.addCheckpoints(validCheckpoints, updatedValidationResult),
+          execInSpan(this.tracer, 'Archiver.setCheckpointData', () =>
+            this.updater.setNewCheckpointData(validCheckpoints, updatedValidationResult),
           ),
         );
         this.instrumentation.processNewBlocks(

package/src/store/block_store.ts

@@ -12,14 +12,13 @@ import {
   Body,
   CheckpointedL2Block,
   CommitteeAttestation,
-  L2Block,
   L2BlockHash,
+  L2BlockNew,
   type ValidateCheckpointResult,
   deserializeValidateCheckpointResult,
   serializeValidateCheckpointResult,
 } from '@aztec/stdlib/block';
 import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import {
@@ -28,7 +27,6 @@ import {
   TxEffect,
   TxHash,
   TxReceipt,
-  TxStatus,
   deserializeIndexedTxEffect,
   serializeIndexedTxEffect,
 } from '@aztec/stdlib/tx';
@@ -38,7 +36,6 @@ import {
   BlockIndexNotSequentialError,
   BlockNotFoundError,
   BlockNumberNotSequentialError,
-  CannotOverwriteCheckpointedBlockError,
   CheckpointNotFoundError,
   CheckpointNumberNotConsistentError,
   CheckpointNumberNotSequentialError,
@@ -78,8 +75,6 @@ export type CheckpointData = {
   attestations: Buffer[];
 };
 
-export type RemoveCheckpointsResult = { blocksRemoved: L2Block[] | undefined };
-
 /**
  * LMDB-based block storage for the archiver.
  */
@@ -116,10 +111,7 @@ export class BlockStore {
 
   #log = createLogger('archiver:block_store');
 
-  constructor(
-    private db: AztecAsyncKVStore,
-    private l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
-  ) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
     this.#blockTxs = db.openMap('archiver_block_txs');
     this.#txEffects = db.openMap('archiver_tx_effects');
@@ -133,25 +125,11 @@ export class BlockStore {
   }
 
   /**
-   * Computes the finalized block number based on the proven block number.
-   * A block is considered finalized when it's 2 epochs behind the proven block.
-   * TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-   * TODO(palla/mbps): Even the provisional computation is wrong, since it should subtract checkpoints, not blocks
-   * @returns The finalized block number.
-   */
-  async getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    const provenBlockNumber = await this.getProvenBlockNumber();
-    return BlockNumber(Math.max(provenBlockNumber - this.l1Constants.epochDuration * 2, 0));
-  }
-
-  /**
-   * Append new proposed blocks to the store's list. All blocks must be for the 'current' checkpoint.
-   * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
-   * For checkpointed blocks (already published to L1), use addCheckpoints() instead.
-   * @param blocks - The proposed L2 blocks to be added to the store.
+   * Append new blocks to the store's list. All blocks must be for the 'current' checkpoint
+   * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  async addProposedBlocks(blocks: L2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+  async addBlocks(blocks: L2BlockNew[], opts: { force?: boolean } = {}): Promise<boolean> {
     if (blocks.length === 0) {
       return true;
     }
@@ -167,12 +145,6 @@ export class BlockStore {
       const previousBlockNumber = await this.getLatestBlockNumber();
       const previousCheckpointNumber = await this.getLatestCheckpointNumber();
 
-      // Verify we're not overwriting checkpointed blocks
-      const lastCheckpointedBlockNumber = await this.getCheckpointedL2BlockNumber();
-      if (!opts.force && firstBlockNumber <= lastCheckpointedBlockNumber) {
-        throw new CannotOverwriteCheckpointedBlockError(firstBlockNumber, lastCheckpointedBlockNumber);
-      }
-
       // Check that the first block number is the expected one
       if (!opts.force && previousBlockNumber !== firstBlockNumber - 1) {
         throw new InitialBlockNumberNotSequentialError(firstBlockNumber, previousBlockNumber);
@@ -210,7 +182,7 @@ export class BlockStore {
       }
 
       // Iterate over blocks array and insert them, checking that the block numbers and indexes are sequential. Also check they are for the correct checkpoint.
-      let previousBlock: L2Block | undefined = undefined;
+      let previousBlock: L2BlockNew | undefined = undefined;
       for (const block of blocks) {
         if (!opts.force && previousBlock) {
           if (previousBlock.number + 1 !== block.number) {
@@ -269,7 +241,7 @@ export class BlockStore {
       }
 
       let previousBlockNumber: BlockNumber | undefined = undefined;
-      let previousBlock: L2Block | undefined = undefined;
+      let previousBlock: L2BlockNew | undefined = undefined;
 
       // If we have a previous checkpoint then we need to get the previous block number
       if (previousCheckpointData !== undefined) {
@@ -350,7 +322,7 @@ export class BlockStore {
     });
   }
 
-  private async addBlockToDatabase(block: L2Block, checkpointNumber: number, indexWithinCheckpoint: number) {
+  private async addBlockToDatabase(block: L2BlockNew, checkpointNumber: number, indexWithinCheckpoint: number) {
     const blockHash = L2BlockHash.fromField(await block.hash());
 
     await this.#blocks.set(block.number, {
@@ -379,7 +351,7 @@ export class BlockStore {
   }
 
   /** Deletes a block and all associated data (tx effects, indices). */
-  private async deleteBlock(block: L2Block): Promise<void> {
+  private async deleteBlock(block: L2BlockNew): Promise<void> {
     // Delete the block from the main blocks map
     await this.#blocks.delete(block.number);
 
@@ -396,48 +368,51 @@ export class BlockStore {
   }
 
   /**
-   * Removes all checkpoints with checkpoint number > checkpointNumber.
-   * Also removes ALL blocks (both checkpointed and uncheckpointed) after the last block of the given checkpoint.
-   * @param checkpointNumber - Remove all checkpoints strictly after this one.
+   * Unwinds checkpoints from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param checkpointsToUnwind - The number of checkpoints we are to unwind
+   * @returns True if the operation is successful
    */
-  async removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<RemoveCheckpointsResult> {
+  async unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number) {
     return await this.db.transactionAsync(async () => {
-      const latestCheckpointNumber = await this.getLatestCheckpointNumber();
-
-      if (checkpointNumber >= latestCheckpointNumber) {
-        this.#log.warn(`No checkpoints to remove after ${checkpointNumber} (latest is ${latestCheckpointNumber})`);
-        return { blocksRemoved: undefined };
+      const last = await this.getLatestCheckpointNumber();
+      if (from !== last) {
+        throw new Error(`Can only unwind checkpoints from the tip (requested ${from} but current tip is ${last})`);
       }
 
-      // If the proven checkpoint is beyond the target, update it
       const proven = await this.getProvenCheckpointNumber();
-      if (proven > checkpointNumber) {
-        this.#log.warn(`Updating proven checkpoint ${proven} to last valid checkpoint ${checkpointNumber}`);
-        await this.setProvenCheckpointNumber(checkpointNumber);
+      if (from - checkpointsToUnwind < proven) {
+        await this.setProvenCheckpointNumber(CheckpointNumber(from - checkpointsToUnwind));
       }
 
-      // Find the last block number to keep (last block of the given checkpoint, or 0 if no checkpoint)
-      let lastBlockToKeep: BlockNumber;
-      if (checkpointNumber <= 0) {
-        lastBlockToKeep = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
-      } else {
-        const targetCheckpoint = await this.#checkpoints.getAsync(checkpointNumber);
-        if (!targetCheckpoint) {
-          throw new Error(`Target checkpoint ${checkpointNumber} not found in store`);
+      for (let i = 0; i < checkpointsToUnwind; i++) {
+        const checkpointNumber = from - i;
+        const checkpoint = await this.#checkpoints.getAsync(checkpointNumber);
+
+        if (checkpoint === undefined) {
+          this.#log.warn(`Cannot remove checkpoint ${checkpointNumber} from the store since we don't have it`);
+          continue;
         }
-        lastBlockToKeep = BlockNumber(targetCheckpoint.startBlock + targetCheckpoint.numBlocks - 1);
-      }
+        await this.#checkpoints.delete(checkpointNumber);
+        const maxBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
 
-      // Remove all blocks after lastBlockToKeep (both checkpointed and uncheckpointed)
-      const blocksRemoved = await this.removeBlocksAfter(lastBlockToKeep);
+        for (let blockNumber = checkpoint.startBlock; blockNumber <= maxBlock; blockNumber++) {
+          const block = await this.getBlock(BlockNumber(blockNumber));
 
-      // Remove all checkpoints after the target
-      for (let c = latestCheckpointNumber; c > checkpointNumber; c = CheckpointNumber(c - 1)) {
-        await this.#checkpoints.delete(c);
-        this.#log.debug(`Removed checkpoint ${c}`);
+          if (block === undefined) {
+            this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
+            continue;
+          }
+
+          await this.deleteBlock(block);
+          this.#log.debug(
+            `Unwound block ${blockNumber} ${(await block.hash()).toString()} for checkpoint ${checkpointNumber}`,
+          );
+        }
       }
 
-      return { blocksRemoved };
+      return true;
     });
   }
 
@@ -474,7 +449,7 @@ export class BlockStore {
     return data;
   }
 
-  async getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2Block[] | undefined> {
+  async getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
     const checkpoint = await this.#checkpoints.getAsync(checkpointNumber);
     if (!checkpoint) {
       return undefined;
@@ -497,8 +472,8 @@ export class BlockStore {
    * @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<L2Block[]> {
-    const blocks: L2Block[] = [];
+  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
@@ -518,13 +493,12 @@ export class BlockStore {
 
   /**
    * Removes all blocks with block number > blockNumber.
-   * Does not remove any associated checkpoints.
    * @param blockNumber - The block number to remove after.
    * @returns The removed blocks (for event emission).
    */
-  async removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+  async unwindBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
     return await this.db.transactionAsync(async () => {
-      const removedBlocks: L2Block[] = [];
+      const removedBlocks: L2BlockNew[] = [];
 
       // Get the latest block number to determine the range
       const latestBlockNumber = await this.getLatestBlockNumber();
@@ -646,7 +620,7 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<L2Block> {
+  async *getBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<L2BlockNew> {
     for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
       const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
       if (block) {
@@ -660,7 +634,7 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: BlockNumber): Promise<L2Block | undefined> {
+  async getBlock(blockNumber: BlockNumber): Promise<L2BlockNew | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
@@ -673,7 +647,7 @@ export class BlockStore {
    * @param blockHash - The hash of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlockByHash(blockHash: L2BlockHash): Promise<L2Block | undefined> {
+  async getBlockByHash(blockHash: L2BlockHash): Promise<L2BlockNew | undefined> {
     const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
     if (blockNumber === undefined) {
       return undefined;
@@ -686,7 +660,7 @@ export class BlockStore {
    * @param archive - The archive root of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  async getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
     if (blockNumber === undefined) {
       return undefined;
@@ -762,7 +736,7 @@ export class BlockStore {
   private async getBlockFromBlockStorage(
     blockNumber: number,
     blockStorage: BlockStorage,
-  ): Promise<L2Block | undefined> {
+  ): Promise<L2BlockNew | undefined> {
     const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
     const blockHash = blockStorage.blockHash;
@@ -786,7 +760,7 @@ export class BlockStore {
       txEffects.push(deserializeIndexedTxEffect(txEffect).data);
     }
     const body = new Body(txEffects);
-    const block = new L2Block(
+    const block = new L2BlockNew(
       archive,
       header,
       body,
@@ -828,34 +802,13 @@ export class BlockStore {
       return undefined;
     }
 
-    const blockNumber = BlockNumber(txEffect.l2BlockNumber);
-
-    // Use existing archiver methods to determine finalization level
-    const [provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
-      this.getProvenBlockNumber(),
-      this.getCheckpointedL2BlockNumber(),
-      this.getFinalizedL2BlockNumber(),
-    ]);
-
-    let status: TxStatus;
-    if (blockNumber <= finalizedBlockNumber) {
-      status = TxStatus.FINALIZED;
-    } else if (blockNumber <= provenBlockNumber) {
-      status = TxStatus.PROVEN;
-    } else if (blockNumber <= checkpointedBlockNumber) {
-      status = TxStatus.CHECKPOINTED;
-    } else {
-      status = TxStatus.PROPOSED;
-    }
-
     return new TxReceipt(
       txHash,
-      status,
-      TxReceipt.executionResultFromRevertCode(txEffect.data.revertCode),
-      undefined,
+      TxReceipt.statusFromRevertCode(txEffect.data.revertCode),
+      '',
       txEffect.data.transactionFee.toBigInt(),
       txEffect.l2BlockHash,
-      blockNumber,
+      BlockNumber(txEffect.l2BlockNumber),
     );
   }
 

package/src/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, L2Block, L2BlockHash, type ValidateCheckpointResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
@@ -16,7 +16,6 @@ import type {
   ExecutablePrivateFunctionWithMembershipProof,
   UtilityFunctionWithMembershipProof,
 } from '@aztec/stdlib/contract';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
@@ -25,7 +24,7 @@ import type { UInt64 } from '@aztec/stdlib/types';
 import { join } from 'path';
 
 import type { InboxMessage } from '../structs/inbox_message.js';
-import { BlockStore, type CheckpointData, type RemoveCheckpointsResult } from './block_store.js';
+import { BlockStore, type CheckpointData } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
@@ -65,9 +64,8 @@ export class KVArchiverDataStore implements ContractDataSource {
   constructor(
     private db: AztecAsyncKVStore,
     logsMaxPageSize: number = 1000,
-    l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
   ) {
-    this.#blockStore = new BlockStore(db, l1Constants);
+    this.#blockStore = new BlockStore(db);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#messageStore = new MessageStore(db);
     this.#contractClassStore = new ContractClassStore(db);
@@ -103,11 +101,6 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.db.close();
   }
 
-  /** Computes the finalized block number based on the proven block number. */
-  getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getFinalizedL2BlockNumber();
-  }
-
   /** Looks up a public function name given a selector. */
   getDebugFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
     return Promise.resolve(this.functionNames.get(selector.toString()));
@@ -235,14 +228,12 @@ export class KVArchiverDataStore implements ContractDataSource {
   }
 
   /**
-   * Append new proposed blocks to the store's list.
-   * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
-   * For checkpointed blocks (already published to L1), use addCheckpoints() instead.
-   * @param blocks - The proposed L2 blocks to be added to the store.
+   * Append new blocks to the store's list.
+   * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addProposedBlocks(blocks: L2Block[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
-    return this.#blockStore.addProposedBlocks(blocks, opts);
+  addBlocks(blocks: L2BlockNew[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
+    return this.#blockStore.addBlocks(blocks, opts);
   }
 
   /**
@@ -263,12 +254,14 @@ export class KVArchiverDataStore implements ContractDataSource {
   }
 
   /**
-   * Removes all checkpoints with checkpoint number > checkpointNumber.
-   * Also removes ALL blocks (both checkpointed and uncheckpointed) after the last block of the given checkpoint.
-   * @param checkpointNumber - Remove all checkpoints strictly after this one.
+   * Unwinds checkpoints from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param checkpointsToUnwind - The number of checkpoints we are to unwind
+   * @returns True if the operation is successful
    */
-  removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<RemoveCheckpointsResult> {
-    return this.#blockStore.removeCheckpointsAfter(checkpointNumber);
+  unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
+    return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
   }
 
   /**
@@ -305,21 +298,21 @@ export class KVArchiverDataStore implements ContractDataSource {
    * Returns the block for the given number, or undefined if not exists.
    * @param number - The block number to return.
    */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlock(number);
   }
   /**
    * Returns the block for the given hash, or undefined if not exists.
    * @param blockHash - The block hash to return.
    */
-  getBlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
   }
   /**
    * Returns the block for the given archive root, or undefined if not exists.
    * @param archive - The archive root to return.
    */
-  getBlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByArchive(archive);
   }
 
@@ -329,7 +322,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
+  getBlocks(from: BlockNumber, limit: number): Promise<L2BlockNew[]> {
     return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
@@ -392,11 +385,11 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.addLogs(blocks);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.deleteLogs(blocks);
   }
 
@@ -605,7 +598,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param checkpointNumber Retrieves all blocks for the given checkpoint
    * @returns The collection of blocks for the requested checkpoint if available (undefined otherwise)
    */
-  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2Block[] | undefined> {
+  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
     return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
   }
 
@@ -623,17 +616,16 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param slotNumber - The slot number to search for.
    * @returns All blocks with the given slot number.
    */
-  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
     return this.#blockStore.getBlocksForSlot(slotNumber);
   }
 
   /**
    * Removes all blocks with block number > blockNumber.
-   * Does not remove any associated checkpoints.
    * @param blockNumber - The block number to remove after.
    * @returns The removed blocks (for event emission).
    */
-  removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
-    return this.#blockStore.removeBlocksAfter(blockNumber);
+  removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
+    return this.#blockStore.unwindBlocksAfter(blockNumber);
   }
 }

package/src/store/log_store.ts

@@ -6,7 +6,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2Block, L2BlockHash } from '@aztec/stdlib/block';
+import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
 import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
@@ -59,7 +59,7 @@ 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.
    */
-  #extractTaggedLogsFromBlock(block: L2Block) {
+  #extractTaggedLogsFromBlock(block: L2BlockNew) {
     // SiloedTag (as string) -> array of log buffers.
     const privateTaggedLogs = new Map<string, Buffer[]>();
     // "{contractAddress}_{tag}" (as string) -> array of log buffers.
@@ -120,7 +120,7 @@ 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.
    */
-  #extractTaggedLogs(blocks: L2Block[]): {
+  #extractTaggedLogs(blocks: L2BlockNew[]): {
     privateTaggedLogs: Map<string, Buffer[]>;
     publicTaggedLogs: Map<string, Buffer[]>;
   } {
@@ -146,7 +146,7 @@ export class LogStore {
     return { privateTaggedLogs, publicTaggedLogs };
   }
 
-  async #addPrivateLogs(blocks: L2Block[]): Promise<void> {
+  async #addPrivateLogs(blocks: L2BlockNew[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#privateLogKeysByBlock.hasAsync(block.number)),
@@ -181,7 +181,7 @@ export class LogStore {
     }
   }
 
-  async #addPublicLogs(blocks: L2Block[]): Promise<void> {
+  async #addPublicLogs(blocks: L2BlockNew[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#publicLogKeysByBlock.hasAsync(block.number)),
@@ -229,7 +229,7 @@ export class LogStore {
     }
   }
 
-  async #addContractClassLogs(blocks: L2Block[]): Promise<void> {
+  async #addContractClassLogs(blocks: L2BlockNew[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#contractClassLogsByBlock.hasAsync(block.number)),
@@ -260,7 +260,7 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       await Promise.all([
         this.#addPrivateLogs(blocks),
@@ -285,7 +285,7 @@ export class LogStore {
     return L2BlockHash.fromField(blockHash);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       await Promise.all(
         blocks.map(async block => {

package/src/test/fake_l1_state.ts

@@ -10,7 +10,7 @@ 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, L2Block } 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';
@@ -51,7 +51,7 @@ type AddCheckpointOptions = {
   /** Number of L2 blocks in the checkpoint. Default: 1 */
   numBlocks?: number;
   /** Or the actual blocks for the checkpoint */
-  blocks?: L2Block[];
+  blocks?: L2BlockNew[];
   /** Number of transactions per block. Default: 4 */
   txsPerBlock?: number;
   /** Max number of effects per tx (for generating large blobs). Default: undefined */