@aztec/archiver 0.24.0 → 0.26.1

package/src/archiver/archiver_store_test_suite.ts

@@ -1,6 +1,5 @@
 import {
   ExtendedContractData,
-  INITIAL_L2_BLOCK_NUM,
   L1ToL2Message,
   L2Block,
   L2BlockContext,
@@ -10,8 +9,8 @@ import {
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import '@aztec/circuit-types/jest';
-import { AztecAddress, Fr } from '@aztec/circuits.js';
-import { makeContractClassPublic } from '@aztec/circuits.js/factories';
+import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { makeContractClassPublic } from '@aztec/circuits.js/testing';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { ContractClassPublic, ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
 
@@ -43,6 +42,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     });
 
     describe('addBlocks', () => {
+      it('returns success when adding block bodies', async () => {
+        await expect(store.addBlockBodies(blocks.map(block => block.body))).resolves.toBe(true);
+      });
+
       it('returns success when adding blocks', async () => {
         await expect(store.addBlocks(blocks)).resolves.toBe(true);
       });
@@ -56,6 +59,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     describe('getBlocks', () => {
       beforeEach(async () => {
         await store.addBlocks(blocks);
+        await store.addBlockBodies(blocks.map(block => block.body));
       });
 
       it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks) => {
@@ -115,7 +119,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns the L1 block number that most recently cancelled pending messages', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 2n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
         await expect(store.getL1BlockNumber()).resolves.toEqual({
           addedBlock: 0n,
           addedMessages: 1n,
@@ -127,7 +131,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     describe('addLogs', () => {
       it('adds encrypted & unencrypted logs', async () => {
         await expect(
-          store.addLogs(blocks[0].newEncryptedLogs, blocks[0].newUnencryptedLogs, blocks[0].number),
+          store.addLogs(blocks[0].body.encryptedLogs, blocks[0].body.unencryptedLogs, blocks[0].number),
         ).resolves.toEqual(true);
       });
     });
@@ -138,25 +142,26 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     ])('getLogs (%s)', (_, logType) => {
       beforeEach(async () => {
         await Promise.all(
-          blocks.map(block => store.addLogs(block.newEncryptedLogs, block.newUnencryptedLogs, block.number)),
+          blocks.map(block => store.addLogs(block.body.encryptedLogs, block.body.unencryptedLogs, block.number)),
         );
       });
 
       it.each(blockTests)('retrieves previously stored logs', async (from, limit, getExpectedBlocks) => {
         const expectedLogs = getExpectedBlocks().map(block =>
-          logType === LogType.ENCRYPTED ? block.newEncryptedLogs : block.newUnencryptedLogs,
+          logType === LogType.ENCRYPTED ? block.body.encryptedLogs : block.body.unencryptedLogs,
         );
         const actualLogs = await store.getLogs(from, limit, logType);
         expect(actualLogs).toEqual(expectedLogs);
       });
     });
 
-    describe('getL2Tx', () => {
+    describe('getTxEffect', () => {
       beforeEach(async () => {
         await Promise.all(
-          blocks.map(block => store.addLogs(block.newEncryptedLogs, block.newUnencryptedLogs, block.number)),
+          blocks.map(block => store.addLogs(block.body.encryptedLogs, block.body.unencryptedLogs, block.number)),
         );
         await store.addBlocks(blocks);
+        await store.addBlockBodies(blocks.map(block => block.body));
       });
 
       it.each([
@@ -167,12 +172,12 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         () => blocks[1].getTx(0),
       ])('retrieves a previously stored transaction', async getExpectedTx => {
         const expectedTx = getExpectedTx();
-        const actualTx = await store.getL2Tx(expectedTx.txHash);
+        const actualTx = await store.getTxEffect(expectedTx.txHash);
         expect(actualTx).toEqual(expectedTx);
       });
 
       it('returns undefined if tx is not found', async () => {
-        await expect(store.getL2Tx(new TxHash(Fr.random().toBuffer()))).resolves.toBeUndefined();
+        await expect(store.getTxEffect(new TxHash(Fr.random().toBuffer()))).resolves.toBeUndefined();
       });
     });
 
@@ -185,7 +190,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const message = L1ToL2Message.random(Fr.random());
         await expect(store.addPendingL1ToL2Messages([message, message], 1n)).resolves.toEqual(true);
 
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey!, message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!, message.entryKey!]);
       });
 
       it('allows duplicate pending messages in different blocks', async () => {
@@ -193,25 +198,26 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.addPendingL1ToL2Messages([message], 1n)).resolves.toEqual(true);
         await expect(store.addPendingL1ToL2Messages([message], 2n)).resolves.toEqual(true);
 
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey!, message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!, message.entryKey!]);
       });
 
       it('is idempotent', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await expect(store.addPendingL1ToL2Messages([message], 1n)).resolves.toEqual(true);
         await expect(store.addPendingL1ToL2Messages([message], 1n)).resolves.toEqual(false);
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!]);
       });
     });
 
-    describe('getPendingL1ToL2Messages', () => {
+    describe('getPendingL1ToL2EntryKeys', () => {
       it('returns previously stored pending L1 to L2 messages', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([message.entryKey!]);
       });
 
-      it('returns messages ordered by fee', async () => {
+      // TODO(@spalladino): Fix and re-enable
+      it.skip('returns messages ordered by fee', async () => {
         const messages = Array.from({ length: 3 }, () => L1ToL2Message.random(Fr.random()));
         // add a duplicate message
         messages.push(messages[0]);
@@ -219,43 +225,43 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await store.addPendingL1ToL2Messages(messages, 1n);
 
         messages.sort((a, b) => b.fee - a.fee);
-        await expect(store.getPendingL1ToL2MessageKeys(messages.length)).resolves.toEqual(
+        await expect(store.getPendingL1ToL2EntryKeys(messages.length)).resolves.toEqual(
           messages.map(message => message.entryKey!),
         );
       });
 
       it('returns an empty array if no messages are found', async () => {
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([]);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
       });
     });
 
-    describe('confirmL1ToL2Messages', () => {
+    describe('confirmL1ToL2EntryKeys', () => {
       it('updates a message from pending to confirmed', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await expect(store.confirmL1ToL2Messages([message.entryKey!])).resolves.toEqual(true);
+        await expect(store.confirmL1ToL2EntryKeys([message.entryKey!])).resolves.toEqual(true);
       });
 
       it('once confirmed, a message is no longer pending', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await store.confirmL1ToL2Messages([message.entryKey!]);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([]);
+        await store.confirmL1ToL2EntryKeys([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
       });
 
       it('once confirmed a message can also be pending if added again', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await store.confirmL1ToL2Messages([message.entryKey!]);
+        await store.confirmL1ToL2EntryKeys([message.entryKey!]);
         await store.addPendingL1ToL2Messages([message], 2n);
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!]);
       });
 
       it('once confirmed a message can remain pending if more of it were pending', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message, message], 1n);
-        await store.confirmL1ToL2Messages([message.entryKey!]);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([message.entryKey!]);
+        await store.confirmL1ToL2EntryKeys([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([message.entryKey!]);
       });
     });
 
@@ -263,62 +269,62 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('cancels a pending message', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 1n);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([]);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 1n);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
       });
 
       it('cancels only one of the pending messages if duplicates exist', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message, message], 1n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 1n);
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey]);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 1n);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey]);
       });
 
       it('once canceled a message can also be pending if added again', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
 
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 1n);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([]);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 1n);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
 
         await store.addPendingL1ToL2Messages([message], 2n);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([message.entryKey!]);
       });
 
       it('allows adding and cancelling in the same block', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message], 1n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 1n);
-        await expect(store.getPendingL1ToL2MessageKeys(1)).resolves.toEqual([]);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 1n);
+        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
       });
 
       it('allows duplicates cancellations in different positions in the same block', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message, message], 1n);
 
-        await store.cancelPendingL1ToL2Messages([message.entryKey!, message.entryKey!], 1n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!, message.entryKey!], 1n);
 
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([]);
       });
 
       it('allows duplicates cancellations in different blocks', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message, message], 1n);
 
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 2n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 3n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 3n);
 
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([]);
       });
 
       it('is idempotent', async () => {
         const message = L1ToL2Message.random(Fr.random());
         await store.addPendingL1ToL2Messages([message, message], 1n);
 
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 2n);
-        await store.cancelPendingL1ToL2Messages([message.entryKey!], 2n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
+        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
 
-        await expect(store.getPendingL1ToL2MessageKeys(2)).resolves.toEqual([message.entryKey!]);
+        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!]);
       });
     });
 
@@ -363,11 +369,12 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       beforeEach(async () => {
         block = L2Block.random(1);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
       });
 
       it('returns previously stored contract data', async () => {
-        await expect(store.getContractData(block.newContractData[0].contractAddress)).resolves.toEqual(
-          block.newContractData[0],
+        await expect(store.getContractData(block.body.txEffects[0].contractData[0].contractAddress)).resolves.toEqual(
+          block.body.txEffects[0].contractData[0],
         );
       });
 
@@ -381,10 +388,13 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       beforeEach(async () => {
         block = L2Block.random(1);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
       });
 
       it('returns the contract data for a known block', async () => {
-        await expect(store.getContractDataInBlock(block.number)).resolves.toEqual(block.newContractData);
+        await expect(store.getContractDataInBlock(block.number)).resolves.toEqual(
+          block.body.txEffects.flatMap(txEffect => txEffect.contractData),
+        );
       });
 
       it('returns an empty array if contract data is not found', async () => {
@@ -396,6 +406,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('stores extended contract data', async () => {
         const block = L2Block.random(1);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
         await expect(store.addExtendedContractData([ExtendedContractData.random()], block.number)).resolves.toEqual(
           true,
         );
@@ -408,11 +419,13 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('"pushes" extended contract data and does not overwrite', async () => {
         const block = L2Block.random(1);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
 
-        const firstContract = ExtendedContractData.random(block.newContractData[0]);
+        // Assuming one contract per tx, and the first two txs
+        const firstContract = ExtendedContractData.random(block.body.txEffects[0].contractData[0]);
         await store.addExtendedContractData([firstContract], block.number);
 
-        const secondContract = ExtendedContractData.random(block.newContractData[1]);
+        const secondContract = ExtendedContractData.random(block.body.txEffects[1].contractData[0]);
         await store.addExtendedContractData([secondContract], block.number);
 
         await expect(store.getExtendedContractDataInBlock(block.number)).resolves.toEqual([
@@ -427,8 +440,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       let extendedContractData: ExtendedContractData;
       beforeEach(async () => {
         block = L2Block.random(1);
-        extendedContractData = ExtendedContractData.random(block.newContractData[0]);
+        extendedContractData = ExtendedContractData.random(block.body.txEffects[0].contractData[0]);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
         await store.addExtendedContractData([extendedContractData], block.number);
       });
 
@@ -448,8 +462,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       let extendedContractData: ExtendedContractData;
       beforeEach(async () => {
         block = L2Block.random(1);
-        extendedContractData = ExtendedContractData.random(block.newContractData[0]);
+        extendedContractData = ExtendedContractData.random(block.body.txEffects[0].contractData[0]);
         await store.addBlocks([block]);
+        await store.addBlockBodies([block.body]);
         await store.addExtendedContractData([extendedContractData], block.number);
       });
 
@@ -477,8 +492,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           );
 
         await store.addBlocks(blocks);
+        await store.addBlockBodies(blocks.map(block => block.body));
+
         await Promise.all(
-          blocks.map(block => store.addLogs(block.newEncryptedLogs, block.newUnencryptedLogs, block.number)),
+          blocks.map(block => store.addLogs(block.body.encryptedLogs, block.body.unencryptedLogs, block.number)),
         );
       });
 
@@ -530,9 +547,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const targetFunctionLogIndex = Math.floor(Math.random() * numPublicFunctionCalls);
         const targetLogIndex = Math.floor(Math.random() * numUnencryptedLogs);
         const targetContractAddress = UnencryptedL2Log.fromBuffer(
-          blocks[targetBlockIndex].newUnencryptedLogs!.txLogs[targetTxIndex].functionLogs[targetFunctionLogIndex].logs[
-            targetLogIndex
-          ],
+          blocks[targetBlockIndex].body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[targetFunctionLogIndex]
+            .logs[targetLogIndex],
         ).contractAddress;
 
         const response = await store.getUnencryptedLogs({ contractAddress: targetContractAddress });
@@ -551,9 +567,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const targetFunctionLogIndex = Math.floor(Math.random() * numPublicFunctionCalls);
         const targetLogIndex = Math.floor(Math.random() * numUnencryptedLogs);
         const targetSelector = UnencryptedL2Log.fromBuffer(
-          blocks[targetBlockIndex].newUnencryptedLogs!.txLogs[targetTxIndex].functionLogs[targetFunctionLogIndex].logs[
-            targetLogIndex
-          ],
+          blocks[targetBlockIndex].body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[targetFunctionLogIndex]
+            .logs[targetLogIndex],
         ).selector;
 
         const response = await store.getUnencryptedLogs({ selector: targetSelector });

package/src/archiver/data_retrieval.ts

@@ -1,5 +1,5 @@
-import { ExtendedContractData, L1ToL2Message, L2Block } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
+import { Body, ExtendedContractData, L1ToL2Message } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, Fr, Header } from '@aztec/circuits.js';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { PublicClient } from 'viem';
@@ -9,10 +9,12 @@ import {
   getL1ToL2MessageCancelledLogs,
   getL2BlockProcessedLogs,
   getPendingL1ToL2MessageLogs,
-  processBlockLogs,
+  getTxsPublishedLogs,
   processCancelledL1ToL2MessagesLogs,
   processContractDeploymentLogs,
+  processL2BlockProcessedLogs,
   processPendingL1ToL2MessageAddedLogs,
+  processTxsPublishedLogs,
 } from './eth_log_handlers.js';
 
 /**
@@ -30,24 +32,24 @@ type DataRetrieval<T> = {
 };
 
 /**
- * Fetches new L2 Blocks.
+ * Fetches new L2 block metadata (header, archive snapshot).
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param rollupAddress - The address of the rollup contract.
  * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of L2 Blocks and the next eth block to search from
+ * @returns An array of tuples representing block metadata including the header, archive tree snapshot, and associated l1 block number; as well as the next eth block to search from.
  */
-export async function retrieveBlocks(
+export async function retrieveBlockMetadataFromRollup(
   publicClient: PublicClient,
   rollupAddress: EthAddress,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   expectedNextL2BlockNum: bigint,
-): Promise<DataRetrieval<L2Block>> {
-  const retrievedBlocks: L2Block[] = [];
+): Promise<DataRetrieval<[Header, AppendOnlyTreeSnapshot, bigint]>> {
+  const retrievedBlockMetadata: [Header, AppendOnlyTreeSnapshot, bigint][] = [];
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
@@ -62,12 +64,55 @@ export async function retrieveBlocks(
       break;
     }
 
-    const newBlocks = await processBlockLogs(publicClient, expectedNextL2BlockNum, l2BlockProcessedLogs);
-    retrievedBlocks.push(...newBlocks);
+    const newBlockMetadata = await processL2BlockProcessedLogs(
+      publicClient,
+      expectedNextL2BlockNum,
+      l2BlockProcessedLogs,
+    );
+    retrievedBlockMetadata.push(...newBlockMetadata);
     searchStartBlock = l2BlockProcessedLogs[l2BlockProcessedLogs.length - 1].blockNumber! + 1n;
-    expectedNextL2BlockNum += BigInt(newBlocks.length);
+    expectedNextL2BlockNum += BigInt(newBlockMetadata.length);
+  } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
+  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedBlockMetadata };
+}
+
+/**
+ * Fetches new L2 block bodies and their hashes.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param availabilityOracleAddress - The address of the availability oracle contract.
+ * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
+ * @param searchStartBlock - The block number to use for starting the search.
+ * @param searchEndBlock - The highest block number that we should search up to.
+ * @returns A array of tuples of L2 block bodies and their associated hash as well as the next eth block to search from
+ */
+export async function retrieveBlockBodiesFromAvailabilityOracle(
+  publicClient: PublicClient,
+  availabilityOracleAddress: EthAddress,
+  blockUntilSynced: boolean,
+  searchStartBlock: bigint,
+  searchEndBlock: bigint,
+): Promise<DataRetrieval<[Body, Buffer]>> {
+  const retrievedBlockBodies: [Body, Buffer][] = [];
+
+  do {
+    if (searchStartBlock > searchEndBlock) {
+      break;
+    }
+    const l2TxsPublishedLogs = await getTxsPublishedLogs(
+      publicClient,
+      availabilityOracleAddress,
+      searchStartBlock,
+      searchEndBlock,
+    );
+    if (l2TxsPublishedLogs.length === 0) {
+      break;
+    }
+
+    const newBlockBodies = await processTxsPublishedLogs(publicClient, l2TxsPublishedLogs);
+    retrievedBlockBodies.push(...newBlockBodies);
+    searchStartBlock = l2TxsPublishedLogs[l2TxsPublishedLogs.length - 1].blockNumber! + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
-  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedBlocks };
+  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedBlockBodies };
 }
 
 /**
@@ -77,7 +122,7 @@ export async function retrieveBlocks(
  * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param blockHashMapping - A mapping from block number to relevant block hash.
+ * @param blockNumberToBodyHash - A mapping from block number to relevant body hash.
  * @returns An array of ExtendedContractData and their equivalent L2 Block number along with the next eth block to search from..
  */
 export async function retrieveNewContractData(
@@ -86,7 +131,7 @@ export async function retrieveNewContractData(
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-  blockHashMapping: { [key: number]: Buffer | undefined },
+  blockNumberToBodyHash: { [key: number]: Buffer | undefined },
 ): Promise<DataRetrieval<[ExtendedContractData[], number]>> {
   let retrievedNewContracts: [ExtendedContractData[], number][] = [];
   do {
@@ -102,7 +147,7 @@ export async function retrieveNewContractData(
     if (contractDataLogs.length === 0) {
       break;
     }
-    const newContracts = processContractDeploymentLogs(blockHashMapping, contractDataLogs);
+    const newContracts = processContractDeploymentLogs(blockNumberToBodyHash, contractDataLogs);
     retrievedNewContracts = retrievedNewContracts.concat(newContracts);
     searchStartBlock = (contractDataLogs.findLast(cd => !!cd)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
@@ -154,7 +199,7 @@ export async function retrieveNewPendingL1ToL2Messages(
  * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of message keys that were cancelled and next eth block to search from.
+ * @returns An array of entry keys that were cancelled and next eth block to search from.
  */
 export async function retrieveNewCancelledL1ToL2Messages(
   publicClient: PublicClient,