@aztec/archiver 0.55.1 → 0.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/archiver",
-  "version": "0.55.1",
+  "version": "0.56.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -61,15 +61,15 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.55.1",
-    "@aztec/circuits.js": "0.55.1",
-    "@aztec/ethereum": "0.55.1",
-    "@aztec/foundation": "0.55.1",
-    "@aztec/kv-store": "0.55.1",
-    "@aztec/l1-artifacts": "0.55.1",
-    "@aztec/protocol-contracts": "0.55.1",
-    "@aztec/telemetry-client": "0.55.1",
-    "@aztec/types": "0.55.1",
+    "@aztec/circuit-types": "0.56.0",
+    "@aztec/circuits.js": "0.56.0",
+    "@aztec/ethereum": "0.56.0",
+    "@aztec/foundation": "0.56.0",
+    "@aztec/kv-store": "0.56.0",
+    "@aztec/l1-artifacts": "0.56.0",
+    "@aztec/protocol-contracts": "0.56.0",
+    "@aztec/telemetry-client": "0.56.0",
+    "@aztec/types": "0.56.0",
     "debug": "^4.3.4",
     "lodash.groupby": "^4.6.0",
     "lodash.omit": "^4.5.0",

package/src/archiver/archiver.ts

@@ -24,13 +24,12 @@ import {
 import { createEthereumChain } from '@aztec/ethereum';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { compactArray, unique } from '@aztec/foundation/collection';
 import { type EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer } from '@aztec/foundation/timer';
-import { RollupAbi } from '@aztec/l1-artifacts';
+import { InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import {
@@ -43,12 +42,19 @@ import {
 } from '@aztec/types/contracts';
 
 import groupBy from 'lodash.groupby';
-import { type Chain, type HttpTransport, type PublicClient, createPublicClient, getContract, http } from 'viem';
+import {
+  type Chain,
+  type GetContractReturnType,
+  type HttpTransport,
+  type PublicClient,
+  createPublicClient,
+  getContract,
+  http,
+} from 'viem';
 
 import { type ArchiverDataStore } from './archiver_store.js';
 import { type ArchiverConfig } from './config.js';
-import { retrieveBlockFromRollup, retrieveL1ToL2Messages, retrieveL2ProofVerifiedEvents } from './data_retrieval.js';
-import { getL1BlockTime } from './eth_log_handlers.js';
+import { retrieveBlockFromRollup, retrieveL1ToL2Messages } from './data_retrieval.js';
 import { ArchiverInstrumentation } from './instrumentation.js';
 import { type SingletonDataRetrieval } from './structs/data_retrieval.js';
 
@@ -68,6 +74,9 @@ export class Archiver implements ArchiveSource {
    */
   private runningPromise?: RunningPromise;
 
+  private rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>;
+  private inbox: GetContractReturnType<typeof InboxAbi, PublicClient<HttpTransport, Chain>>;
+
   /**
    * Creates a new instance of the Archiver.
    * @param publicClient - A client for interacting with the Ethereum node.
@@ -88,7 +97,19 @@ export class Archiver implements ArchiveSource {
     private readonly instrumentation: ArchiverInstrumentation,
     private readonly l1StartBlock: bigint = 0n,
     private readonly log: DebugLogger = createDebugLogger('aztec:archiver'),
-  ) {}
+  ) {
+    this.rollup = getContract({
+      address: rollupAddress.toString(),
+      abi: RollupAbi,
+      client: publicClient,
+    });
+
+    this.inbox = getContract({
+      address: inboxAddress.toString(),
+      abi: InboxAbi,
+      client: publicClient,
+    });
+  }
 
   /**
    * Creates a new instance of the Archiver and blocks until it syncs from chain.
@@ -179,31 +200,12 @@ export class Archiver implements ArchiveSource {
      * This code does not handle reorgs.
      */
     const {
-      blockBodiesSynchedTo = this.l1StartBlock,
       blocksSynchedTo = this.l1StartBlock,
       messagesSynchedTo = this.l1StartBlock,
       provenLogsSynchedTo = this.l1StartBlock,
     } = await this.store.getSynchPoint();
     const currentL1BlockNumber = await this.publicClient.getBlockNumber();
 
-    if (
-      currentL1BlockNumber <= blocksSynchedTo &&
-      currentL1BlockNumber <= messagesSynchedTo &&
-      currentL1BlockNumber <= blockBodiesSynchedTo &&
-      currentL1BlockNumber <= provenLogsSynchedTo
-    ) {
-      // chain hasn't moved forward
-      // or it's been rolled back
-      this.log.debug(`Nothing to sync`, {
-        currentL1BlockNumber,
-        blocksSynchedTo,
-        messagesSynchedTo,
-        provenLogsSynchedTo,
-        blockBodiesSynchedTo,
-      });
-      return;
-    }
-
     // ********** Ensuring Consistency of data pulled from L1 **********
 
     /**
@@ -223,51 +225,114 @@ export class Archiver implements ArchiveSource {
      * in future but for the time being it should give us the guarantees that we need
      */
 
+    await this.updateLastProvenL2Block(provenLogsSynchedTo, currentL1BlockNumber);
+
     // ********** Events that are processed per L1 block **********
 
+    await this.handleL1ToL2Messages(blockUntilSynced, messagesSynchedTo, currentL1BlockNumber);
+
     // ********** Events that are processed per L2 block **********
+    await this.handleL2blocks(blockUntilSynced, blocksSynchedTo, currentL1BlockNumber);
+  }
+
+  private async handleL1ToL2Messages(
+    blockUntilSynced: boolean,
+    messagesSynchedTo: bigint,
+    currentL1BlockNumber: bigint,
+  ) {
+    if (currentL1BlockNumber <= messagesSynchedTo) {
+      return;
+    }
 
     const retrievedL1ToL2Messages = await retrieveL1ToL2Messages(
-      this.publicClient,
-      this.inboxAddress,
+      this.inbox,
       blockUntilSynced,
       messagesSynchedTo + 1n,
       currentL1BlockNumber,
     );
 
-    if (retrievedL1ToL2Messages.retrievedData.length !== 0) {
+    if (retrievedL1ToL2Messages.retrievedData.length === 0) {
+      await this.store.setMessageSynchedL1BlockNumber(currentL1BlockNumber);
       this.log.verbose(
-        `Retrieved ${retrievedL1ToL2Messages.retrievedData.length} new L1 -> L2 messages between L1 blocks ${
-          messagesSynchedTo + 1n
-        } and ${currentL1BlockNumber}.`,
+        `Retrieved no new L1 -> L2 messages between L1 blocks ${messagesSynchedTo + 1n} and ${currentL1BlockNumber}.`,
       );
+      return;
     }
 
     await this.store.addL1ToL2Messages(retrievedL1ToL2Messages);
 
-    // Read all data from chain and then write to our stores at the end
-    const nextExpectedL2BlockNum = BigInt((await this.store.getSynchedL2BlockNumber()) + 1);
+    this.log.verbose(
+      `Retrieved ${retrievedL1ToL2Messages.retrievedData.length} new L1 -> L2 messages between L1 blocks ${
+        messagesSynchedTo + 1n
+      } and ${currentL1BlockNumber}.`,
+    );
+  }
+
+  private async updateLastProvenL2Block(provenSynchedTo: bigint, currentL1BlockNumber: bigint) {
+    if (currentL1BlockNumber <= provenSynchedTo) {
+      return;
+    }
+
+    const provenBlockNumber = await this.rollup.read.getProvenBlockNumber();
+    if (provenBlockNumber) {
+      await this.store.setProvenL2BlockNumber({
+        retrievedData: Number(provenBlockNumber),
+        lastProcessedL1BlockNumber: currentL1BlockNumber,
+      });
+    }
+  }
+
+  private async handleL2blocks(blockUntilSynced: boolean, blocksSynchedTo: bigint, currentL1BlockNumber: bigint) {
+    if (currentL1BlockNumber <= blocksSynchedTo) {
+      return;
+    }
+
+    const lastBlock = await this.getBlock(-1);
+
+    const [, , pendingBlockNumber, pendingArchive, archiveOfMyBlock] = await this.rollup.read.status([
+      BigInt(lastBlock?.number ?? 0),
+    ]);
+
+    const noBlocksButInitial = lastBlock === undefined && pendingBlockNumber == 0n;
+    const noBlockSinceLast =
+      lastBlock &&
+      pendingBlockNumber === BigInt(lastBlock.number) &&
+      pendingArchive === lastBlock.archive.root.toString();
+
+    if (noBlocksButInitial || noBlockSinceLast) {
+      await this.store.setBlockSynchedL1BlockNumber(currentL1BlockNumber);
+      this.log.verbose(`No blocks to retrieve from ${blocksSynchedTo + 1n} to ${currentL1BlockNumber}`);
+      return;
+    }
+
+    if (lastBlock && archiveOfMyBlock !== lastBlock.archive.root.toString()) {
+      // @todo  Either `prune` have been called, or L1 have re-orged deep enough to remove a block.
+      //        Issue#8620 and Issue#8621
+    }
 
     this.log.debug(`Retrieving blocks from ${blocksSynchedTo + 1n} to ${currentL1BlockNumber}`);
     const retrievedBlocks = await retrieveBlockFromRollup(
+      this.rollup,
       this.publicClient,
-      this.rollupAddress,
       blockUntilSynced,
       blocksSynchedTo + 1n,
       currentL1BlockNumber,
-      nextExpectedL2BlockNum,
+      this.log,
     );
 
-    // Add the body
+    if (retrievedBlocks.length === 0) {
+      await this.store.setBlockSynchedL1BlockNumber(currentL1BlockNumber);
+      this.log.verbose(`Retrieved no new blocks from ${blocksSynchedTo + 1n} to ${currentL1BlockNumber}`);
+      return;
+    }
 
-    (retrievedBlocks.length ? this.log.verbose : this.log.debug)(
-      `Retrieved ${retrievedBlocks.length || 'no'} new L2 blocks between L1 blocks ${
+    this.log.debug(
+      `Retrieved ${retrievedBlocks.length} new L2 blocks between L1 blocks ${
         blocksSynchedTo + 1n
       } and ${currentL1BlockNumber}.`,
     );
 
-    const lastProcessedL1BlockNumber =
-      retrievedBlocks.length > 0 ? retrievedBlocks[retrievedBlocks.length - 1].l1.blockNumber : blocksSynchedTo;
+    const lastProcessedL1BlockNumber = retrievedBlocks[retrievedBlocks.length - 1].l1.blockNumber;
 
     this.log.debug(
       `Processing retrieved blocks ${retrievedBlocks
@@ -275,127 +340,37 @@ export class Archiver implements ArchiveSource {
         .join(',')} with last processed L1 block ${lastProcessedL1BlockNumber}`,
     );
 
-    if (retrievedBlocks.length > 0) {
-      await Promise.all(
-        retrievedBlocks.map(block => {
-          const noteEncryptedLogs = block.data.body.noteEncryptedLogs;
-          const encryptedLogs = block.data.body.encryptedLogs;
-          const unencryptedLogs = block.data.body.unencryptedLogs;
-          return this.store.addLogs(noteEncryptedLogs, encryptedLogs, unencryptedLogs, block.data.number);
-        }),
-      );
-
-      // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-      await Promise.all(
-        retrievedBlocks.map(async block => {
-          const blockLogs = block.data.body.txEffects
-            .flatMap(txEffect => (txEffect ? [txEffect.unencryptedLogs] : []))
-            .flatMap(txLog => txLog.unrollLogs());
-          await this.storeRegisteredContractClasses(blockLogs, block.data.number);
-          await this.storeDeployedContractInstances(blockLogs, block.data.number);
-          await this.storeBroadcastedIndividualFunctions(blockLogs, block.data.number);
-        }),
-      );
-
-      const timer = new Timer();
-      await this.store.addBlockBodies({
-        lastProcessedL1BlockNumber: lastProcessedL1BlockNumber,
-        retrievedData: retrievedBlocks.map(b => b.data.body),
-      });
-      await this.store.addBlocks(retrievedBlocks);
-      this.instrumentation.processNewBlocks(
-        timer.ms() / retrievedBlocks.length,
-        retrievedBlocks.map(b => b.data),
-      );
-      const lastL2BlockNumber = retrievedBlocks[retrievedBlocks.length - 1].data.number;
-      this.log.verbose(`Processed ${retrievedBlocks.length} new L2 blocks up to ${lastL2BlockNumber}`);
-    }
-
-    // Fetch the logs for proven blocks in the block range and update the last proven block number.
-    if (currentL1BlockNumber > provenLogsSynchedTo) {
-      await this.updateLastProvenL2Block(provenLogsSynchedTo + 1n, currentL1BlockNumber);
-    }
-
-    if (retrievedBlocks.length > 0 || blockUntilSynced) {
-      (blockUntilSynced ? this.log.info : this.log.verbose)(`Synced to L1 block ${currentL1BlockNumber}`);
-    }
-  }
-
-  private async updateLastProvenL2Block(fromBlock: bigint, toBlock: bigint) {
-    const logs = await retrieveL2ProofVerifiedEvents(this.publicClient, this.rollupAddress, fromBlock, toBlock);
-    const lastLog = logs[logs.length - 1];
-    if (!lastLog) {
-      return;
-    }
-
-    const provenBlockNumber = lastLog.l2BlockNumber;
-    if (!provenBlockNumber) {
-      throw new Error(`Missing argument blockNumber from L2ProofVerified event`);
-    }
-
-    await this.emitProofVerifiedMetrics(logs);
-
-    const currentProvenBlockNumber = await this.store.getProvenL2BlockNumber();
-    if (provenBlockNumber > currentProvenBlockNumber) {
-      // Update the last proven block number
-      this.log.verbose(`Updated last proven block number from ${currentProvenBlockNumber} to ${provenBlockNumber}`);
-      await this.store.setProvenL2BlockNumber({
-        retrievedData: Number(provenBlockNumber),
-        lastProcessedL1BlockNumber: lastLog.l1BlockNumber,
-      });
-      this.instrumentation.updateLastProvenBlock(Number(provenBlockNumber));
-    } else {
-      // We set the last processed L1 block number to the last L1 block number in the range to avoid duplicate processing
-      await this.store.setProvenL2BlockNumber({
-        retrievedData: Number(currentProvenBlockNumber),
-        lastProcessedL1BlockNumber: lastLog.l1BlockNumber,
-      });
-    }
-  }
-
-  /**
-   * Emits as metrics the block number proven, who proved it, and how much time passed since it was submitted.
-   * @param logs - The ProofVerified logs to emit metrics for, as collected from `retrieveL2ProofVerifiedEvents`.
-   **/
-  private async emitProofVerifiedMetrics(logs: { l1BlockNumber: bigint; l2BlockNumber: bigint; proverId: Fr }[]) {
-    if (!logs.length || !this.instrumentation.isEnabled()) {
-      return;
-    }
-
-    const l1BlockTimes = new Map(
-      await Promise.all(
-        unique(logs.map(log => log.l1BlockNumber)).map(
-          async blockNumber => [blockNumber, await getL1BlockTime(this.publicClient, blockNumber)] as const,
-        ),
-      ),
+    await Promise.all(
+      retrievedBlocks.map(block => {
+        return this.store.addLogs(
+          block.data.body.noteEncryptedLogs,
+          block.data.body.encryptedLogs,
+          block.data.body.unencryptedLogs,
+          block.data.number,
+        );
+      }),
     );
 
-    // Collect L2 block times for all the blocks verified, this is the time in which the block proven was
-    // originally submitted to L1, using the L1 timestamp of the transaction.
-    const getL2BlockTime = async (blockNumber: bigint) =>
-      (await this.store.getBlocks(Number(blockNumber), 1))[0]?.l1.timestamp;
-
-    const l2BlockTimes = new Map(
-      await Promise.all(
-        unique(logs.map(log => log.l2BlockNumber)).map(
-          async blockNumber => [blockNumber, await getL2BlockTime(blockNumber)] as const,
-        ),
-      ),
+    // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
+    await Promise.all(
+      retrievedBlocks.map(async block => {
+        const blockLogs = block.data.body.txEffects
+          .flatMap(txEffect => (txEffect ? [txEffect.unencryptedLogs] : []))
+          .flatMap(txLog => txLog.unrollLogs());
+        await this.storeRegisteredContractClasses(blockLogs, block.data.number);
+        await this.storeDeployedContractInstances(blockLogs, block.data.number);
+        await this.storeBroadcastedIndividualFunctions(blockLogs, block.data.number);
+      }),
     );
 
-    // Emit the prover id and the time difference between block submission and proof.
-    this.instrumentation.processProofsVerified(
-      compactArray(
-        logs.map(log => {
-          const l1BlockTime = l1BlockTimes.get(log.l1BlockNumber)!;
-          const l2BlockTime = l2BlockTimes.get(log.l2BlockNumber);
-          if (!l2BlockTime) {
-            return undefined;
-          }
-          return { ...log, delay: l1BlockTime - l2BlockTime, proverId: log.proverId.toString() };
-        }),
-      ),
+    const timer = new Timer();
+    await this.store.addBlocks(retrievedBlocks);
+    this.instrumentation.processNewBlocks(
+      timer.ms() / retrievedBlocks.length,
+      retrievedBlocks.map(b => b.data),
     );
+    const lastL2BlockNumber = retrievedBlocks[retrievedBlocks.length - 1].data.number;
+    this.log.verbose(`Processed ${retrievedBlocks.length} new L2 blocks up to ${lastL2BlockNumber}`);
   }
 
   /**

package/src/archiver/archiver_store.ts

@@ -1,5 +1,4 @@
 import {
-  type Body,
   type EncryptedL2BlockL2Logs,
   type EncryptedNoteL2BlockL2Logs,
   type FromLogType,
@@ -33,8 +32,6 @@ import { type L1Published } from './structs/published.js';
 export type ArchiverL1SynchPoint = {
   /** Number of the last L1 block that added a new L2 block metadata.  */
   blocksSynchedTo?: bigint;
-  /** Number of the last L1 block that added a new L2 block body.  */
-  blockBodiesSynchedTo?: bigint;
   /** Number of the last L1 block that added L1 -> L2 messages from the Inbox. */
   messagesSynchedTo?: bigint;
   /** Number of the last L1 block that added a new proven block. */
@@ -53,21 +50,6 @@ export interface ArchiverDataStore {
    */
   addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean>;
 
-  /**
-   * Append new block bodies to the store's list.
-   * @param blockBodies - The L2 block bodies to be added to the store.
-   * @returns True if the operation is successful.
-   */
-  addBlockBodies(blockBodies: DataRetrieval<Body>): Promise<boolean>;
-
-  /**
-   * Gets block bodies that have the same txsEffectsHashes as we supply.
-   *
-   * @param txsEffectsHashes - A list of txsEffectsHashes.
-   * @returns The requested L2 block bodies
-   */
-  getBlockBodies(txsEffectsHashes: Buffer[]): Promise<(Body | undefined)[]>;
-
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
@@ -165,6 +147,18 @@ export interface ArchiverDataStore {
    */
   setProvenL2BlockNumber(l2BlockNumber: SingletonDataRetrieval<number>): Promise<void>;
 
+  /**
+   * Stores the l1 block number that blocks have been synched until
+   * @param l1BlockNumber  - The l1 block number
+   */
+  setBlockSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void>;
+
+  /**
+   * Stores the l1 block number that messages have been synched until
+   * @param l1BlockNumber  - The l1 block number
+   */
+  setMessageSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void>;
+
   /**
    * Gets the synch point of the archiver
    */

package/src/archiver/archiver_store_test_suite.ts

@@ -1,4 +1,4 @@
-import { type Body, InboxLeaf, L2Block, LogId, LogType, TxHash } from '@aztec/circuit-types';
+import { InboxLeaf, L2Block, LogId, LogType, TxHash } from '@aztec/circuit-types';
 import '@aztec/circuit-types/jest';
 import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
 import {
@@ -15,7 +15,6 @@ import {
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from './archiver_store.js';
-import { type DataRetrieval } from './structs/data_retrieval.js';
 import { type L1Published } from './structs/published.js';
 
 /**
@@ -26,7 +25,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
   describe(testName, () => {
     let store: ArchiverDataStore;
     let blocks: L1Published<L2Block>[];
-    let blockBodies: DataRetrieval<Body>;
     const blockTests: [number, number, () => L1Published<L2Block>[]][] = [
       [1, 1, () => blocks.slice(0, 1)],
       [10, 1, () => blocks.slice(9, 10)],
@@ -41,17 +39,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         data: L2Block.random(i + 1),
         l1: { blockNumber: BigInt(i + 10), blockHash: `0x${i}`, timestamp: BigInt(i * 1000) },
       }));
-      blockBodies = {
-        retrievedData: blocks.map(block => block.data.body),
-        lastProcessedL1BlockNumber: 4n,
-      };
     });
 
     describe('addBlocks', () => {
-      it('returns success when adding block bodies', async () => {
-        await expect(store.addBlockBodies(blockBodies)).resolves.toBe(true);
-      });
-
       it('returns success when adding blocks', async () => {
         await expect(store.addBlocks(blocks)).resolves.toBe(true);
       });
@@ -65,7 +55,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     describe('getBlocks', () => {
       beforeEach(async () => {
         await store.addBlocks(blocks);
-        await store.addBlockBodies(blockBodies);
       });
 
       it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks) => {
@@ -101,7 +90,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: undefined,
-          blockBodiesSynchedTo: undefined,
           provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
@@ -111,17 +99,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: 19n,
           messagesSynchedTo: undefined,
-          blockBodiesSynchedTo: undefined,
-          provenLogsSynchedTo: undefined,
-        } satisfies ArchiverL1SynchPoint);
-      });
-
-      it('returns the L1 block number in which the most recent L2 block body was published', async () => {
-        await store.addBlockBodies(blockBodies);
-        await expect(store.getSynchPoint()).resolves.toEqual({
-          blocksSynchedTo: undefined,
-          messagesSynchedTo: undefined,
-          blockBodiesSynchedTo: blockBodies.lastProcessedL1BlockNumber,
           provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
@@ -134,7 +111,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: 1n,
-          blockBodiesSynchedTo: undefined,
           provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
@@ -144,7 +120,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: undefined,
-          blockBodiesSynchedTo: undefined,
           provenLogsSynchedTo: 3n,
         } satisfies ArchiverL1SynchPoint);
       });
@@ -212,7 +187,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           ),
         );
         await store.addBlocks(blocks);
-        await store.addBlockBodies(blockBodies);
       });
 
       it.each([
@@ -364,7 +338,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         }));
 
         await store.addBlocks(blocks);
-        await store.addBlockBodies(blockBodies);
 
         await Promise.all(
           blocks.map(block =>