@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/test/mock_structs.ts

@@ -0,0 +1,50 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
+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 { checkpointNumber = CheckpointNumber(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.smallestIndexForCheckpoint(checkpointNumber) } = overrides;
+
+  return {
+    index,
+    leaf,
+    checkpointNumber,
+    l1BlockNumber,
+    l1BlockHash,
+    rollingHash,
+  };
+}
+
+export function makeInboxMessages(
+  count: number,
+  opts: {
+    initialHash?: Buffer16;
+    initialCheckpointNumber?: CheckpointNumber;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+  } = {},
+): InboxMessage[] {
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialCheckpointNumber = 1 } = opts;
+  const messages: InboxMessage[] = [];
+  let rollingHash = initialHash;
+  for (let i = 0; i < count; i++) {
+    const leaf = Fr.random();
+    const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, checkpointNumber }), i);
+    rollingHash = message.rollingHash;
+    messages.push(message);
+  }
+
+  return messages;
+}

package/dest/archiver/data_retrieval.d.ts

@@ -1,74 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { ViemPublicClient } from '@aztec/ethereum';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { L2Block } from '@aztec/stdlib/block';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { Proof } from '@aztec/stdlib/proofs';
-import { type GetContractEventsReturnType, type GetContractReturnType, type Hex } from 'viem';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { L1Published } from './structs/published.js';
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @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 block; as well as the next eth block to search from.
- */
-export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<L1Published<L2Block>[]>;
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */
-export declare function processL2BlockProposedLogs(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>, logger: Logger): Promise<L1Published<L2Block>[]>;
-export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
-/**
- * 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 InboxLeaf and next eth block to search from.
- */
-export declare function retrieveL1ToL2Messages(inbox: GetContractReturnType<typeof InboxAbi, ViemPublicClient>, searchStartBlock: bigint, searchEndBlock: bigint): Promise<DataRetrieval<InboxLeaf>>;
-/** Retrieves L2ProofVerified events from the rollup contract. */
-export declare function retrieveL2ProofVerifiedEvents(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<{
-    l1BlockNumber: bigint;
-    l2BlockNumber: bigint;
-    proverId: Fr;
-    txHash: Hex;
-}[]>;
-/** Retrieve submitted proofs from the rollup contract */
-export declare function retrieveL2ProofsFromRollup(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<DataRetrieval<{
-    proof: Proof;
-    proverId: Fr;
-    l2BlockNumber: bigint;
-    txHash: `0x${string}`;
-}>>;
-export type SubmitBlockProof = {
-    archiveRoot: Fr;
-    proverId: Fr;
-    aggregationObject: Buffer;
-    proof: Proof;
-};
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */
-export declare function getProofFromSubmitProofTx(publicClient: ViemPublicClient, txHash: `0x${string}`, expectedProverId: Fr): Promise<SubmitBlockProof>;
-//# sourceMappingURL=data_retrieval.d.ts.map

package/dest/archiver/data_retrieval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data_retrieval.d.ts","sourceRoot":"","sources":["../../src/archiver/data_retrieval.ts"],"names":[],"mappings":"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"}

package/dest/archiver/data_retrieval.js

@@ -1,283 +0,0 @@
-import { Blob, BlobDeserializationError } from '@aztec/blob-lib';
-import { asyncPool } from '@aztec/foundation/async-pool';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { ForwarderAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, L2Block } from '@aztec/stdlib/block';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { Proof } from '@aztec/stdlib/proofs';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader } from '@aztec/stdlib/tx';
-import { decodeFunctionData, getAbiItem, hexToBytes } from 'viem';
-import { NoBlobBodiesFoundError } from './errors.js';
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @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 block; as well as the next eth block to search from.
- */ export async function retrieveBlocksFromRollup(rollup, publicClient, blobSinkClient, searchStartBlock, searchEndBlock, logger = createLogger('archiver')) {
-    const retrievedBlocks = [];
-    do {
-        if (searchStartBlock > searchEndBlock) {
-            break;
-        }
-        const l2BlockProposedLogs = (await rollup.getEvents.L2BlockProposed({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
-        if (l2BlockProposedLogs.length === 0) {
-            break;
-        }
-        const lastLog = l2BlockProposedLogs[l2BlockProposedLogs.length - 1];
-        logger.debug(`Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`);
-        const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, l2BlockProposedLogs, logger);
-        retrievedBlocks.push(...newBlocks);
-        searchStartBlock = lastLog.blockNumber + 1n;
-    }while (searchStartBlock <= searchEndBlock)
-    // The asyncpool from processL2BlockProposedLogs will not necessarily return the blocks in order, so we sort them before returning.
-    return retrievedBlocks.sort((a, b)=>Number(a.l1.blockNumber - b.l1.blockNumber));
-}
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */ export async function processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, logs, logger) {
-    const retrievedBlocks = [];
-    await asyncPool(10, logs, async (log)=>{
-        const l2BlockNumber = log.args.blockNumber;
-        const archive = log.args.archive;
-        const archiveFromChain = await rollup.read.archiveAt([
-            l2BlockNumber
-        ]);
-        const blobHashes = log.args.versionedBlobHashes.map((blobHash)=>Buffer.from(blobHash.slice(2), 'hex'));
-        // The value from the event and contract will match only if the block is in the chain.
-        if (archive === archiveFromChain) {
-            const block = await getBlockFromRollupTx(publicClient, blobSinkClient, log.transactionHash, blobHashes, l2BlockNumber, rollup.address, logger);
-            const l1 = {
-                blockNumber: log.blockNumber,
-                blockHash: log.blockHash,
-                timestamp: await getL1BlockTime(publicClient, log.blockNumber)
-            };
-            retrievedBlocks.push({
-                data: block,
-                l1
-            });
-        } else {
-            logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
-                actual: archive,
-                expected: archiveFromChain
-            });
-        }
-    });
-    return retrievedBlocks;
-}
-export async function getL1BlockTime(publicClient, blockNumber) {
-    const block = await publicClient.getBlock({
-        blockNumber,
-        includeTransactions: false
-    });
-    return block.timestamp;
-}
-/**
- * Extracts the first 'propose' method calldata from a forwarder transaction's data.
- * @param forwarderData - The forwarder transaction input data
- * @param rollupAddress - The address of the rollup contract
- * @returns The calldata for the first 'propose' method call to the rollup contract
- */ function extractRollupProposeCalldata(forwarderData, rollupAddress) {
-    // TODO(#11451): custom forwarders
-    const { functionName: forwarderFunctionName, args: forwarderArgs } = decodeFunctionData({
-        abi: ForwarderAbi,
-        data: forwarderData
-    });
-    if (forwarderFunctionName !== 'forward') {
-        throw new Error(`Unexpected forwarder method called ${forwarderFunctionName}`);
-    }
-    if (forwarderArgs.length !== 2) {
-        throw new Error(`Unexpected number of arguments for forwarder`);
-    }
-    const [to, data] = forwarderArgs;
-    // Find all rollup calls
-    const rollupAddressLower = rollupAddress.toLowerCase();
-    for(let i = 0; i < to.length; i++){
-        const addr = to[i];
-        if (addr.toLowerCase() !== rollupAddressLower) {
-            continue;
-        }
-        const callData = data[i];
-        try {
-            const { functionName: rollupFunctionName } = decodeFunctionData({
-                abi: RollupAbi,
-                data: callData
-            });
-            if (rollupFunctionName === 'propose') {
-                return callData;
-            }
-        } catch (err) {
-            continue;
-        }
-    }
-    throw new Error(`Rollup address not found in forwarder args`);
-}
-/**
- * Gets block from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block from the calldata, deserialized
- */ async function getBlockFromRollupTx(publicClient, blobSinkClient, txHash, blobHashes, l2BlockNum, rollupAddress, logger) {
-    const { input: forwarderData, blockHash } = await publicClient.getTransaction({
-        hash: txHash
-    });
-    const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
-    const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
-        abi: RollupAbi,
-        data: rollupData
-    });
-    if (rollupFunctionName !== 'propose') {
-        throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
-    }
-    const [decodedArgs] = rollupArgs;
-    const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
-    const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
-    if (blobBodies.length === 0) {
-        throw new NoBlobBodiesFoundError(Number(l2BlockNum));
-    }
-    let blockFields;
-    try {
-        blockFields = Blob.toEncodedFields(blobBodies);
-    } catch (err) {
-        if (err instanceof BlobDeserializationError) {
-            logger.fatal(err.message);
-        } else {
-            logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
-        }
-        throw err;
-    }
-    // The blob source gives us blockFields, and we must construct the body from them:
-    const blockBody = Body.fromBlobFields(blockFields);
-    const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
-    if (blockNumberFromHeader !== l2BlockNum) {
-        throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
-    }
-    const archive = AppendOnlyTreeSnapshot.fromBuffer(Buffer.concat([
-        Buffer.from(hexToBytes(decodedArgs.archive)),
-        numToUInt32BE(Number(l2BlockNum + 1n))
-    ]));
-    return new L2Block(archive, header, blockBody);
-}
-/**
- * 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 InboxLeaf and next eth block to search from.
- */ export async function retrieveL1ToL2Messages(inbox, searchStartBlock, searchEndBlock) {
-    const retrievedL1ToL2Messages = [];
-    do {
-        if (searchStartBlock > searchEndBlock) {
-            break;
-        }
-        const messageSentLogs = (await inbox.getEvents.MessageSent({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
-        if (messageSentLogs.length === 0) {
-            break;
-        }
-        for (const log of messageSentLogs){
-            const { index, hash } = log.args;
-            retrievedL1ToL2Messages.push(new InboxLeaf(index, Fr.fromHexString(hash)));
-        }
-        // handles the case when there are no new messages:
-        searchStartBlock = (messageSentLogs.findLast((msgLog)=>!!msgLog)?.blockNumber || searchStartBlock) + 1n;
-    }while (searchStartBlock <= searchEndBlock)
-    return {
-        lastProcessedL1BlockNumber: searchStartBlock - 1n,
-        retrievedData: retrievedL1ToL2Messages
-    };
-}
-/** Retrieves L2ProofVerified events from the rollup contract. */ export async function retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock) {
-    const logs = await publicClient.getLogs({
-        address: rollupAddress.toString(),
-        fromBlock: searchStartBlock,
-        toBlock: searchEndBlock ? searchEndBlock : undefined,
-        strict: true,
-        event: getAbiItem({
-            abi: RollupAbi,
-            name: 'L2ProofVerified'
-        })
-    });
-    return logs.map((log)=>({
-            l1BlockNumber: log.blockNumber,
-            l2BlockNumber: log.args.blockNumber,
-            proverId: Fr.fromHexString(log.args.proverId),
-            txHash: log.transactionHash
-        }));
-}
-/** Retrieve submitted proofs from the rollup contract */ export async function retrieveL2ProofsFromRollup(publicClient, rollupAddress, searchStartBlock, searchEndBlock) {
-    const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
-    const retrievedData = [];
-    const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1).l1BlockNumber : searchStartBlock - 1n;
-    for (const { txHash, proverId, l2BlockNumber } of logs){
-        const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
-        retrievedData.push({
-            proof: proofData.proof,
-            proverId: proofData.proverId,
-            l2BlockNumber,
-            txHash
-        });
-    }
-    return {
-        retrievedData,
-        lastProcessedL1BlockNumber
-    };
-}
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */ export async function getProofFromSubmitProofTx(publicClient, txHash, expectedProverId) {
-    const { input: data } = await publicClient.getTransaction({
-        hash: txHash
-    });
-    const { functionName, args } = decodeFunctionData({
-        abi: RollupAbi,
-        data
-    });
-    let proverId;
-    let archiveRoot;
-    let aggregationObject;
-    let proof;
-    if (functionName === 'submitEpochRootProof') {
-        const [decodedArgs] = args;
-        aggregationObject = Buffer.from(hexToBytes(decodedArgs.aggregationObject));
-        proverId = Fr.fromHexString(decodedArgs.args.proverId);
-        archiveRoot = Fr.fromHexString(decodedArgs.args.endArchive);
-        proof = Proof.fromBuffer(Buffer.from(hexToBytes(decodedArgs.proof)));
-    } else {
-        throw new Error(`Unexpected proof method called ${functionName}`);
-    }
-    if (!proverId.equals(expectedProverId)) {
-        throw new Error(`Prover ID mismatch: expected ${expectedProverId} but got ${proverId}`);
-    }
-    return {
-        proverId,
-        aggregationObject,
-        archiveRoot,
-        proof
-    };
-}

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;
-    }
-}