@aztec/archiver 0.28.0 → 0.29.0

package/src/archiver/archiver_store_test_suite.ts

@@ -1,13 +1,4 @@
-import {
-  L1ToL2Message,
-  L2Block,
-  L2BlockContext,
-  LogId,
-  LogType,
-  NewInboxLeaf,
-  TxHash,
-  UnencryptedL2Log,
-} from '@aztec/circuit-types';
+import { InboxLeaf, L2Block, L2BlockContext, LogId, LogType, TxHash, UnencryptedL2Log } 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 { makeContractClassPublic } from '@aztec/circuits.js/testing';
@@ -71,7 +62,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
 
       it('throws an error if limit is invalid', async () => {
-        await expect(store.getBlocks(1, 0)).rejects.toThrowError('Invalid limit: 0');
+        await expect(store.getBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
       });
 
       it('resets `from` to the first block if it is out of range', async () => {
@@ -79,64 +70,38 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
     });
 
-    describe('getBlockNumber', () => {
+    describe('getSyncedL2BlockNumber', () => {
       it('returns the block number before INITIAL_L2_BLOCK_NUM if no blocks have been added', async () => {
-        await expect(store.getBlockNumber()).resolves.toEqual(INITIAL_L2_BLOCK_NUM - 1);
+        await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(INITIAL_L2_BLOCK_NUM - 1);
       });
 
       it("returns the most recently added block's number", async () => {
         await store.addBlocks(blocks);
-        await expect(store.getBlockNumber()).resolves.toEqual(blocks.at(-1)!.number);
+        await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(blocks.at(-1)!.number);
       });
     });
 
-    describe('getL1BlockNumber', () => {
+    describe('getSynchedL1BlockNumbers', () => {
       it('returns 0n if no blocks have been added', async () => {
-        await expect(store.getL1BlockNumber()).resolves.toEqual({
-          addedBlock: 0n,
-          addedMessages: 0n,
-          cancelledMessages: 0n,
-          newMessages: 0n,
+        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
+          blocks: 0n,
+          messages: 0n,
         });
       });
 
       it('returns the L1 block number in which the most recent L2 block was published', async () => {
         await store.addBlocks(blocks);
-        await expect(store.getL1BlockNumber()).resolves.toEqual({
-          addedBlock: blocks.at(-1)!.getL1BlockNumber(),
-          addedMessages: 0n,
-          cancelledMessages: 0n,
-          newMessages: 0n,
+        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
+          blocks: blocks.at(-1)!.getL1BlockNumber(),
+          messages: 0n,
         });
       });
 
-      it('returns the L1 block number that most recently added pending messages', async () => {
-        await store.addPendingL1ToL2Messages([L1ToL2Message.random(Fr.random())], 1n);
-        await expect(store.getL1BlockNumber()).resolves.toEqual({
-          addedBlock: 0n,
-          addedMessages: 1n,
-          cancelledMessages: 0n,
-          newMessages: 0n,
-        });
-      });
-      it('returns the L1 block number that most recently added messages from new inbox', async () => {
-        await store.addNewL1ToL2Messages([new NewInboxLeaf(0n, 0n, Fr.ZERO)], 1n);
-        await expect(store.getL1BlockNumber()).resolves.toEqual({
-          addedBlock: 0n,
-          addedMessages: 0n,
-          cancelledMessages: 0n,
-          newMessages: 1n,
-        });
-      });
-      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.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
-        await expect(store.getL1BlockNumber()).resolves.toEqual({
-          addedBlock: 0n,
-          addedMessages: 1n,
-          cancelledMessages: 2n,
-          newMessages: 0n,
+      it('returns the L1 block number that most recently added messages from inbox', async () => {
+        await store.addL1ToL2Messages([new InboxLeaf(0n, 0n, Fr.ZERO)], 1n);
+        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
+          blocks: 0n,
+          messages: 1n,
         });
       });
     });
@@ -194,47 +159,18 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
     });
 
-    describe('addPendingL1ToL2Messages', () => {
-      it('stores pending L1 to L2 messages', async () => {
-        await expect(store.addPendingL1ToL2Messages([L1ToL2Message.random(Fr.random())], 1n)).resolves.toEqual(true);
-      });
-
-      it('allows duplicate pending messages in different positions in the same block', async () => {
-        const message = L1ToL2Message.random(Fr.random());
-        await expect(store.addPendingL1ToL2Messages([message, message], 1n)).resolves.toEqual(true);
-
-        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!, message.entryKey!]);
-      });
-
-      it('allows duplicate pending messages in different blocks', async () => {
-        const message = L1ToL2Message.random(Fr.random());
-        await expect(store.addPendingL1ToL2Messages([message], 1n)).resolves.toEqual(true);
-        await expect(store.addPendingL1ToL2Messages([message], 2n)).resolves.toEqual(true);
-
-        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.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!]);
-      });
-    });
-
-    // TODO(#4492): Drop the "New" below once the old inbox is purged
-    describe('New L1 to L2 Messages', () => {
+    describe('L1 to L2 Messages', () => {
       const l2BlockNumber = 13n;
       const l1ToL2MessageSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
 
       const generateBlockMessages = (blockNumber: bigint, numMessages: number) =>
-        Array.from({ length: numMessages }, (_, i) => new NewInboxLeaf(blockNumber, BigInt(i), Fr.random()));
+        Array.from({ length: numMessages }, (_, i) => new InboxLeaf(blockNumber, BigInt(i), Fr.random()));
 
       it('returns messages in correct order', async () => {
         const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize);
         const shuffledMessages = msgs.slice().sort(() => randomInt(1) - 0.5);
-        await store.addNewL1ToL2Messages(shuffledMessages, 100n);
-        const retrievedMessages = await store.getNewL1ToL2Messages(l2BlockNumber);
+        await store.addL1ToL2Messages(shuffledMessages, 100n);
+        const retrievedMessages = await store.getL1ToL2Messages(l2BlockNumber);
 
         const expectedLeavesOrder = msgs.map(msg => msg.leaf);
         expect(expectedLeavesOrder).toEqual(retrievedMessages);
@@ -244,11 +180,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize - 1);
         // We replace a message with index 4 with a message with index at the end of the tree
         // --> with that there will be a gap and it will be impossible to sequence the messages
-        msgs[4] = new NewInboxLeaf(l2BlockNumber, BigInt(l1ToL2MessageSubtreeSize - 1), Fr.random());
+        msgs[4] = new InboxLeaf(l2BlockNumber, BigInt(l1ToL2MessageSubtreeSize - 1), Fr.random());
 
-        await store.addNewL1ToL2Messages(msgs, 100n);
+        await store.addL1ToL2Messages(msgs, 100n);
         await expect(async () => {
-          await store.getNewL1ToL2Messages(l2BlockNumber);
+          await store.getL1ToL2Messages(l2BlockNumber);
         }).rejects.toThrow(`L1 to L2 message gap found in block ${l2BlockNumber}`);
       });
 
@@ -256,130 +192,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize + 1);
 
         await expect(async () => {
-          await store.addNewL1ToL2Messages(msgs, 100n);
+          await store.addL1ToL2Messages(msgs, 100n);
         }).rejects.toThrow(`Message index ${l1ToL2MessageSubtreeSize} out of subtree range`);
       });
     });
 
-    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.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([message.entryKey!]);
-      });
-
-      // 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]);
-
-        await store.addPendingL1ToL2Messages(messages, 1n);
-
-        messages.sort((a, b) => b.fee - a.fee);
-        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.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
-      });
-    });
-
-    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.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.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.confirmL1ToL2EntryKeys([message.entryKey!]);
-        await store.addPendingL1ToL2Messages([message], 2n);
-        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.confirmL1ToL2EntryKeys([message.entryKey!]);
-        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([message.entryKey!]);
-      });
-    });
-
-    describe('cancelL1ToL2Messages', () => {
-      it('cancels a pending message', async () => {
-        const message = L1ToL2Message.random(Fr.random());
-        await store.addPendingL1ToL2Messages([message], 1n);
-        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.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.cancelPendingL1ToL2EntryKeys([message.entryKey!], 1n);
-        await expect(store.getPendingL1ToL2EntryKeys(1)).resolves.toEqual([]);
-
-        await store.addPendingL1ToL2Messages([message], 2n);
-        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.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.cancelPendingL1ToL2EntryKeys([message.entryKey!, message.entryKey!], 1n);
-
-        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.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
-        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 3n);
-
-        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.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
-        await store.cancelPendingL1ToL2EntryKeys([message.entryKey!], 2n);
-
-        await expect(store.getPendingL1ToL2EntryKeys(2)).resolves.toEqual([message.entryKey!]);
-      });
-    });
-
     describe('contractInstances', () => {
       let contractInstance: ContractInstanceWithAddress;
       const blockNum = 10;

package/src/archiver/data_retrieval.ts

@@ -1,19 +1,15 @@
-import { Body, L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
-import { AppendOnlyTreeSnapshot, Fr, Header } from '@aztec/circuits.js';
+import { Body, InboxLeaf } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, Header } from '@aztec/circuits.js';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { PublicClient } from 'viem';
 
 import {
-  getL1ToL2MessageCancelledLogs,
   getL2BlockProcessedLogs,
   getLeafInsertedLogs,
-  getPendingL1ToL2MessageLogs,
   getTxsPublishedLogs,
-  processCancelledL1ToL2MessagesLogs,
   processL2BlockProcessedLogs,
   processLeafInsertedLogs,
-  processPendingL1ToL2MessageAddedLogs,
   processTxsPublishedLogs,
 } from './eth_log_handlers.js';
 
@@ -116,112 +112,34 @@ export async function retrieveBlockBodiesFromAvailabilityOracle(
 }
 
 /**
- * Fetch new pending L1 to L2 messages.
+ * Fetch L1 to L2 messages.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param inboxAddress - The address of the inbox contract to fetch messages from.
  * @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 L1ToL2Message and next eth block to search from.
+ * @returns An array of InboxLeaf and next eth block to search from.
  */
-export async function retrieveNewPendingL1ToL2Messages(
+export async function retrieveL1ToL2Messages(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-): Promise<DataRetrieval<[L1ToL2Message, bigint]>> {
-  const retrievedNewL1ToL2Messages: [L1ToL2Message, bigint][] = [];
+): Promise<DataRetrieval<InboxLeaf>> {
+  const retrievedL1ToL2Messages: InboxLeaf[] = [];
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const newL1ToL2MessageLogs = await getPendingL1ToL2MessageLogs(
-      publicClient,
-      inboxAddress,
-      searchStartBlock,
-      searchEndBlock,
-    );
-    if (newL1ToL2MessageLogs.length === 0) {
-      break;
-    }
-    const newL1ToL2Messages = processPendingL1ToL2MessageAddedLogs(newL1ToL2MessageLogs);
-    retrievedNewL1ToL2Messages.push(...newL1ToL2Messages);
-    // handles the case when there are no new messages:
-    searchStartBlock = (newL1ToL2MessageLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
-  } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
-  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewL1ToL2Messages };
-}
-
-/**
- * Fetch new L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param newInboxAddress - The address of the inbox contract to fetch messages from.
- * @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 NewInboxLeaf and next eth block to search from.
- */
-export async function retrieveNewL1ToL2Messages(
-  publicClient: PublicClient,
-  newInboxAddress: EthAddress,
-  blockUntilSynced: boolean,
-  searchStartBlock: bigint,
-  searchEndBlock: bigint,
-): Promise<DataRetrieval<NewInboxLeaf>> {
-  const retrievedNewL1ToL2Messages: NewInboxLeaf[] = [];
-  do {
-    if (searchStartBlock > searchEndBlock) {
-      break;
-    }
-    const leafInsertedLogs = await getLeafInsertedLogs(publicClient, newInboxAddress, searchStartBlock, searchEndBlock);
+    const leafInsertedLogs = await getLeafInsertedLogs(publicClient, inboxAddress, searchStartBlock, searchEndBlock);
     if (leafInsertedLogs.length === 0) {
       break;
     }
-    const newL1ToL2Messages = processLeafInsertedLogs(leafInsertedLogs);
-    retrievedNewL1ToL2Messages.push(...newL1ToL2Messages);
+    const l1ToL2Messages = processLeafInsertedLogs(leafInsertedLogs);
+    retrievedL1ToL2Messages.push(...l1ToL2Messages);
     // handles the case when there are no new messages:
     searchStartBlock = (leafInsertedLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
-  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewL1ToL2Messages };
-}
-
-/**
- * Fetch newly cancelled L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @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 entry keys that were cancelled and next eth block to search from.
- * TODO(#4492): Nuke the following when purging the old inbox
- */
-export async function retrieveNewCancelledL1ToL2Messages(
-  publicClient: PublicClient,
-  inboxAddress: EthAddress,
-  blockUntilSynced: boolean,
-  searchStartBlock: bigint,
-  searchEndBlock: bigint,
-): Promise<DataRetrieval<[Fr, bigint]>> {
-  const retrievedNewCancelledL1ToL2Messages: [Fr, bigint][] = [];
-  do {
-    if (searchStartBlock > searchEndBlock) {
-      break;
-    }
-    const newL1ToL2MessageCancelledLogs = await getL1ToL2MessageCancelledLogs(
-      publicClient,
-      inboxAddress,
-      searchStartBlock,
-      searchEndBlock,
-    );
-    if (newL1ToL2MessageCancelledLogs.length === 0) {
-      break;
-    }
-    const newCancelledL1ToL2Messages = processCancelledL1ToL2MessagesLogs(newL1ToL2MessageCancelledLogs);
-    retrievedNewCancelledL1ToL2Messages.push(...newCancelledL1ToL2Messages);
-    // handles the case when there are no new messages:
-    searchStartBlock =
-      (newL1ToL2MessageCancelledLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
-  } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
-  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewCancelledL1ToL2Messages };
+  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedL1ToL2Messages };
 }

package/src/archiver/eth_log_handlers.ts

@@ -1,10 +1,9 @@
-import { Body, L1Actor, L1ToL2Message, L2Actor, NewInboxLeaf } from '@aztec/circuit-types';
+import { Body, InboxLeaf } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, Header } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { AvailabilityOracleAbi, InboxAbi, NewInboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { AvailabilityOracleAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
 
@@ -14,59 +13,16 @@ import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hex
  * @returns Array of all processed LeafInserted logs
  */
 export function processLeafInsertedLogs(
-  logs: Log<bigint, number, false, undefined, true, typeof NewInboxAbi, 'LeafInserted'>[],
-): NewInboxLeaf[] {
-  const leaves: NewInboxLeaf[] = [];
+  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'LeafInserted'>[],
+): InboxLeaf[] {
+  const leaves: InboxLeaf[] = [];
   for (const log of logs) {
     const { blockNumber, index, value } = log.args;
-    leaves.push(new NewInboxLeaf(blockNumber, index, Fr.fromString(value)));
+    leaves.push(new InboxLeaf(blockNumber, index, Fr.fromString(value)));
   }
   return leaves;
 }
 
-/**
- * Processes newly received MessageAdded (L1 to L2) logs.
- * @param logs - MessageAdded logs.
- * @returns Array of all Pending L1 to L2 messages that were processed
- */
-export function processPendingL1ToL2MessageAddedLogs(
-  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[],
-): [L1ToL2Message, bigint][] {
-  const l1ToL2Messages: [L1ToL2Message, bigint][] = [];
-  for (const log of logs) {
-    const { sender, senderChainId, recipient, recipientVersion, content, secretHash, deadline, fee, entryKey } =
-      log.args;
-    l1ToL2Messages.push([
-      new L1ToL2Message(
-        new L1Actor(EthAddress.fromString(sender), Number(senderChainId)),
-        new L2Actor(AztecAddress.fromString(recipient), Number(recipientVersion)),
-        Fr.fromString(content),
-        Fr.fromString(secretHash),
-        deadline,
-        Number(fee),
-        Fr.fromString(entryKey),
-      ),
-      log.blockNumber!,
-    ]);
-  }
-  return l1ToL2Messages;
-}
-
-/**
- * Process newly received L1ToL2MessageCancelled logs.
- * @param logs - L1ToL2MessageCancelled logs.
- * @returns Array of entry keys of the L1 to L2 messages that were cancelled
- */
-export function processCancelledL1ToL2MessagesLogs(
-  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[],
-): [Fr, bigint][] {
-  const cancelledL1ToL2Messages: [Fr, bigint][] = [];
-  for (const log of logs) {
-    cancelledL1ToL2Messages.push([Fr.fromString(log.args.entryKey), log.blockNumber!]);
-  }
-  return cancelledL1ToL2Messages;
-}
-
 /**
  * Processes newly received L2BlockProcessed logs.
  * @param publicClient - The viem public client to use for transaction retrieval.
@@ -235,73 +191,23 @@ export function getTxsPublishedLogs(
 }
 
 /**
- * Get relevant `MessageAdded` logs emitted by Inbox on chain.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract.
- * @param fromBlock - First block to get logs from (inclusive).
- * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `MessageAdded` logs.
- */
-export function getPendingL1ToL2MessageLogs(
-  publicClient: PublicClient,
-  inboxAddress: EthAddress,
-  fromBlock: bigint,
-  toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[]> {
-  return publicClient.getLogs({
-    address: getAddress(inboxAddress.toString()),
-    event: getAbiItem({
-      abi: InboxAbi,
-      name: 'MessageAdded',
-    }),
-    fromBlock,
-    toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
-  });
-}
-
-/**
- * Get relevant `L1ToL2MessageCancelled` logs emitted by Inbox on chain when pending messages are cancelled
+ * Get relevant `LeafInserted` logs emitted by Inbox on chain.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param inboxAddress - The address of the inbox contract.
  * @param fromBlock - First block to get logs from (inclusive).
  * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `L1ToL2MessageCancelled` logs.
+ * @returns An array of `LeafInserted` logs.
  */
-export function getL1ToL2MessageCancelledLogs(
+export function getLeafInsertedLogs(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[]> {
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'LeafInserted'>[]> {
   return publicClient.getLogs({
     address: getAddress(inboxAddress.toString()),
     event: getAbiItem({
       abi: InboxAbi,
-      name: 'L1ToL2MessageCancelled',
-    }),
-    fromBlock,
-    toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
-  });
-}
-
-/**
- * Get relevant `LeafInserted` logs emitted by NewInbox on chain.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param newInboxAddress - The address of the new inbox contract.
- * @param fromBlock - First block to get logs from (inclusive).
- * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `LeafInserted` logs.
- */
-export function getLeafInsertedLogs(
-  publicClient: PublicClient,
-  newInboxAddress: EthAddress,
-  fromBlock: bigint,
-  toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof NewInboxAbi, 'LeafInserted'>[]> {
-  return publicClient.getLogs({
-    address: getAddress(newInboxAddress.toString()),
-    event: getAbiItem({
-      abi: NewInboxAbi,
       name: 'LeafInserted',
     }),
     fromBlock,

package/src/archiver/kv_archiver_store/block_store.ts

@@ -155,7 +155,7 @@ export class BlockStore {
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getBlockNumber(): number {
+  getSynchedL2BlockNumber(): number {
     const [lastBlockNumber] = this.#blocks.keys({ reverse: true, limit: 1 });
     return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
   }
@@ -164,7 +164,7 @@ export class BlockStore {
    * Gets the most recent L1 block processed.
    * @returns The L1 block that published the latest L2 block
    */
-  getL1BlockNumber(): bigint {
+  getSynchedL1BlockNumber(): bigint {
     const [lastBlock] = this.#blocks.values({ reverse: true, limit: 1 });
     if (!lastBlock) {
       return 0n;