@aztec-labs/archiver 6.0.0-nightly.20260829

package/dest/test/mock_structs.js

@@ -0,0 +1,188 @@
+import { MAX_L1_TO_L2_MSGS_PER_BLOCK, MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { times, timesParallel } from '@aztec-labs/foundation/collection';
+import { randomBigInt } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { CommitteeAttestation, L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec-labs/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec-labs/stdlib/logs';
+import { updateInboxRollingHash } from '@aztec-labs/stdlib/messaging';
+import { orderAttestations } from '@aztec-labs/stdlib/p2p';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import { makeCheckpointAttestationFromCheckpoint } from '@aztec-labs/stdlib/testing';
+import { AppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/trees';
+import { PartialStateReference, StateReference, TxEffect } from '@aztec-labs/stdlib/tx';
+export function makeInboxMessage(previousInboxRollingHash = Fr.ZERO, overrides = {}) {
+    const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
+    const { l1BlockHash = Buffer32.random() } = overrides;
+    const { leaf = Fr.random() } = overrides;
+    // Compact global insertion index: defaults to the first slot.
+    const { index = 0n } = overrides;
+    const { inboxRollingHash = updateInboxRollingHash(previousInboxRollingHash, leaf) } = overrides;
+    // Default each message to its own bucket, keyed monotonically off its global index.
+    const { bucketSeq = index + 1n } = overrides;
+    const { bucketTimestamp = index + 1n } = overrides;
+    return {
+        index,
+        leaf,
+        l1BlockNumber,
+        l1BlockHash,
+        inboxRollingHash,
+        bucketSeq,
+        bucketTimestamp
+    };
+}
+/**
+ * Builds a contiguous run of `totalCount` inbox messages with compact global indices starting at `initialIndex`
+ * and a chained consensus rolling hash starting from `initialInboxHash`.
+ */ export function makeInboxMessages(totalCount, opts = {}) {
+    const { initialInboxHash = Fr.ZERO, initialIndex = 0n, overrideFn = (msg)=>msg } = opts;
+    const messages = [];
+    let inboxRollingHash = initialInboxHash;
+    for(let i = 0; i < totalCount; i++){
+        const leaf = Fr.random();
+        inboxRollingHash = updateInboxRollingHash(inboxRollingHash, leaf);
+        const message = overrideFn(makeInboxMessage(Fr.ZERO, {
+            leaf,
+            index: initialIndex + BigInt(i),
+            inboxRollingHash
+        }), i);
+        messages.push(message);
+    }
+    return messages;
+}
+/**
+ * Creates `blockCount` full buckets of `MAX_L1_TO_L2_MSGS_PER_BLOCK` inbox messages each, with compact indices and one
+ * bucket sequence per block.
+ */ export function makeInboxMessagesWithFullBlocks(blockCount) {
+    return makeInboxMessages(MAX_L1_TO_L2_MSGS_PER_BLOCK * blockCount, {
+        overrideFn: (msg, i)=>{
+            const bucketSeq = BigInt(Math.floor(i / MAX_L1_TO_L2_MSGS_PER_BLOCK)) + 1n;
+            return {
+                ...msg,
+                bucketSeq,
+                bucketTimestamp: bucketSeq
+            };
+        }
+    });
+}
+/** Creates a deterministic block hash from a block number. */ export function makeBlockHash(blockNumber) {
+    return `0x${blockNumber.toString(16).padStart(64, '0')}`;
+}
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */ export function makeStateForBlock(blockNumber, txsPerBlock) {
+    const noteHashIndex = blockNumber * txsPerBlock * MAX_NOTE_HASHES_PER_TX;
+    return new StateReference(AppendOnlyTreeSnapshot.random(), new PartialStateReference(new AppendOnlyTreeSnapshot(Fr.random(), noteHashIndex), AppendOnlyTreeSnapshot.random(), AppendOnlyTreeSnapshot.random()));
+}
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */ export function makeL1PublishedData(l1BlockNumber) {
+    return new L1PublishedData(BigInt(l1BlockNumber), BigInt(l1BlockNumber * 1000), makeBlockHash(l1BlockNumber));
+}
+/** Creates a Checkpoint from a list of blocks with a header that matches the blocks' structure. */ export function makeCheckpoint(blocks, checkpointNumber = CheckpointNumber(1)) {
+    const firstBlock = blocks[0];
+    const { slotNumber, timestamp, coinbase, feeRecipient, gasFees } = firstBlock.header.globalVariables;
+    return new Checkpoint(blocks.at(-1).archive, CheckpointHeader.random({
+        lastArchiveRoot: firstBlock.header.lastArchive.root,
+        slotNumber,
+        timestamp,
+        coinbase,
+        feeRecipient,
+        gasFees
+    }), blocks, checkpointNumber);
+}
+/** Wraps a Checkpoint with L1 published data and random attestations. */ export function makePublishedCheckpoint(checkpoint, l1BlockNumber, attestationCount = 3) {
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), times(attestationCount, CommitteeAttestation.random));
+}
+/**
+ * Creates multiple checkpoints with properly chained archives.
+ * Each checkpoint's blocks have their lastArchive set to the previous block's archive,
+ * ensuring archive chain continuity for testing.
+ */ export async function makeChainedCheckpoints(count, options = {}) {
+    const { blocksPerCheckpoint = 1, txsPerBlock = 4, startCheckpointNumber = CheckpointNumber(1), startBlockNumber = 1, startL1BlockNumber = 10, makeCheckpointOptions } = options;
+    let previousArchive = options.previousArchive;
+    const checkpoints = [];
+    for(let i = 0; i < count; i++){
+        const cpNumber = CheckpointNumber(startCheckpointNumber + i);
+        const blockStart = startBlockNumber + i * blocksPerCheckpoint;
+        const customOptions = makeCheckpointOptions?.(cpNumber) ?? {};
+        const checkpoint = await Checkpoint.random(cpNumber, {
+            numBlocks: blocksPerCheckpoint,
+            startBlockNumber: blockStart,
+            previousArchive,
+            txsPerBlock,
+            state: makeStateForBlock(blockStart, txsPerBlock),
+            txOptions: {
+                numPublicCallsPerTx: 2,
+                numPublicLogsPerCall: 2
+            },
+            ...customOptions
+        });
+        previousArchive = checkpoint.blocks.at(-1).archive;
+        checkpoints.push(makePublishedCheckpoint(checkpoint, startL1BlockNumber + i * 10));
+    }
+    return checkpoints;
+}
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */ export function makeSignedPublishedCheckpoint(checkpoint, signers, committee, l1BlockNumber = 1) {
+    const attestations = signers.map((signer)=>makeCheckpointAttestationFromCheckpoint(checkpoint, signer));
+    const committeeAttestations = orderAttestations(attestations, committee);
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), committeeAttestations);
+}
+/** Creates a deterministic SiloedTag for private log testing. */ export function makePrivateLogTag(blockNumber, txIndex, logIndex) {
+    return new SiloedTag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr(blockNumber * 100 + txIndex * 10 + logIndex));
+}
+/** Creates a PrivateLog with fields derived from the tag. */ export function makePrivateLog(tag) {
+    return PrivateLog.from({
+        fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, (i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i))),
+        emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS
+    });
+}
+/** Creates multiple private logs for a transaction. */ export function mockPrivateLogs(blockNumber, txIndex, numLogsPerTx) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePrivateLogTag(blockNumber, txIndex, logIndex);
+        return makePrivateLog(tag);
+    });
+}
+/** Creates a deterministic Tag for public log testing. */ export function makePublicLogTag(blockNumber, txIndex, logIndex) {
+    return new Tag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * 123));
+}
+/** Creates a PublicLog with fields derived from the tag. */ export function makePublicLog(tag, contractAddress = AztecAddress.fromNumberUnsafe(543254)) {
+    return PublicLog.from({
+        contractAddress,
+        fields: new Array(10).fill(null).map((_, i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))
+    });
+}
+/** Creates multiple public logs for a transaction. */ export function makePublicLogs(blockNumber, txIndex, numLogsPerTx, contractAddress = AztecAddress.fromNumberUnsafe(543254)) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePublicLogTag(blockNumber, txIndex, logIndex);
+        return makePublicLog(tag, contractAddress);
+    });
+}
+/** Creates a checkpoint with specified logs on each tx effect. */ export async function makeCheckpointWithLogs(blockNumber, options = {}) {
+    const { previousArchive, numTxsPerBlock = 4, privateLogs, publicLogs } = options;
+    const block = await L2Block.random(BlockNumber(blockNumber), {
+        checkpointNumber: CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
+        indexWithinCheckpoint: IndexWithinCheckpoint(0),
+        state: makeStateForBlock(blockNumber, numTxsPerBlock),
+        ...previousArchive ? {
+            lastArchive: previousArchive
+        } : {}
+    });
+    block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
+    block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex)=>{
+        const txEffect = await TxEffect.random();
+        txEffect.privateLogs = privateLogs ? mockPrivateLogs(blockNumber, txIndex, privateLogs.numLogsPerTx) : [];
+        txEffect.publicLogs = publicLogs ? makePublicLogs(blockNumber, txIndex, publicLogs.numLogsPerTx, publicLogs.contractAddress) : [];
+        return txEffect;
+    });
+    const checkpoint = makeCheckpoint([
+        block
+    ], CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)));
+    return makePublishedCheckpoint(checkpoint, blockNumber);
+}

package/dest/test/noop_l1_archiver.d.ts

@@ -0,0 +1,34 @@
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import type { BlockHash } from '@aztec-labs/stdlib/block';
+import type { L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+import { Archiver } from '../archiver.js';
+import { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import type { ArchiverDataStores } from '../store/data_stores.js';
+import { L2TipsCache } from '../store/l2_tips_cache.js';
+type NoopL1ArchiverConfigOverrides = Partial<{
+    skipOrphanProposedBlockPruning: boolean;
+}>;
+/**
+ * Archiver with mocked L1 connectivity for testing.
+ * Uses mock L1 clients and a noop synchronizer, enabling tests that
+ * don't require real Ethereum connectivity.
+ */
+export declare class NoopL1Archiver extends Archiver {
+    constructor(dataStores: ArchiverDataStores, l1Constants: L1RollupConstants & {
+        genesisArchiveRoot: Fr;
+    }, instrumentation: ArchiverInstrumentation, initialHeader: BlockHeader, initialBlockHash: BlockHash, l2TipsCache: L2TipsCache, dateProvider?: DateProvider, configOverrides?: NoopL1ArchiverConfigOverrides);
+    /** Override start to skip L1 validation checks. */
+    start(_blockUntilSynced?: boolean): Promise<void>;
+    /** Always reports as fully synced since there is no real L1 to sync from. */
+    getSyncedL2SlotNumber(): Promise<SlotNumber | undefined>;
+}
+/** Creates an archiver with mocked L1 connectivity for testing. */
+export declare function createNoopL1Archiver(dataStores: ArchiverDataStores, l1Constants: L1RollupConstants & {
+    genesisArchiveRoot: Fr;
+}, telemetry: TelemetryClient | undefined, initialHeader: BlockHeader, dateProvider?: DateProvider, configOverrides?: NoopL1ArchiverConfigOverrides): Promise<NoopL1Archiver>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcF9sMV9hcmNoaXZlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3Qvbm9vcF9sMV9hcmNoaXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFbEUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUU1RCxPQUFPLEtBQUssRUFBbUIsU0FBUyxFQUFXLE1BQU0sMEJBQTBCLENBQUM7QUFDcEYsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQW1DLE1BQU0sOEJBQThCLENBQUM7QUFJckcsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzFDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXhFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRXhELEtBQUssNkJBQTZCLEdBQUcsT0FBTyxDQUFDO0lBQzNDLDhCQUE4QixFQUFFLE9BQU8sQ0FBQztDQUN6QyxDQUFDLENBQUM7QUF5Qkg7Ozs7R0FJRztBQUNILHFCQUFhLGNBQWUsU0FBUSxRQUFRO0lBQzFDLFlBQ0UsVUFBVSxFQUFFLGtCQUFrQixFQUM5QixXQUFXLEVBQUUsaUJBQWlCLEdBQUc7UUFBRSxrQkFBa0IsRUFBRSxFQUFFLENBQUE7S0FBRSxFQUMzRCxlQUFlLEVBQUUsdUJBQXVCLEVBQ3hDLGFBQWEsRUFBRSxXQUFXLEVBQzFCLGdCQUFnQixFQUFFLFNBQVMsRUFDM0IsV0FBVyxFQUFFLFdBQVcsRUFDeEIsWUFBWSxHQUFFLFlBQWlDLEVBQy9DLGVBQWUsR0FBRSw2QkFBa0MsRUFvRHBEO0lBRUQsbURBQW1EO0lBQ25DLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLE9BQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSWhFO0lBRUQsNkVBQTZFO0lBQzdELHFCQUFxQixJQUFJLE9BQU8sQ0FBQyxVQUFVLEdBQUcsU0FBUyxDQUFDLENBRXZFO0NBQ0Y7QUFFRCxtRUFBbUU7QUFDbkUsd0JBQXNCLG9CQUFvQixDQUN4QyxVQUFVLEVBQUUsa0JBQWtCLEVBQzlCLFdBQVcsRUFBRSxpQkFBaUIsR0FBRztJQUFFLGtCQUFrQixFQUFFLEVBQUUsQ0FBQTtDQUFFLEVBQzNELFNBQVMsNkJBQXdDLEVBQ2pELGFBQWEsRUFBRSxXQUFXLEVBQzFCLFlBQVksQ0FBQyxFQUFFLFlBQVksRUFDM0IsZUFBZSxDQUFDLEVBQUUsNkJBQTZCLEdBQzlDLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FrQnpCIn0=

package/dest/test/noop_l1_archiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop_l1_archiver.d.ts","sourceRoot":"","sources":["../../src/test/noop_l1_archiver.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAElE,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,OAAO,KAAK,EAAmB,SAAS,EAAW,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,eAAe,EAAmC,MAAM,8BAA8B,CAAC;AAIrG,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,KAAK,6BAA6B,GAAG,OAAO,CAAC;IAC3C,8BAA8B,EAAE,OAAO,CAAC;CACzC,CAAC,CAAC;AAyBH;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,QAAQ;IAC1C,YACE,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,iBAAiB,GAAG;QAAE,kBAAkB,EAAE,EAAE,CAAA;KAAE,EAC3D,eAAe,EAAE,uBAAuB,EACxC,aAAa,EAAE,WAAW,EAC1B,gBAAgB,EAAE,SAAS,EAC3B,WAAW,EAAE,WAAW,EACxB,YAAY,GAAE,YAAiC,EAC/C,eAAe,GAAE,6BAAkC,EAoDpD;IAED,mDAAmD;IACnC,KAAK,CAAC,iBAAiB,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;IAED,6EAA6E;IAC7D,qBAAqB,IAAI,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEvE;CACF;AAED,mEAAmE;AACnE,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,iBAAiB,GAAG;IAAE,kBAAkB,EAAE,EAAE,CAAA;CAAE,EAC3D,SAAS,6BAAwC,EACjD,aAAa,EAAE,WAAW,EAC1B,YAAY,CAAC,EAAE,YAAY,EAC3B,eAAe,CAAC,EAAE,6BAA6B,GAC9C,OAAO,CAAC,cAAc,CAAC,CAkBzB"}

package/dest/test/noop_l1_archiver.js

@@ -0,0 +1,88 @@
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { mock } from 'jest-mock-extended';
+import { EventEmitter } from 'node:events';
+import { Archiver } from '../archiver.js';
+import { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import { L2TipsCache } from '../store/l2_tips_cache.js';
+/** Noop L1 synchronizer for testing without L1 connectivity. */ class NoopL1Synchronizer {
+    tracer;
+    constructor(tracer){
+        this.tracer = tracer;
+    }
+    setConfig(_config) {}
+    getL1BlockNumber() {
+        return 0n;
+    }
+    getL1Timestamp() {
+        return undefined;
+    }
+    testEthereumNodeSynced() {
+        return Promise.resolve();
+    }
+    syncFromL1(_initialSyncComplete) {
+        return Promise.resolve([]);
+    }
+}
+/**
+ * Archiver with mocked L1 connectivity for testing.
+ * Uses mock L1 clients and a noop synchronizer, enabling tests that
+ * don't require real Ethereum connectivity.
+ */ export class NoopL1Archiver extends Archiver {
+    constructor(dataStores, l1Constants, instrumentation, initialHeader, initialBlockHash, l2TipsCache, dateProvider = new DateProvider(), configOverrides = {}){
+        // Create mocks for L1 clients
+        const publicClient = mock();
+        const debugClient = mock();
+        const rollup = mock();
+        const outbox = mock();
+        const blobClient = mock();
+        // Mock methods called during start()
+        blobClient.testSources.mockResolvedValue();
+        publicClient.getBlockNumber.mockResolvedValue(1n);
+        const events = new EventEmitter();
+        const synchronizer = new NoopL1Synchronizer(instrumentation.tracer);
+        super(publicClient, debugClient, rollup, outbox, {
+            rollupAddress: EthAddress.ZERO,
+            registryAddress: EthAddress.ZERO,
+            inboxAddress: EthAddress.ZERO,
+            governanceProposerAddress: EthAddress.ZERO,
+            slashingProposerAddress: EthAddress.ZERO
+        }, dataStores, {
+            pollingIntervalMs: 1000,
+            batchSize: 100,
+            skipValidateCheckpointAttestations: true,
+            maxAllowedEthClientDriftSeconds: 300,
+            ethereumAllowNoDebugHosts: true,
+            skipHistoricalLogsCheck: true,
+            checkpointProposalSyncGrace: 4,
+            orphanPruneNoProposalTolerance: 1,
+            skipOrphanProposedBlockPruning: true,
+            blockDuration: 2,
+            ...configOverrides
+        }, blobClient, instrumentation, {
+            ...l1Constants,
+            l1StartBlockHash: Buffer32.random()
+        }, synchronizer, events, initialHeader, initialBlockHash, l2TipsCache, dateProvider);
+    }
+    /** Override start to skip L1 validation checks. */ start(_blockUntilSynced) {
+        // Just start the running promise without L1 checks
+        this.runningPromise.start();
+        return Promise.resolve();
+    }
+    /** Always reports as fully synced since there is no real L1 to sync from. */ getSyncedL2SlotNumber() {
+        return Promise.resolve(SlotNumber(Number.MAX_SAFE_INTEGER));
+    }
+}
+/** Creates an archiver with mocked L1 connectivity for testing. */ export async function createNoopL1Archiver(dataStores, l1Constants, telemetry = getTelemetryClient(), initialHeader, dateProvider, configOverrides) {
+    const instrumentation = await ArchiverInstrumentation.new(telemetry, ()=>dataStores.db.estimateSize());
+    // Mirror the production factory: precompute the dynamic genesis block hash from the injected
+    // initial header so `L2TipsCache` reports the correct tip hash at block 0. Without this, the
+    // cache falls back to the static `GENESIS_BLOCK_HEADER_HASH`, which only matches deployments
+    // with default empty genesis.
+    const initialBlockHash = await initialHeader.hash();
+    const l2TipsCache = new L2TipsCache(dataStores.blocks, initialBlockHash);
+    return new NoopL1Archiver(dataStores, l1Constants, instrumentation, initialHeader, initialBlockHash, l2TipsCache, dateProvider, configOverrides);
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@aztec-labs/archiver",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./test": "./dest/test/index.js",
+    "./test/noop-l1": "./dest/test/noop_l1_archiver.js",
+    "./config": "./dest/config.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Archiver",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "test:integration": "concurrently -k -s first -c reset,dim -n test,anvil \"yarn test:integration:run\" \"anvil\"",
+    "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "workerThreads": true,
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/blob-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/blob-lib": "6.0.0-nightly.20260829",
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/epoch-cache": "6.0.0-nightly.20260829",
+    "@aztec-labs/ethereum": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/kv-store": "6.0.0-nightly.20260829",
+    "@aztec-labs/protocol-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/standard-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "@aztec/l1-artifacts": "6.0.0-nightly.20260826",
+    "lodash.groupby": "^4.6.0",
+    "lodash.omit": "^4.5.0",
+    "tslib": "^2.5.0",
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.groupby": "^4.6.9",
+    "@types/lodash.omit": "^4.5.7",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "concurrently": "^8.0.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}