@aztec/archiver 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/factory.ts

@@ -1,27 +1,28 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { createLogger } from '@aztec/foundation/log';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
-import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
-import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractNames, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
-import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
-import {
-  type ContractClassPublic,
-  computePublicBytecodeCommitment,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
-import type { ArchiverApi, Service } from '@aztec/stdlib/interfaces/server';
-import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+import { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 
-import { Archiver } from './archiver/archiver.js';
+import { Archiver, type ArchiverDeps } from './archiver/archiver.js';
 import type { ArchiverConfig } from './archiver/config.js';
-import { KVArchiverDataStore } from './archiver/index.js';
-import { createArchiverClient } from './rpc/index.js';
+import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './archiver/kv_archiver_store/kv_archiver_store.js';
+
+export const ARCHIVER_STORE_NAME = 'archiver';
+
+/** Creates an archiver store. */
+export async function createArchiverStore(
+  userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
+) {
+  const config = {
+    ...userConfig,
+    dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
+  };
+  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
+  return new KVArchiverDataStore(store, config.maxLogs);
+}
 
 /**
  * Creates a local archiver.
@@ -33,36 +34,12 @@ import { createArchiverClient } from './rpc/index.js';
  */
 export async function createArchiver(
   config: ArchiverConfig & DataStoreConfig,
-  blobSinkClient: BlobSinkClientInterface,
+  deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
-  telemetry: TelemetryClient = getTelemetryClient(),
-): Promise<ArchiverApi & Service & L2BlockSourceEventEmitter> {
-  const store = await createStore(
-    'archiver',
-    KVArchiverDataStore.SCHEMA_VERSION,
-    config,
-    createLogger('archiver:lmdb'),
-  );
-  const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
+): Promise<Archiver> {
+  const archiverStore = await createArchiverStore(config);
   await registerProtocolContracts(archiverStore);
-  await registerCommonContracts(archiverStore);
-  return Archiver.createAndSync(config, archiverStore, { telemetry, blobSinkClient }, opts.blockUntilSync);
-}
-
-/**
- * Creates a remote archiver client.
- * @param config - The archiver configuration.
- * @returns The remote archiver client.
- */
-export function createRemoteArchiver(config: ArchiverConfig): ArchiverApi {
-  if (!config.archiverUrl) {
-    throw new Error('Archiver URL is required');
-  }
-
-  return createArchiverClient(
-    config.archiverUrl,
-    getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot()),
-  );
+  return Archiver.createAndSync(config, archiverStore, deps, opts.blockUntilSync);
 }
 
 async function registerProtocolContracts(store: KVArchiverDataStore) {
@@ -73,35 +50,16 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
     const contractClassPublic: ContractClassPublic = {
       ...contract.contractClass,
       privateFunctions: [],
-      unconstrainedFunctions: [],
+      utilityFunctions: [],
     };
 
     const publicFunctionSignatures = contract.artifact.functions
       .filter(fn => fn.functionType === FunctionType.PUBLIC)
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
-    await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
+    await store.registerContractFunctionSignatures(publicFunctionSignatures);
     const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
     await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
     await store.addContractInstances([contract.instance], blockNumber);
   }
 }
-
-// TODO(#10007): Remove this method. We are explicitly registering these contracts
-// here to ensure they are available to all nodes and all prover nodes, since the PXE
-// was tweaked to automatically push contract classes to the node it is registered,
-// but other nodes in the network may require the contract classes to be registered as well.
-// TODO(#10007): Remove the dependency on noir-contracts.js from this package once we remove this.
-async function registerCommonContracts(store: KVArchiverDataStore) {
-  const blockNumber = 0;
-  const artifacts = [TokenBridgeContractArtifact, TokenContractArtifact];
-  const classes = await Promise.all(
-    artifacts.map(async artifact => ({
-      ...(await getContractClassFromArtifact(artifact)),
-      privateFunctions: [],
-      unconstrainedFunctions: [],
-    })),
-  );
-  const bytecodeCommitments = await Promise.all(classes.map(x => computePublicBytecodeCommitment(x.packedBytecode)));
-  await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
-}

package/src/rpc/index.ts

@@ -1,7 +1,7 @@
 import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
 import { type ArchiverApi, ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
 import { type ComponentsVersions, getVersioningResponseHandler } from '@aztec/stdlib/versioning';
-import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
+import { makeTracedFetch } from '@aztec/telemetry-client';
 
 export function createArchiverClient(
   url: string,
@@ -14,7 +14,3 @@ export function createArchiverClient(
     onResponse: getVersioningResponseHandler(versions),
   });
 }
-
-export function createArchiverRpcServer(handler: ArchiverApi) {
-  return createTracedJsonRpcServer(handler, ArchiverApiSchema);
-}

package/src/test/mock_archiver.ts

@@ -15,7 +15,7 @@ export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1
     this.messageSource.setL1ToL2Messages(blockNumber, msgs);
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
     return this.messageSource.getL1ToL2Messages(blockNumber);
   }
 

package/src/test/mock_l1_to_l2_message_source.ts

@@ -1,4 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
+import type { L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 /**
@@ -17,8 +18,8 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
     this.blockNumber = blockNumber;
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    return Promise.resolve(this.messagesPerBlock.get(Number(blockNumber)) ?? []);
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
+    return Promise.resolve(this.messagesPerBlock.get(blockNumber) ?? []);
   }
 
   getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
@@ -28,4 +29,14 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
   getBlockNumber(): Promise<number> {
     return Promise.resolve(this.blockNumber);
   }
+
+  getL2Tips(): Promise<L2Tips> {
+    const number = this.blockNumber;
+    const tip = { number, hash: new Fr(number).toString() };
+    return Promise.resolve({
+      latest: tip,
+      proven: tip,
+      finalized: tip,
+    });
+  }
 }

package/src/test/mock_l2_block_source.ts

@@ -1,17 +1,32 @@
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
-import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  L2Block,
+  L2BlockHash,
+  type L2BlockSource,
+  type L2Tips,
+  PublishedL2Block,
+  type ValidateBlockResult,
+} from '@aztec/stdlib/block';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */
-export class MockL2BlockSource implements L2BlockSource {
+export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   protected l2Blocks: L2Block[] = [];
 
   private provenBlockNumber: number = 0;
+  private finalizedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
@@ -39,6 +54,13 @@ export class MockL2BlockSource implements L2BlockSource {
     this.provenBlockNumber = provenBlockNumber;
   }
 
+  public setFinalizedBlockNumber(finalizedBlockNumber: number) {
+    if (finalizedBlockNumber > this.provenBlockNumber) {
+      this.provenBlockNumber = finalizedBlockNumber;
+    }
+    this.finalizedBlockNumber = finalizedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -90,8 +112,74 @@ export class MockL2BlockSource implements L2BlockSource {
     );
   }
 
+  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(block =>
+      PublishedL2Block.fromFields({
+        block,
+        l1: {
+          blockNumber: BigInt(block.number),
+          blockHash: Buffer32.random().toString(),
+          timestamp: BigInt(block.number),
+        },
+        attestations: [],
+      }),
+    );
+  }
+
+  public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return PublishedL2Block.fromFields({
+          block,
+          l1: {
+            blockNumber: BigInt(block.number),
+            blockHash: Buffer32.random().toString(),
+            timestamp: BigInt(block.number),
+          },
+          attestations: [],
+        });
+      }
+    }
+    return undefined;
+  }
+
+  public getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(
+      PublishedL2Block.fromFields({
+        block,
+        l1: {
+          blockNumber: BigInt(block.number),
+          blockHash: Buffer32.random().toString(),
+          timestamp: BigInt(block.number),
+        },
+        attestations: [],
+      }),
+    );
+  }
+
+  public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return block.getBlockHeader();
+      }
+    }
+    return undefined;
+  }
+
+  public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    return Promise.resolve(block?.getBlockHeader());
+  }
+
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
   getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
@@ -104,10 +192,15 @@ export class MockL2BlockSource implements L2BlockSource {
     return Promise.resolve(blocks);
   }
 
+  async getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]> {
+    const blocks = await this.getBlocksForEpoch(epochNumber);
+    return blocks.map(b => b.getBlockHeader());
+  }
+
   /**
    * Gets a tx effect.
-   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-   * @returns The requested tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
   public async getTxEffect(txHash: TxHash) {
     const match = this.l2Blocks
@@ -117,7 +210,12 @@ export class MockL2BlockSource implements L2BlockSource {
       return Promise.resolve(undefined);
     }
     const [txEffect, block] = match;
-    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
+    return {
+      data: txEffect,
+      l2BlockNumber: block.number,
+      l2BlockHash: L2BlockHash.fromField(await block.hash()),
+      txIndexInBlock: block.body.txEffects.indexOf(txEffect),
+    };
   }
 
   /**
@@ -147,7 +245,7 @@ export class MockL2BlockSource implements L2BlockSource {
     const [latest, proven, finalized] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
-      await this.getProvenBlockNumber(),
+      this.finalizedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
@@ -183,6 +281,14 @@ export class MockL2BlockSource implements L2BlockSource {
   }
 
   getL1Constants(): Promise<L1RollupConstants> {
+    return Promise.resolve(EmptyL1RollupConstants);
+  }
+
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
+  }
+
+  getL1Timestamp(): Promise<bigint> {
     throw new Error('Method not implemented.');
   }
 
@@ -191,6 +297,7 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the initialization of the l2 block source on completion.
    */
   public start(): Promise<void> {
+    this.log.verbose('Starting mock L2 block source');
     return Promise.resolve();
   }
 
@@ -199,6 +306,43 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the l2 block source is now stopped.
    */
   public stop(): Promise<void> {
+    this.log.verbose('Stopping mock L2 block source');
     return Promise.resolve();
   }
+
+  getContractClass(_id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getBytecodeCommitment(_id: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContract(_address: AztecAddress, _timestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    return Promise.resolve([]);
+  }
+
+  getDebugFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  registerContractFunctionSignatures(_signatures: string[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  syncImmediate(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  isPendingChainInvalid(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+    return Promise.resolve({ valid: true });
+  }
 }

package/src/test/mock_structs.ts

@@ -0,0 +1,49 @@
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt, randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+
+import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
+
+export function makeInboxMessage(
+  previousRollingHash = Buffer16.ZERO,
+  overrides: Partial<InboxMessage> = {},
+): InboxMessage {
+  const { l2BlockNumber = randomInt(100) + 1 } = overrides;
+  const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
+  const { l1BlockHash = Buffer32.random() } = overrides;
+  const { leaf = Fr.random() } = overrides;
+  const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
+  const { index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) } = overrides;
+
+  return {
+    index,
+    leaf,
+    l2BlockNumber,
+    l1BlockNumber,
+    l1BlockHash,
+    rollingHash,
+  };
+}
+
+export function makeInboxMessages(
+  count: number,
+  opts: {
+    initialHash?: Buffer16;
+    initialL2BlockNumber?: number;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+  } = {},
+): InboxMessage[] {
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialL2BlockNumber = 1 } = opts;
+  const messages: InboxMessage[] = [];
+  let rollingHash = initialHash;
+  for (let i = 0; i < count; i++) {
+    const leaf = Fr.random();
+    const l2BlockNumber = i + initialL2BlockNumber;
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), i);
+    rollingHash = message.rollingHash;
+    messages.push(message);
+  }
+
+  return messages;
+}

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts

@@ -1,12 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
-export declare class NullifierStore {
-    #private;
-    private db;
-    constructor(db: AztecAsyncKVStore);
-    addNullifiers(blocks: L2Block[]): Promise<boolean>;
-    deleteNullifiers(blocks: L2Block[]): Promise<boolean>;
-    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
-}
-//# sourceMappingURL=nullifier_store.d.ts.map

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nullifier_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/nullifier_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,qBAAa,cAAc;;IAMb,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAMnC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BlD,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAerD,8BAA8B,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,GACf,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;CAkC5C"}

package/dest/archiver/kv_archiver_store/nullifier_store.js

@@ -1,73 +0,0 @@
-import { MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-export class NullifierStore {
-    db;
-    #nullifiersToBlockNumber;
-    #nullifiersToBlockHash;
-    #nullifiersToIndex;
-    #log;
-    constructor(db){
-        this.db = db;
-        this.#log = createLogger('archiver:log_store');
-        this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
-        this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
-        this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
-    }
-    async addNullifiers(blocks) {
-        const blockHashes = await Promise.all(blocks.map((block)=>block.hash()));
-        await this.db.transactionAsync(async ()=>{
-            await Promise.all(blocks.map((block, i)=>{
-                const dataStartIndexForBlock = block.header.state.partial.nullifierTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-                return Promise.all(block.body.txEffects.map((txEffects, txIndex)=>{
-                    const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-                    return Promise.all(txEffects.nullifiers.map(async (nullifier, nullifierIndex)=>{
-                        await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
-                        await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
-                        await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
-                    }));
-                }));
-            }));
-        });
-        return true;
-    }
-    async deleteNullifiers(blocks) {
-        await this.db.transactionAsync(async ()=>{
-            for (const block of blocks){
-                for (const nullifier of block.body.txEffects.flatMap((tx)=>tx.nullifiers)){
-                    await Promise.all([
-                        this.#nullifiersToBlockNumber.delete(nullifier.toString()),
-                        this.#nullifiersToBlockHash.delete(nullifier.toString()),
-                        this.#nullifiersToIndex.delete(nullifier.toString())
-                    ]);
-                }
-            }
-        });
-        return true;
-    }
-    async findNullifiersIndexesWithBlock(blockNumber, nullifiers) {
-        const asStrings = nullifiers.map((x)=>x.toString());
-        const maybeNullifiers = await Promise.all(asStrings.map(async (nullifier)=>{
-            const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
-                this.#nullifiersToIndex.getAsync(nullifier),
-                this.#nullifiersToBlockNumber.getAsync(nullifier),
-                this.#nullifiersToBlockHash.getAsync(nullifier)
-            ]);
-            return {
-                data,
-                l2BlockNumber,
-                l2BlockHash
-            };
-        }));
-        return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash })=>{
-            if (data === undefined || l2BlockNumber === undefined || l2BlockHash === undefined || l2BlockNumber > blockNumber) {
-                return undefined;
-            } else {
-                return {
-                    data: BigInt(data),
-                    l2BlockNumber,
-                    l2BlockHash
-                };
-            }
-        });
-    }
-}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts

@@ -1,23 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */
-export declare class L1ToL2MessageStore {
-    #private;
-    /**
-     * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-     */
-    protected store: Map<string, Fr>;
-    constructor();
-    getTotalL1ToL2MessageCount(): bigint;
-    addMessage(message: InboxLeaf): void;
-    getMessages(blockNumber: bigint): Fr[];
-    /**
-     * Gets the L1 to L2 message index in the L1 to L2 message tree.
-     * @param l1ToL2Message - The L1 to L2 message.
-     * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-     */
-    getMessageIndex(l1ToL2Message: Fr): bigint | undefined;
-}
-//# sourceMappingURL=l1_to_l2_message_store.d.ts.map

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1_to_l2_message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/memory_archiver_store/l1_to_l2_message_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;AACH,qBAAa,kBAAkB;;IAC7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAa;;IAM7C,0BAA0B,IAAI,MAAM;IAIpC,UAAU,CAAC,OAAO,EAAE,SAAS;IAI7B,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,EAAE;IAsBtC;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,EAAE,GAAG,MAAM,GAAG,SAAS;CAQvD"}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.js

@@ -1,49 +0,0 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */ export class L1ToL2MessageStore {
-    /**
-   * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-   */ store = new Map();
-    #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-    constructor(){}
-    getTotalL1ToL2MessageCount() {
-        return BigInt(this.store.size);
-    }
-    addMessage(message) {
-        this.store.set(`${message.index}`, message.leaf);
-    }
-    getMessages(blockNumber) {
-        const messages = [];
-        let undefinedMessageFound = false;
-        const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
-        for(let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++){
-            // This is inefficient but probably fine for now.
-            const message = this.store.get(`${i}`);
-            if (message) {
-                if (undefinedMessageFound) {
-                    throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
-                }
-                messages.push(message);
-            } else {
-                undefinedMessageFound = true;
-            // We continue iterating over messages here to verify that there are no more messages after the undefined one.
-            // --> If this was the case this would imply there is some issue with log fetching.
-            }
-        }
-        return messages;
-    }
-    /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
-   * @param l1ToL2Message - The L1 to L2 message.
-   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-   */ getMessageIndex(l1ToL2Message) {
-        for (const [key, message] of this.store.entries()){
-            if (message.equals(l1ToL2Message)) {
-                return BigInt(key);
-            }
-        }
-        return undefined;
-    }
-}