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

package/src/archiver.ts

@@ -17,7 +17,7 @@ import {
   type ArchiverEmitter,
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
-  L2Block,
+  L2BlockNew,
   type L2BlockSink,
   type L2Tips,
   type ValidateCheckpointResult,
@@ -46,7 +46,7 @@ export type { ArchiverEmitter };
 
 /** Request to add a block to the archiver, queued for processing by the sync loop. */
 type AddBlockRequest = {
-  block: L2Block;
+  block: L2BlockNew;
   resolve: () => void;
   reject: (err: Error) => void;
 };
@@ -187,7 +187,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: L2Block): Promise<void> {
+  public addBlock(block: L2BlockNew): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       this.blockQueue.push({ block, resolve, reject });
       this.log.debug(`Queued block ${block.number} for processing`);
@@ -215,7 +215,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     // Process each block individually to properly resolve/reject each promise
     for (const { block, resolve, reject } of queuedItems) {
       try {
-        await this.updater.addProposedBlocks([block]);
+        await this.updater.addBlocks([block]);
         this.log.debug(`Added block ${block.number} to store`);
         resolve();
       } catch (err: any) {
@@ -323,11 +323,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   }
 
   public async isEpochComplete(epochNumber: EpochNumber): Promise<boolean> {
-    // 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;
+    // The epoch is complete if the current L2 block is the last one in the epoch (or later)
+    const header = await this.getBlockHeader('latest');
     const slot = header ? header.globalVariables.slotNumber : undefined;
     const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
     if (slot && slot >= endSlot) {
@@ -358,8 +355,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     return this.initialSyncComplete;
   }
 
-  public removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
-    return this.updater.removeCheckpointsAfter(checkpointNumber);
+  public unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
+    return this.updater.unwindCheckpoints(from, checkpointsToUnwind);
   }
 
   /** Used by TXE to add checkpoints directly without syncing from L1. */
@@ -367,18 +364,22 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
-    await this.updater.addCheckpoints(checkpoints, pendingChainValidationStatus);
+    await this.updater.setNewCheckpointData(checkpoints, pendingChainValidationStatus);
     return true;
   }
 
   public async getL2Tips(): Promise<L2Tips> {
-    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
+    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
       this.getBlockNumber(),
       this.getProvenBlockNumber(),
-      this.getCheckpointedL2BlockNumber(),
-      this.getFinalizedL2BlockNumber(),
+      this.getCheckpointedBlockNumber(),
     ] 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
@@ -424,12 +425,14 @@ 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.getCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
+        ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
         : [undefined],
       finalizedCheckpointedBlock !== undefined
-        ? await this.getCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
+        ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
+        : [undefined],
+      checkpointedBlock !== undefined
+        ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1)
         : [undefined],
-      checkpointedBlock !== undefined ? await this.getCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [undefined],
     ]);
 
     const initialcheckpointId: CheckpointId = {
@@ -487,12 +490,13 @@ 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 = targetL2Block.checkpointNumber;
+    const targetCheckpointNumber = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
     const targetL1Block = await this.publicClient.getBlock({
       blockNumber: targetL1BlockNumber,
       includeTransactions: false,
@@ -501,11 +505,9 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       throw new Error(`Missing L1 block ${targetL1BlockNumber}`);
     }
     const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
-    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}`);
+    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}`);
     await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
     this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
     await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);

package/src/errors.ts

@@ -88,15 +88,3 @@ 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

@@ -15,7 +15,6 @@ 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';
@@ -32,14 +31,13 @@ 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, l1Constants);
+  return new KVArchiverDataStore(store, config.maxLogs);
 }
 
 /**
@@ -54,7 +52,7 @@ export async function createArchiver(
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config, { epochDuration: config.aztecEpochDuration });
+  const archiverStore = await createArchiverStore(config);
   await registerProtocolContracts(archiverStore);
 
   // Create Ethereum clients

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 
@@ -142,12 +142,7 @@ async function main() {
     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.fromBlockNumber(BlockNumber(l2BlockNumber)),
-      {},
-    );
+    const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber), {});
 
     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, L2Block } from '@aztec/stdlib/block';
+import { Body, CommitteeAttestation, L2BlockNew } 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: L2Block[] = [];
+  const l2Blocks: L2BlockNew[] = [];
   for (let i = 0; i < blocksBlobData.length; i++) {
     const blockBlobData = blocksBlobData[i];
     const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
@@ -119,7 +119,7 @@ export async function retrievedToPublishedCheckpoint({
 
     const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
 
-    l2Blocks.push(new L2Block(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
+    l2Blocks.push(new L2BlockNew(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
   }
 
   const lastBlock = l2Blocks.at(-1)!;

package/src/modules/data_source_base.ts

@@ -4,7 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { isDefined } from '@aztec/foundation/types';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, CommitteeAttestation, L2Block, type L2Tips } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, CommitteeAttestation, L2BlockNew, type L2Tips } from '@aztec/stdlib/block';
 import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
@@ -87,14 +87,10 @@ export abstract class ArchiverDataSourceBase
     return this.store.getCheckpointedBlock(number);
   }
 
-  public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
+  public getCheckpointedBlockNumber(): Promise<BlockNumber> {
     return this.store.getCheckpointedL2BlockNumber();
   }
 
-  public getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    return this.store.getFinalizedL2BlockNumber();
-  }
-
   public async getCheckpointHeader(number: CheckpointNumber | 'latest'): Promise<CheckpointHeader | undefined> {
     if (number === 'latest') {
       number = await this.store.getSynchedCheckpointNumber();
@@ -117,8 +113,18 @@ export abstract class ArchiverDataSourceBase
     return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
   }
 
-  public getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
-    return this.store.getCheckpointedBlocks(from, limit);
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const blocks = await this.store.getCheckpointedBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.block.number <= provenBlockNumber);
+    }
+    return blocks;
   }
 
   public getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
@@ -129,7 +135,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlockHeaderByArchive(archive);
   }
 
-  public async getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
+  public async getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -157,6 +163,16 @@ export abstract class ArchiverDataSourceBase
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
+  public async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
   public getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
     return this.store.getPrivateLogsByTags(tags, page);
   }
@@ -221,7 +237,10 @@ export abstract class ArchiverDataSourceBase
     return this.store.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
-  public async getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]> {
+  public async getPublishedCheckpoints(
+    checkpointNumber: CheckpointNumber,
+    limit: number,
+  ): Promise<PublishedCheckpoint[]> {
     const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
     const blocks = (
       await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
@@ -247,17 +266,17 @@ export abstract class ArchiverDataSourceBase
     return fullCheckpoints;
   }
 
-  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
     return this.store.getBlocksForSlot(slotNumber);
   }
 
-  public async getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
+  public async getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: CheckpointedL2Block[] = [];
+    const blocks: L2BlockNew[] = [];
 
     // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
     // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
@@ -268,9 +287,9 @@ export abstract class ArchiverDataSourceBase
         // push the blocks on backwards
         const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
         for (let i = endBlock; i >= checkpoint.startBlock; i--) {
-          const checkpointedBlock = await this.getCheckpointedBlock(BlockNumber(i));
-          if (checkpointedBlock) {
-            blocks.push(checkpointedBlock);
+          const block = await this.getBlock(BlockNumber(i));
+          if (block) {
+            blocks.push(block);
           }
         }
       }
@@ -280,7 +299,7 @@ export abstract class ArchiverDataSourceBase
     return blocks.reverse();
   }
 
-  public async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+  public async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
@@ -323,7 +342,7 @@ export abstract class ArchiverDataSourceBase
     while (checkpointData && slot(checkpointData) >= start) {
       if (slot(checkpointData) <= end) {
         // push the checkpoints on backwards
-        const [checkpoint] = await this.getCheckpoints(checkpointData.checkpointNumber, 1);
+        const [checkpoint] = await this.getPublishedCheckpoints(checkpointData.checkpointNumber, 1);
         checkpoints.push(checkpoint.checkpoint);
       }
       checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
@@ -332,7 +351,33 @@ export abstract class ArchiverDataSourceBase
     return checkpoints.reverse();
   }
 
-  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+  public async getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]> {
+    const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
+    const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
+    const blocks = (
+      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
+    ).filter(isDefined);
+
+    const publishedBlocks: CheckpointedL2Block[] = [];
+    for (let i = 0; i < checkpoints.length; i++) {
+      const blockForCheckpoint = blocks[i][0];
+      const checkpoint = checkpoints[i];
+      if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
+        // this checkpoint isn't proven and we only want proven
+        continue;
+      }
+      const publishedBlock = new CheckpointedL2Block(
+        checkpoint.checkpointNumber,
+        blockForCheckpoint,
+        checkpoint.l1,
+        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+      );
+      publishedBlocks.push(publishedBlock);
+    }
+    return publishedBlocks;
+  }
+
+  public async getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -343,24 +388,30 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlock(number);
   }
 
-  public getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
-    return this.store.getBlocks(from, limit);
+  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
   }
 
-  public getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByHash(blockHash);
   }
 
-  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByArchive(archive);
   }
 
-  public async getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+  public async getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
     return checkpointedBlock?.block;
   }
 
-  public async getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  public async getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
     return checkpointedBlock?.block;
   }

package/src/modules/data_store_updater.ts

@@ -1,4 +1,4 @@
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import {
@@ -10,7 +10,7 @@ import {
   ContractInstancePublishedEvent,
   ContractInstanceUpdatedEvent,
 } from '@aztec/protocol-contracts/instance-registry';
-import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { L2BlockNew, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type ExecutablePrivateFunctionWithMembershipProof,
@@ -35,7 +35,7 @@ enum Operation {
 /** Result of adding checkpoints with information about any pruned blocks. */
 type ReconcileCheckpointsResult = {
   /** Blocks that were pruned due to conflict with L1 checkpoints. */
-  prunedBlocks: L2Block[] | undefined;
+  prunedBlocks: L2BlockNew[] | undefined;
   /** Last block number that was already inserted locally, or undefined if none. */
   lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
 };
@@ -47,21 +47,17 @@ export class ArchiverDataStoreUpdater {
   constructor(private store: KVArchiverDataStore) {}
 
   /**
-   * Adds proposed blocks to the store with contract class/instance extraction from logs.
-   * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
+   * Adds blocks to the store with contract class/instance extraction from logs.
    * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
    * and individually broadcasted functions from the block logs.
    *
-   * @param blocks - The proposed L2 blocks to add.
+   * @param blocks - The L2 blocks to add.
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */
-  public addProposedBlocks(
-    blocks: L2Block[],
-    pendingChainValidationStatus?: ValidateCheckpointResult,
-  ): Promise<boolean> {
+  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
     return this.store.transactionAsync(async () => {
-      await this.store.addProposedBlocks(blocks);
+      await this.store.addBlocks(blocks);
 
       const opResults = await Promise.all([
         // Update the pending chain validation status if provided
@@ -69,7 +65,7 @@ export class ArchiverDataStoreUpdater {
         // Add any logs emitted during the retrieved blocks
         this.store.addLogs(blocks),
         // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-        ...blocks.map(block => this.addContractDataToDb(block)),
+        ...blocks.map(block => this.addBlockDataToDB(block)),
       ]);
 
       return opResults.every(Boolean);
@@ -78,7 +74,7 @@ export class ArchiverDataStoreUpdater {
 
   /**
    * Reconciles local blocks with incoming checkpoints from L1.
-   * Adds new checkpoints to the store with contract class/instance extraction from logs.
+   * Adds checkpoints to the store with contract class/instance extraction from logs.
    * Prunes any local blocks that conflict with checkpoint data (by comparing archive roots).
    * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
    * and individually broadcasted functions from the checkpoint block logs.
@@ -87,7 +83,7 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns Result with information about any pruned blocks.
    */
-  public addCheckpoints(
+  public setNewCheckpointData(
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<ReconcileCheckpointsResult> {
@@ -97,7 +93,7 @@ export class ArchiverDataStoreUpdater {
 
       await this.store.addCheckpoints(checkpoints);
 
-      // Filter out blocks that were already inserted via addProposedBlocks() to avoid duplicating logs/contract data
+      // Filter out blocks that were already inserted via addBlocks() to avoid duplicating logs/contract data
       const newBlocks = checkpoints
         .flatMap((ch: PublishedCheckpoint) => ch.checkpoint.blocks)
         .filter(b => lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
@@ -108,7 +104,7 @@ export class ArchiverDataStoreUpdater {
         // Add any logs emitted during the retrieved blocks
         this.store.addLogs(newBlocks),
         // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-        ...newBlocks.map(block => this.addContractDataToDb(block)),
+        ...newBlocks.map(block => this.addBlockDataToDB(block)),
       ]);
 
       return { prunedBlocks, lastAlreadyInsertedBlockNumber };
@@ -189,80 +185,80 @@ export class ArchiverDataStoreUpdater {
   }
 
   /**
-   * Removes all uncheckpointed blocks strictly after the specified block number and cleans up associated contract data.
+   * Removes all blocks strictly after the specified block number and cleans up associated contract data.
    * This handles removal of provisionally added blocks along with their contract classes/instances.
-   * Verifies that each block being removed is not part of a stored checkpoint.
    *
    * @param blockNumber - Remove all blocks with number greater than this.
    * @returns The removed blocks.
-   * @throws Error if any block to be removed is checkpointed.
    */
-  public removeUncheckpointedBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
     return this.store.transactionAsync(async () => {
-      // Verify we're only removing uncheckpointed blocks
-      const lastCheckpointedBlockNumber = await this.store.getCheckpointedL2BlockNumber();
-      if (blockNumber < lastCheckpointedBlockNumber) {
-        throw new Error(
-          `Cannot remove blocks after ${blockNumber} because checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`,
-        );
-      }
-
-      return await this.removeBlocksAfter(blockNumber);
-    });
-  }
+      // First get the blocks to be removed so we can clean up contract data
+      const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
 
-  /**
-   * Removes all blocks strictly after the given block number along with any logs and contract data.
-   * Does not remove their checkpoints.
-   */
-  private async removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
-    // First get the blocks to be removed so we can clean up contract data
-    const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
-
-    // Clean up contract data and logs for the removed blocks
-    await Promise.all([
-      this.store.deleteLogs(removedBlocks),
-      ...removedBlocks.map(block => this.removeContractDataFromDb(block)),
-    ]);
+      // Clean up contract data and logs for the removed blocks
+      await Promise.all([
+        this.store.deleteLogs(removedBlocks),
+        ...removedBlocks.map(block => this.removeBlockDataFromDB(block)),
+      ]);
 
-    return removedBlocks;
+      return removedBlocks;
+    });
   }
 
   /**
-   * Removes all checkpoints after the given checkpoint number.
+   * Unwinds checkpoints from the store with reverse contract extraction.
    * Deletes ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated data
-   * that was stored for the removed checkpoints. Also removes ALL blocks (both checkpointed
-   * and uncheckpointed) after the last block of the given checkpoint.
+   * that was stored for the unwound checkpoints.
    *
-   * @param checkpointNumber - Remove all checkpoints strictly after this one.
+   * @param from - The checkpoint number to unwind from (must be the current tip).
+   * @param checkpointsToUnwind - The number of checkpoints to unwind.
    * @returns True if the operation is successful.
    */
-  public async removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
-    const { blocksRemoved = [] } = await this.store.removeCheckpointsAfter(checkpointNumber);
+  public async unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
+    if (checkpointsToUnwind <= 0) {
+      throw new Error(`Cannot unwind ${checkpointsToUnwind} blocks`);
+    }
+
+    const last = await this.store.getSynchedCheckpointNumber();
+    if (from != last) {
+      throw new Error(`Cannot unwind checkpoints from checkpoint ${from} when the last checkpoint is ${last}`);
+    }
+
+    const blocks = [];
+    const lastCheckpointNumber = from + checkpointsToUnwind - 1;
+    for (let checkpointNumber = from; checkpointNumber <= lastCheckpointNumber; checkpointNumber++) {
+      const blocksForCheckpoint = await this.store.getBlocksForCheckpoint(checkpointNumber);
+      if (!blocksForCheckpoint) {
+        continue;
+      }
+      blocks.push(...blocksForCheckpoint);
+    }
 
     const opResults = await Promise.all([
       // Prune rolls back to the last proven block, which is by definition valid
       this.store.setPendingChainValidationStatus({ valid: true }),
-      // Remove contract data for all blocks being removed
-      ...blocksRemoved.map(block => this.removeContractDataFromDb(block)),
-      this.store.deleteLogs(blocksRemoved),
+      // Remove contract data for all blocks being unwound
+      ...blocks.map(block => this.removeBlockDataFromDB(block)),
+      this.store.deleteLogs(blocks),
+      this.store.unwindCheckpoints(from, checkpointsToUnwind),
     ]);
 
     return opResults.every(Boolean);
   }
 
   /** Extracts and stores contract data from a single block. */
-  private addContractDataToDb(block: L2Block): Promise<boolean> {
-    return this.updateContractDataOnDb(block, Operation.Store);
+  private addBlockDataToDB(block: L2BlockNew): Promise<boolean> {
+    return this.editContractBlockData(block, Operation.Store);
   }
 
   /** Removes contract data associated with a block. */
-  private removeContractDataFromDb(block: L2Block): Promise<boolean> {
-    return this.updateContractDataOnDb(block, Operation.Delete);
+  private removeBlockDataFromDB(block: L2BlockNew): Promise<boolean> {
+    return this.editContractBlockData(block, Operation.Delete);
   }
 
   /** Adds or remove contract data associated with a block. */
-  private async updateContractDataOnDb(block: L2Block, operation: Operation): Promise<boolean> {
+  private async editContractBlockData(block: L2BlockNew, operation: Operation): Promise<boolean> {
     const contractClassLogs = block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
     const privateLogs = block.body.txEffects.flatMap(txEffect => txEffect.privateLogs);
     const publicLogs = block.body.txEffects.flatMap(txEffect => txEffect.publicLogs);