@aztec/archiver 0.1.0-alpha23 → 0.1.0-alpha40

package/src/archiver/archiver_store.ts

@@ -1,19 +1,20 @@
+import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
 import {
-  ContractPublicData,
-  L2Block,
-  INITIAL_L2_BLOCK_NUM,
   ContractData,
+  ContractDataAndBytecode,
+  INITIAL_L2_BLOCK_NUM,
   L1ToL2Message,
+  L2Block,
   L2BlockL2Logs,
   LogType,
 } from '@aztec/types';
-import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+
 import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
 /**
  * Interface describing a data store to be used by the archiver to store all its relevant data
- * (blocks, encrypted logs, aztec contract public data).
+ * (blocks, encrypted logs, aztec contract data and bytecode).
  */
 export interface ArchiverDataStore {
   /**
@@ -24,12 +25,12 @@ export interface ArchiverDataStore {
   addL2Blocks(blocks: L2Block[]): Promise<boolean>;
 
   /**
-   * Gets the `take` amount of L2 blocks starting from `from`.
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
-   * @param take - The number of blocks to return.
+   * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getL2Blocks(from: number, take: number): Promise<L2Block[]>;
+  getL2Blocks(from: number, limit: number): Promise<L2Block[]>;
 
   /**
    * Append new logs to the store's list.
@@ -62,11 +63,11 @@ export interface ArchiverDataStore {
   confirmL1ToL2Messages(messageKeys: Fr[]): Promise<boolean>;
 
   /**
-   * Gets the `take` amount of pending L1 to L2 messages, sorted by fee
-   * @param take - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
+   * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
+   * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
    * @returns The requested L1 to L2 message keys.
    */
-  getPendingL1ToL2MessageKeys(take: number): Promise<Fr[]>;
+  getPendingL1ToL2MessageKeys(limit: number): Promise<Fr[]>;
 
   /**
    * Gets the confirmed L1 to L2 message corresponding to the given message key.
@@ -76,35 +77,35 @@ export interface ArchiverDataStore {
   getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message>;
 
   /**
-   * Gets the `take` amount of logs starting from `from`.
+   * Gets up to `limit` amount of logs starting from `from`.
    * @param from - Number of the L2 block to which corresponds the first logs to be returned.
-   * @param take - The number of logs to return.
+   * @param limit - The number of logs to return.
    * @param logType - Specifies whether to return encrypted or unencrypted logs.
    * @returns The requested logs.
    */
-  getLogs(from: number, take: number, logType: LogType): Promise<L2BlockL2Logs[]>;
+  getLogs(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]>;
 
   /**
-   * Store new Contract Public Data from an L2 block to the store's list.
+   * Store new Contract data and bytecode from an L2 block to the store's list.
    * @param data - List of contracts' data to be added.
    * @param blockNum - Number of the L2 block the contract data was deployed in.
    * @returns True if the operation is successful.
    */
-  addL2ContractPublicData(data: ContractPublicData[], blockNum: number): Promise<boolean>;
+  addContractDataAndBytecode(data: ContractDataAndBytecode[], blockNum: number): Promise<boolean>;
 
   /**
    * Lookup the L2 contract data for a contract address.
    * @param contractAddress - The contract data address.
    * @returns The contract's public data.
    */
-  getL2ContractPublicData(contractAddress: AztecAddress): Promise<ContractPublicData | undefined>;
+  getContractDataAndBytecode(contractAddress: AztecAddress): Promise<ContractDataAndBytecode | undefined>;
 
   /**
-   * Lookup all contract data in an L2 block.
+   * Lookup all contract data and bytecode in an L2 block.
    * @param blockNum - The block number to get all contract data from.
-   * @returns All contract public data in the block (if found).
+   * @returns All contract data and bytecode in the block (if found).
    */
-  getL2ContractPublicDataInBlock(blockNum: number): Promise<ContractPublicData[]>;
+  getContractDataAndBytecodeInBlock(blockNum: number): Promise<ContractDataAndBytecode[]>;
 
   /**
    * Get basic info for an L2 contract.
@@ -112,7 +113,7 @@ export interface ArchiverDataStore {
    * @param contractAddress - The contract data address.
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
-  getL2ContractInfo(contractAddress: AztecAddress): Promise<ContractData | undefined>;
+  getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined>;
 
   /**
    * Get basic info for an all L2 contracts deployed in a block.
@@ -120,7 +121,7 @@ export interface ArchiverDataStore {
    * @param l2BlockNum - Number of the L2 block where contracts were deployed.
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
-  getL2ContractInfoInBlock(l2BlockNum: number): Promise<ContractData[] | undefined>;
+  getContractDataInBlock(l2BlockNum: number): Promise<ContractData[] | undefined>;
 
   /**
    * Gets the number of the latest L2 block processed.
@@ -157,9 +158,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   private unencryptedLogs: L2BlockL2Logs[] = [];
 
   /**
-   * A sparse array containing all the contract data that have been fetched so far.
+   * A sparse array containing all the contract data and bytecode that have been fetched so far.
    */
-  private contractPublicData: (ContractPublicData[] | undefined)[] = [];
+  private contractDataAndBytecodeByBlock: (ContractDataAndBytecode[] | undefined)[] = [];
+
+  /**
+   * A mapping of contract address to contract data and bytecode.
+   */
+  private contractDataAndBytecode: Map<string, ContractDataAndBytecode> = new Map();
 
   /**
    * Contains all the confirmed L1 to L2 messages (i.e. messages that were consumed in an L2 block)
@@ -234,45 +240,53 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * Store new Contract Public Data from an L2 block to the store's list.
+   * Store new Contract data and bytecode from an L2 block to the store's list.
    * @param data - List of contracts' data to be added.
    * @param blockNum - Number of the L2 block the contract data was deployed in.
    * @returns True if the operation is successful (always in this implementation).
    */
-  public addL2ContractPublicData(data: ContractPublicData[], blockNum: number): Promise<boolean> {
-    if (this.contractPublicData[blockNum]?.length) {
-      this.contractPublicData[blockNum]?.push(...data);
+  public addContractDataAndBytecode(data: ContractDataAndBytecode[], blockNum: number): Promise<boolean> {
+    // Add to the contracts mapping
+    for (const contractData of data) {
+      const key = contractData.contractData.contractAddress.toString();
+      this.contractDataAndBytecode.set(key, contractData);
+    }
+
+    // Add the index per block
+    if (this.contractDataAndBytecodeByBlock[blockNum]?.length) {
+      this.contractDataAndBytecodeByBlock[blockNum]?.push(...data);
     } else {
-      this.contractPublicData[blockNum] = [...data];
+      this.contractDataAndBytecodeByBlock[blockNum] = [...data];
     }
     return Promise.resolve(true);
   }
 
   /**
-   * Gets the `take` amount of L2 blocks starting from `from`.
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
-   * @param take - The number of blocks to return.
+   * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  public getL2Blocks(from: number, take: number): Promise<L2Block[]> {
-    if (from < INITIAL_L2_BLOCK_NUM) {
-      throw new Error(`Invalid block range ${from}`);
+  public getL2Blocks(from: number, limit: number): Promise<L2Block[]> {
+    // Return an empty array if we are outside of range
+    if (limit < 1) {
+      throw new Error(`Invalid block range from: ${from}, limit: ${limit}`);
     }
-    if (from > this.l2Blocks.length) {
+    if (from < INITIAL_L2_BLOCK_NUM || from > this.l2Blocks.length) {
       return Promise.resolve([]);
     }
     const startIndex = from - INITIAL_L2_BLOCK_NUM;
-    const endIndex = from + take;
+    const endIndex = startIndex + limit;
     return Promise.resolve(this.l2Blocks.slice(startIndex, endIndex));
   }
 
   /**
-   * Gets the `take` amount of pending L1 to L2 messages, sorted by fee
-   * @param take - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
+   * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
+   * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
    * @returns The requested L1 to L2 message keys.
    */
-  public getPendingL1ToL2MessageKeys(take: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
-    return Promise.resolve(this.pendingL1ToL2Messages.getMessageKeys(take));
+  public getPendingL1ToL2MessageKeys(limit: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
+    return Promise.resolve(this.pendingL1ToL2Messages.getMessageKeys(limit));
   }
 
   /**
@@ -283,28 +297,28 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   public getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
     const message = this.confirmedL1ToL2Messages.getMessage(messageKey);
     if (!message) {
-      throw new Error(`Message with key ${messageKey.toString()} not found`);
+      throw new Error(`L1 to L2 Message with key ${messageKey.toString()} not found in the confirmed messages store`);
     }
     return Promise.resolve(message);
   }
 
   /**
-   * Gets the `take` amount of logs starting from `from`.
+   * Gets up to `limit` amount of logs starting from `from`.
    * @param from - Number of the L2 block to which corresponds the first logs to be returned.
-   * @param take - The number of logs to return.
+   * @param limit - The number of logs to return.
    * @param logType - Specifies whether to return encrypted or unencrypted logs.
    * @returns The requested logs.
    */
-  getLogs(from: number, take: number, logType: LogType): Promise<L2BlockL2Logs[]> {
-    if (from < INITIAL_L2_BLOCK_NUM) {
-      throw new Error(`Invalid block range ${from}`);
+  getLogs(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
+    if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
+      throw new Error(`Invalid block range from: ${from}, limit: ${limit}`);
     }
     const logs = logType === LogType.ENCRYPTED ? this.encryptedLogs : this.unencryptedLogs;
     if (from > logs.length) {
       return Promise.resolve([]);
     }
     const startIndex = from - INITIAL_L2_BLOCK_NUM;
-    const endIndex = from + take;
+    const endIndex = startIndex + limit;
     return Promise.resolve(logs.slice(startIndex, endIndex));
   }
 
@@ -313,29 +327,21 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param contractAddress - The contract data address.
    * @returns The contract's public data.
    */
-  public getL2ContractPublicData(contractAddress: AztecAddress): Promise<ContractPublicData | undefined> {
-    let result;
-    for (let i = INITIAL_L2_BLOCK_NUM; i < this.contractPublicData.length; i++) {
-      const contracts = this.contractPublicData[i];
-      const contract = contracts?.find(c => c.contractData.contractAddress.equals(contractAddress));
-      if (contract) {
-        result = contract;
-        break;
-      }
-    }
+  public getContractDataAndBytecode(contractAddress: AztecAddress): Promise<ContractDataAndBytecode | undefined> {
+    const result = this.contractDataAndBytecode.get(contractAddress.toString());
     return Promise.resolve(result);
   }
 
   /**
    * Lookup all contract data in an L2 block.
    * @param blockNum - The block number to get all contract data from.
-   * @returns All contract public data in the block (if found).
+   * @returns All contract data and bytecode in the block (if found).
    */
-  public getL2ContractPublicDataInBlock(blockNum: number): Promise<ContractPublicData[]> {
+  public getContractDataAndBytecodeInBlock(blockNum: number): Promise<ContractDataAndBytecode[]> {
     if (blockNum > this.l2Blocks.length) {
       return Promise.resolve([]);
     }
-    return Promise.resolve(this.contractPublicData[blockNum] || []);
+    return Promise.resolve(this.contractDataAndBytecodeByBlock[blockNum] || []);
   }
 
   /**
@@ -344,7 +350,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param contractAddress - The contract data address.
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
-  public getL2ContractInfo(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+  public getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+    if (contractAddress.isZero()) {
+      return Promise.resolve(undefined);
+    }
     for (const block of this.l2Blocks) {
       for (const contractData of block.newContractData) {
         if (contractData.contractAddress.equals(contractAddress)) {
@@ -361,7 +370,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param l2BlockNum - Number of the L2 block where contracts were deployed.
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
-  public getL2ContractInfoInBlock(l2BlockNum: number): Promise<ContractData[] | undefined> {
+  public getContractDataInBlock(l2BlockNum: number): Promise<ContractData[] | undefined> {
     if (l2BlockNum > this.l2Blocks.length) {
       return Promise.resolve([]);
     }

package/src/archiver/config.ts

@@ -1,6 +1,13 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { L1Addresses } from '@aztec/types';
 
+/**
+ * There are 2 polling intervals used in this configuration. The first is the archiver polling interval, archiverPollingIntervalMS.
+ * This is the interval between successive calls to eth_blockNumber via viem.
+ * Results of calls to eth_blockNumber are cached by viem with this cache being updated periodically at the interval specified by viemPollingIntervalMS.
+ * As a result the maximum observed polling time for new blocks will be viemPollingIntervalMS + archiverPollingIntervalMS.
+ */
+
 /**
  * The archiver configuration.
  */
@@ -18,7 +25,12 @@ export interface ArchiverConfig extends L1Addresses {
   /**
    * The polling interval in ms for retrieving new L2 blocks and encrypted logs.
    */
-  archiverPollingInterval?: number;
+  archiverPollingIntervalMS?: number;
+
+  /**
+   * The polling interval viem uses in ms
+   */
+  viemPollingIntervalMS?: number;
 
   /**
    * Eth block from which we start scanning for L2Blocks.
@@ -34,7 +46,8 @@ export interface ArchiverConfig extends L1Addresses {
 export function getConfigEnvVars(): ArchiverConfig {
   const {
     ETHEREUM_HOST,
-    ARCHIVER_POLLING_INTERVAL,
+    ARCHIVER_POLLING_INTERVAL_MS,
+    ARCHIVER_VIEM_POLLING_INTERVAL_MS,
     ROLLUP_CONTRACT_ADDRESS,
     CONTRACT_DEPLOYMENT_EMITTER_ADDRESS,
     SEARCH_START_BLOCK,
@@ -43,7 +56,8 @@ export function getConfigEnvVars(): ArchiverConfig {
   } = process.env;
   return {
     rpcUrl: ETHEREUM_HOST || 'http://127.0.0.1:8545/',
-    archiverPollingInterval: ARCHIVER_POLLING_INTERVAL ? +ARCHIVER_POLLING_INTERVAL : 1_000,
+    archiverPollingIntervalMS: ARCHIVER_POLLING_INTERVAL_MS ? +ARCHIVER_POLLING_INTERVAL_MS : 1_000,
+    viemPollingIntervalMS: ARCHIVER_VIEM_POLLING_INTERVAL_MS ? +ARCHIVER_VIEM_POLLING_INTERVAL_MS : 1_000,
     rollupContract: ROLLUP_CONTRACT_ADDRESS ? EthAddress.fromString(ROLLUP_CONTRACT_ADDRESS) : EthAddress.ZERO,
     inboxContract: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
     contractDeploymentEmitterContract: CONTRACT_DEPLOYMENT_EMITTER_ADDRESS

package/src/archiver/data_retrieval.ts

@@ -1,17 +1,19 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { ContractDataAndBytecode, L1ToL2Message, L2Block } from '@aztec/types';
+
 import { PublicClient } from 'viem';
+
 import {
   getContractDeploymentLogs,
+  getL1ToL2MessageCancelledLogs,
   getL2BlockProcessedLogs,
   getPendingL1ToL2MessageLogs,
-  getL1ToL2MessageCancelledLogs,
   processBlockLogs,
+  processCancelledL1ToL2MessagesLogs,
   processContractDeploymentLogs,
   processPendingL1ToL2MessageAddedLogs,
-  processCancelledL1ToL2MessagesLogs,
 } from './eth_log_handlers.js';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { ContractPublicData, L1ToL2Message, L2Block } from '@aztec/types';
-import { Fr } from '@aztec/foundation/fields';
 
 /**
  * Data retrieved from logs
@@ -71,7 +73,7 @@ export async function retrieveBlocks(
  * @param currentBlockNumber - Latest available block number in the ETH node.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param blockHashMapping - A mapping from block number to relevant block hash.
- * @returns An array of ContractPublicData and their equivalent L2 Block number along with the next eth block to search from..
+ * @returns An array of ContractDataAndBytecode and their equivalent L2 Block number along with the next eth block to search from..
  */
 export async function retrieveNewContractData(
   publicClient: PublicClient,
@@ -80,8 +82,8 @@ export async function retrieveNewContractData(
   currentBlockNumber: bigint,
   searchStartBlock: bigint,
   blockHashMapping: { [key: number]: Buffer | undefined },
-): Promise<DataRetrieval<[ContractPublicData[], number]>> {
-  let retrievedNewContracts: [ContractPublicData[], number][] = [];
+): Promise<DataRetrieval<[ContractDataAndBytecode[], number]>> {
+  let retrievedNewContracts: [ContractDataAndBytecode[], number][] = [];
   do {
     if (searchStartBlock > currentBlockNumber) {
       break;

package/src/archiver/eth_log_handlers.ts

@@ -1,18 +1,19 @@
-import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
-import { InboxAbi, RollupAbi, ContractDeploymentEmitterAbi } from '@aztec/l1-artifacts';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import { ContractDeploymentEmitterAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 import {
-  L1ToL2Message,
-  L1Actor,
-  L2Actor,
-  L2Block,
-  ContractPublicData,
   BufferReader,
   ContractData,
+  ContractDataAndBytecode,
   EncodedContractFunction,
+  L1Actor,
+  L1ToL2Message,
+  L2Actor,
+  L2Block,
 } from '@aztec/types';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+
+import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
 
 /**
  * Processes newly received MessageAdded (L1 to L2) logs.
@@ -162,13 +163,13 @@ export async function getContractDeploymentLogs(
  * Processes newly received ContractDeployment logs.
  * @param blockHashMapping - A mapping from block number to relevant block hash.
  * @param logs - ContractDeployment logs.
- * @returns The set of retrieved contract public data items.
+ * @returns The set of retrieved contract data and bytecode items.
  */
 export function processContractDeploymentLogs(
   blockHashMapping: { [key: number]: Buffer | undefined },
   logs: Log<bigint, number, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[],
-): [ContractPublicData[], number][] {
-  const contractPublicData: [ContractPublicData[], number][] = [];
+): [ContractDataAndBytecode[], number][] {
+  const contractDataAndBytecode: [ContractDataAndBytecode[], number][] = [];
   for (let i = 0; i < logs.length; i++) {
     const log = logs[i];
     const l2BlockNum = Number(log.args.l2BlockNum);
@@ -178,17 +179,17 @@ export function processContractDeploymentLogs(
       continue;
     }
     const publicFnsReader = BufferReader.asReader(Buffer.from(log.args.acir.slice(2), 'hex'));
-    const contractData = new ContractPublicData(
+    const contractData = new ContractDataAndBytecode(
       new ContractData(AztecAddress.fromString(log.args.aztecAddress), EthAddress.fromString(log.args.portalAddress)),
       publicFnsReader.readVector(EncodedContractFunction),
     );
-    if (contractPublicData[i]) {
-      contractPublicData[i][0].push(contractData);
+    if (contractDataAndBytecode[i]) {
+      contractDataAndBytecode[i][0].push(contractData);
     } else {
-      contractPublicData[i] = [[contractData], l2BlockNum];
+      contractDataAndBytecode[i] = [[contractData], l2BlockNum];
     }
   }
-  return contractPublicData;
+  return contractDataAndBytecode;
 }
 
 /**

package/src/archiver/l1_to_l2_message_store.test.ts

@@ -1,7 +1,8 @@
 import { Fr } from '@aztec/foundation/fields';
-import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
 import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/types';
 
+import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
+
 describe('l1_to_l2_message_store', () => {
   let store: L1ToL2MessageStore;
   let entryKey: Fr;
@@ -62,12 +63,12 @@ describe('pending_l1_to_l2_message_store', () => {
     expect(store.getMessageKeys(10)).toEqual([]);
   });
 
-  it('getMessageKeys returns an empty array if take is 0', () => {
+  it('getMessageKeys returns an empty array if limit is 0', () => {
     store.addMessage(entryKey, msg);
     expect(store.getMessageKeys(0)).toEqual([]);
   });
 
-  it('get messages for a non-empty store when take > number of messages in store', () => {
+  it('get messages for a non-empty store when limit > number of messages in store', () => {
     const entryKeys = [1, 2, 3, 4, 5].map(x => new Fr(x));
     entryKeys.forEach(entryKey => {
       store.addMessage(entryKey, L1ToL2Message.random());

package/src/archiver/l1_to_l2_message_store.ts

@@ -38,18 +38,18 @@ export class L1ToL2MessageStore {
  * for removing messages or fetching multiple messages.
  */
 export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
-  getMessageKeys(take: number): Fr[] {
-    if (take < 1) {
+  getMessageKeys(limit: number): Fr[] {
+    if (limit < 1) {
       return [];
     }
-    // fetch `take` number of messages from the store with the highest fee.
+    // fetch `limit` number of messages from the store with the highest fee.
     // Note the store has multiple of the same message. So if a message has count 2, include both of them in the result:
     const messages: Fr[] = [];
     const sortedMessages = Array.from(this.store.values()).sort((a, b) => b.message.fee - a.message.fee);
     for (const messageAndCount of sortedMessages) {
       for (let i = 0; i < messageAndCount.count; i++) {
         messages.push(messageAndCount.message.entryKey!);
-        if (messages.length === take) {
+        if (messages.length === limit) {
           return messages;
         }
       }
@@ -63,7 +63,7 @@ export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
     const messageKeyBigInt = messageKey.value;
     const msgAndCount = this.store.get(messageKeyBigInt);
     if (!msgAndCount) {
-      throw new Error(`Message with key ${messageKeyBigInt} not found in store`);
+      throw new Error(`Unable to remove message: L1 to L2 Message with key ${messageKeyBigInt} not found in store`);
     }
     if (msgAndCount.count > 1) {
       msgAndCount.count--;

package/src/index.ts

@@ -1,13 +1,15 @@
+import { createDebugLogger } from '@aztec/foundation/log';
+
 import { fileURLToPath } from 'url';
 import { createPublicClient, http } from 'viem';
 import { localhost } from 'viem/chains';
-import { Archiver, getConfigEnvVars } from './archiver/index.js';
+
 import { MemoryArchiverStore } from './archiver/archiver_store.js';
-import { createLogger } from '@aztec/foundation/log';
+import { Archiver, getConfigEnvVars } from './archiver/index.js';
 
 export * from './archiver/index.js';
 
-const log = createLogger('aztec:archiver_init');
+const log = createDebugLogger('aztec:archiver');
 
 /**
  * A function which instantiates and starts Archiver.
@@ -45,7 +47,7 @@ async function main() {
 if (process.argv[1] === fileURLToPath(import.meta.url).replace(/\/index\.js$/, '')) {
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
   main().catch(err => {
-    log(err);
+    log.fatal(err);
     process.exit(1);
   });
 }

package/tsconfig.json

@@ -6,6 +6,9 @@
     "tsBuildInfoFile": ".tsbuildinfo"
   },
   "references": [
+    {
+      "path": "../circuits.js"
+    },
     {
       "path": "../ethereum"
     },