@aztec/prover-node 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/session-manager.js

@@ -0,0 +1,492 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { getEpochAtSlot, getProofSubmissionDeadlineTimestamp, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { CheckpointProver } from './job/checkpoint-prover.js';
+import { EpochSession, specKey } from './job/epoch-session.js';
+/**
+ * Owns the lifecycle of every `EpochSession`. Each L2BlockStream event and periodic tick
+ * arrives via a dedicated entry point (`onCheckpointAdded`, `onPrune`, `onTick`, etc.) which
+ * schedules a `reconcile(trigger)` on a serial queue. Reconcile walks both session
+ * maps, cancels any session whose canonical content has shifted, re-creates it with
+ * the same spec but new content, and opens fresh full sessions for any epoch implicated
+ * by the trigger.
+ */ export class SessionManager {
+    deps;
+    log;
+    fullSessions;
+    partialSessions;
+    /**
+   * Serialises every reconcile call. The trigger sources (L2BlockStream events, the
+   * periodic tick, JSON-RPC `startProof`) run independently, so without this queue two
+   * reconciles could interleave on the `await session.cancel(...)` step and orphan a
+   * freshly-constructed session.
+   */ reconcileQueue;
+    /** Cached L1 constants, populated on first read. */ cachedL1Constants;
+    /** Test-only hooks applied to every session this manager constructs. */ sessionHooks;
+    /** Periodic tick that nudges reconcile to pick up newly-complete epochs. Started by `start()`. */ epochTicker;
+    constructor(deps){
+        this.deps = deps;
+        this.fullSessions = new Map();
+        this.partialSessions = new Map();
+        this.reconcileQueue = new SerialQueue();
+        this.log = createLogger('prover-node:session-manager', deps.bindings);
+        this.reconcileQueue.start();
+    }
+    /**
+   * Starts the periodic tick. Separated from the constructor so tests can drive `onTick()`
+   * manually without the background ticker interleaving. Idempotent.
+   */ start() {
+        if (this.epochTicker) {
+            return;
+        }
+        this.epochTicker = new RunningPromise(()=>this.onTick(), this.log, this.deps.config.tickIntervalMs);
+        this.epochTicker.start();
+    }
+    /**
+   * Installs hooks applied to every session constructed from now on. Used by the e2e
+   * harness to interpose around top-tree proving (gate it, override it, observe it)
+   * without monkey-patching the orchestrator factory.
+   */ setSessionHooks(hooks) {
+        this.sessionHooks = hooks;
+    }
+    // ---------------- read-only views ----------------
+    /** Every live (non-terminal) session. */ allSessions() {
+        return [
+            ...this.fullSessions.values(),
+            ...this.partialSessions.values()
+        ];
+    }
+    /** Returns the full session for `epoch`, if any. */ getFullSession(epoch) {
+        return this.fullSessions.get(epoch);
+    }
+    /** Returns the partial session for `spec`, if any. */ getPartialSession(spec) {
+        return this.partialSessions.get(specKey(spec));
+    }
+    /** Observability summary used by the prover-node API. */ getJobs() {
+        return this.allSessions().map((s)=>({
+                uuid: s.getId(),
+                status: s.getState(),
+                epochNumber: s.getEpochNumber()
+            }));
+    }
+    // ---------------- event entry points ----------------
+    /** Called by ProverNode after a chain-checkpointed event has been added to the store. */ onCheckpointAdded(epoch) {
+        return this.scheduleReconcile({
+            kind: 'checkpoint',
+            epoch
+        });
+    }
+    /** Called by ProverNode after a chain-pruned event has flipped store provers to pruned. */ onPrune(affectedEpochs) {
+        return this.scheduleReconcile({
+            kind: 'prune',
+            affectedEpochs
+        });
+    }
+    /**
+   * Called periodically by ProverNode's ticker. Picks up epochs that have become complete
+   * by time without a fresh checkpoint event (e.g. the epoch's last slots are empty), and
+   * advances to the next epoch once the previous one is proven on L1.
+   */ onTick() {
+        return this.scheduleReconcile({
+            kind: 'tick'
+        });
+    }
+    // ---------------- public API ----------------
+    /**
+   * Schedules a proof attempt for the supplied epoch and returns the job id without waiting for
+   * the proof to complete — proving can far outlast an HTTP request, so callers poll `getJobs()`
+   * for the outcome. Every session — full or partial — begins at the epoch's first slot; the
+   * partial's spec stops at the last canonical slot, while the full's stops at the epoch's last
+   * slot. Dedupes against any existing session covering the same range, returning its id.
+   */ async startProof(epoch) {
+        const canonical = await this.deps.checkpointStore.listForEpoch(epoch);
+        if (canonical.length === 0) {
+            throw new EmptyEpochError(epoch);
+        }
+        // Don't re-prove an epoch the L1 proven chain already encompasses — it was already proven
+        // (possibly by another prover node), so a fresh proof would be wasted work.
+        if (await this.isProvenChainEncompassing(canonical)) {
+            throw new EpochAlreadyProvenError(epoch);
+        }
+        const l1Constants = await this.getL1Constants();
+        const [fromSlot] = getSlotRangeForEpoch(epoch, l1Constants);
+        const toSlot = canonical[canonical.length - 1].slotNumber;
+        const spec = {
+            kind: 'partial',
+            epochNumber: epoch,
+            fromSlot,
+            toSlot
+        };
+        // Reuse a session already covering this exact range rather than scheduling a duplicate.
+        const existingFull = this.getFullSession(epoch);
+        if (existingFull && !existingFull.isTerminal() && existingFull.getSpec().fromSlot === fromSlot && existingFull.getSpec().toSlot === toSlot) {
+            return existingFull.getId();
+        }
+        const existingPartial = this.getPartialSession(spec);
+        if (existingPartial && !existingPartial.isTerminal()) {
+            return existingPartial.getId();
+        }
+        await this.scheduleReconcile({
+            kind: 'start-proof',
+            spec
+        });
+        const created = this.getPartialSession(spec);
+        if (!created) {
+            throw new Error(`Failed to schedule partial proof for epoch ${epoch}`);
+        }
+        return created.getId();
+    }
+    /** Stops the tick, drains the reconcile queue, and cancels every live session. */ async stop() {
+        await this.epochTicker?.stop();
+        await this.reconcileQueue.cancel();
+        const sessions = this.allSessions();
+        // A clean shutdown is just a restart, so preserve the in-flight broker jobs (abortJobs: false)
+        // for the restarted node to reuse rather than re-proving the epoch from scratch.
+        await Promise.allSettled(sessions.map((s)=>s.cancel('prover-node stopping', {
+                abortJobs: false
+            })));
+    }
+    // ---------------- reconcile ----------------
+    scheduleReconcile(trigger) {
+        return this.reconcileQueue.put(()=>this.reconcile(trigger));
+    }
+    async reconcile(trigger) {
+        this.log.debug(`Reconciling`, {
+            trigger
+        });
+        this.recreateInvalidSessions();
+        const implicatedEpochs = await this.epochsForTrigger(trigger);
+        for (const epoch of implicatedEpochs){
+            await this.openFullSessionIfReady(epoch);
+        }
+        if (trigger.kind === 'start-proof') {
+            this.openPartialSession(trigger.spec);
+        }
+    }
+    recreateInvalidSessions() {
+        for (const [key, session] of Array.from(this.fullSessions.entries())){
+            const canonical = this.checkpointsForSpec(session.getSpec());
+            const contentChanged = !this.checkpointsMatch(session.getCheckpoints(), canonical);
+            if (session.isTerminal()) {
+                // A full session that failed on its own account is retained as a "do not re-prove" marker while
+                // its content is unchanged — this is what stops the tick re-proving a deterministically-failing
+                // epoch. When the content changes (a re-add), it is replaced so the epoch retries over the new
+                // provers. Any other terminal full session is simply dropped.
+                if (session.hasFailed() && !contentChanged) {
+                    continue;
+                }
+                this.fullSessions.delete(key);
+                if (contentChanged && this.canBuildOver(canonical)) {
+                    const newSession = this.constructSession(session.getSpec(), canonical);
+                    this.fullSessions.set(key, newSession);
+                    void this.runSession(newSession);
+                }
+                continue;
+            }
+            if (contentChanged) {
+                this.fireAndForgetCancel(session, 'canonical content changed');
+                this.fullSessions.delete(key);
+                if (this.canBuildOver(canonical)) {
+                    const newSession = this.constructSession(session.getSpec(), canonical);
+                    this.fullSessions.set(key, newSession);
+                    void this.runSession(newSession);
+                }
+            }
+        }
+        for (const [key, session] of Array.from(this.partialSessions.entries())){
+            if (session.isTerminal()) {
+                this.partialSessions.delete(key);
+                continue;
+            }
+            const canonical = this.checkpointsForSpec(session.getSpec());
+            if (!this.checkpointsMatch(session.getCheckpoints(), canonical)) {
+                this.fireAndForgetCancel(session, 'canonical content changed');
+                this.partialSessions.delete(key);
+                if (this.canBuildOver(canonical)) {
+                    const newSession = this.constructSession(session.getSpec(), canonical);
+                    this.partialSessions.set(key, newSession);
+                    void this.runSession(newSession);
+                }
+            }
+        }
+    }
+    /** A session may be built over a checkpoint set only when it is non-empty and contains no failed prover. */ canBuildOver(canonical) {
+        return canonical.length > 0 && !this.hasFailedProver(canonical);
+    }
+    async openFullSessionIfReady(epoch) {
+        // A session present here already covers the epoch: either live, or a retained genuinely-failed
+        // session kept by `recreateInvalidSessions` as a "do not re-prove" marker. Either way, don't open
+        // another — the retained-failed one is replaced only when its canonical content changes.
+        if (this.fullSessions.has(epoch)) {
+            return;
+        }
+        if (this.atMaxSessionLimit()) {
+            this.log.debug(`Skipping full-session open for epoch ${epoch}: max pending jobs reached`);
+            return;
+        }
+        if (!await this.deps.l2BlockSource.isEpochComplete(epoch)) {
+            return;
+        }
+        const l1Constants = await this.getL1Constants();
+        const archiverCps = await this.deps.l2BlockSource.getCheckpoints({
+            epoch
+        });
+        if (archiverCps.length === 0) {
+            return;
+        }
+        const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
+        const canonical = this.deps.checkpointStore.listInSlotRange(fromSlot, toSlot);
+        if (!this.archiverFullyCovered(archiverCps, canonical)) {
+            this.log.debug(`Skipping full-session open for epoch ${epoch}: archiver checkpoints not all in store`, {
+                archiverCount: archiverCps.length,
+                storeCount: canonical.length
+            });
+            return;
+        }
+        if (this.hasFailedProver(canonical)) {
+            // A checkpoint prover in the set has failed (a sub-tree fault or a prune-induced fork fault), so a
+            // session over it would fail immediately. Don't re-create it every tick — it recovers when a
+            // prune/re-add replaces the failed prover with a fresh one, or fails for good at expiry.
+            this.log.debug(`Skipping full-session open for epoch ${epoch}: a checkpoint prover has failed`, {
+                epoch
+            });
+            return;
+        }
+        const spec = {
+            kind: 'full',
+            epochNumber: epoch,
+            fromSlot,
+            toSlot
+        };
+        const session = this.constructSession(spec, canonical);
+        this.fullSessions.set(epoch, session);
+        void this.runSession(session);
+    }
+    openPartialSession(spec) {
+        const canonical = this.deps.checkpointStore.listInSlotRange(spec.fromSlot, spec.toSlot);
+        if (canonical.length === 0 || this.hasFailedProver(canonical)) {
+            return;
+        }
+        // Reuse a live partial session for this epoch whose checkpoint set already matches the
+        // canonical content — e.g. a repeated `startProof` with no new checkpoints mined since the
+        // last one. Reconstructing would re-prove identical content and burn a pending-job slot.
+        const existing = Array.from(this.partialSessions.values()).find((s)=>s.getSpec().epochNumber === spec.epochNumber && !s.isTerminal() && this.checkpointsMatch(s.getCheckpoints(), canonical));
+        if (existing) {
+            return;
+        }
+        if (this.atMaxSessionLimit()) {
+            throw new Error(`Maximum pending proving jobs ${this.deps.config.maxPendingJobs} reached.`);
+        }
+        const session = this.constructSession(spec, canonical);
+        this.partialSessions.set(specKey(spec), session);
+        void this.runSession(session);
+    }
+    // ---------------- session construction ----------------
+    constructSession(spec, checkpoints) {
+        return this.doConstructSession(spec, checkpoints, this.buildSessionDeps(spec.epochNumber), this.sessionHooks);
+    }
+    /** Extracted for test override. */ doConstructSession(spec, checkpoints, sessionDeps, hooks) {
+        return new EpochSession(spec, checkpoints, {
+            ...sessionDeps,
+            hooks
+        });
+    }
+    buildSessionDeps(epochNumber) {
+        const config = {
+            finalizationDelayMs: this.deps.config.finalizationDelayMs
+        };
+        return {
+            proverFactory: this.deps.proverFactory,
+            proverId: this.deps.proverId,
+            publishingService: this.deps.publishingService,
+            metrics: this.deps.metrics,
+            dateProvider: this.deps.dateProvider,
+            deadline: this.computeDeadline(epochNumber),
+            config,
+            bindings: this.deps.bindings
+        };
+    }
+    computeDeadline(epochNumber) {
+        if (!this.cachedL1Constants) {
+            return undefined;
+        }
+        const ts = getProofSubmissionDeadlineTimestamp(epochNumber, this.cachedL1Constants);
+        return new Date(Number(ts) * 1000);
+    }
+    async runSession(session) {
+        // A reconcile may have cancelled this session before it starts (content-change
+        // recreation). Don't proceed — start() would build a TopTreeJob that should never run.
+        if (session.isTerminal()) {
+            this.log.debug(`Skipping start for ${session.getId()}: already terminal (${session.getState()})`);
+            return;
+        }
+        const state = await session.start();
+        this.log.info(`Session ${session.getId()} exited with state ${state}`);
+        // A full session that failed on its own account (top-tree/submit failed with every prover healthy)
+        // is a genuine, race-free failure: upload its post-mortem once. `recreateInvalidSessions` retains
+        // the terminal session so this fires exactly once (it is never re-run over the same content). A
+        // `stopped` session (a prover under it failed) is not uploaded — it may be a prune, and recovers on
+        // re-add.
+        if (session.getKind() === 'full' && session.hasFailed() && this.deps.onSessionFailed) {
+            try {
+                await this.deps.onSessionFailed(session);
+            } catch (err) {
+                this.log.error(`Error in onSessionFailed callback for epoch ${session.getEpochNumber()}`, err);
+            }
+        }
+    }
+    /**
+   * Builds the EpochProvingJobData snapshot for a post-mortem failure upload from a set of
+   * checkpoint provers. Includes every checkpoint regardless of whether sub-tree proving
+   * completed — partial state is still useful for post-mortem analysis.
+   */ static async buildProvingData(checkpoints) {
+        if (checkpoints.length === 0) {
+            throw new Error('Cannot build proving data from an empty checkpoint set');
+        }
+        // Provers no longer cache their txs; re-fetch each checkpoint's txs from the tx pool (concurrently)
+        // for the snapshot. The pool retains them past the proving window (A-1274), so this is durable.
+        const perCheckpoint = await Promise.all(checkpoints.map(async (c)=>({
+                c,
+                txs: await c.getTxsForUpload()
+            })));
+        const txs = new Map();
+        const l1ToL2Messages = {};
+        for (const { c, txs: checkpointTxs } of perCheckpoint){
+            for (const [hash, tx] of checkpointTxs){
+                txs.set(hash, tx);
+            }
+            l1ToL2Messages[c.checkpoint.number] = c.l1ToL2Messages;
+        }
+        return {
+            epochNumber: checkpoints[0].epochNumber,
+            checkpoints: checkpoints.map((c)=>c.checkpoint),
+            txs,
+            l1ToL2Messages,
+            previousBlockHeader: checkpoints[0].previousBlockHeader,
+            attestations: []
+        };
+    }
+    // ---------------- reconcile helpers ----------------
+    atMaxSessionLimit() {
+        const { maxPendingJobs: max } = this.deps.config;
+        if (!max || max <= 0) {
+            return false;
+        }
+        const live = this.allSessions().filter((s)=>!s.isTerminal()).length;
+        return live >= max;
+    }
+    /**
+   * Maps a reconcile trigger to the epochs whose full session should be (re)opened.
+   *
+   * The periodic `tick` returns the next unproven epoch every time; it does not track prior attempts.
+   * `openFullSessionIfReady` is what keeps this from re-proving a doomed epoch: it refuses to build a
+   * session when any checkpoint prover in the set has failed, so a stuck epoch is cheaply skipped each
+   * tick rather than re-proved. `checkpoint` and `prune` fire when an epoch's canonical content changes
+   * (a checkpoint arrives, or a reorg prunes/replaces one) — which is what installs a fresh prover in
+   * place of a failed one, letting the next open succeed and recovering a pruned-then-re-added epoch.
+   */ async epochsForTrigger(trigger) {
+        switch(trigger.kind){
+            case 'checkpoint':
+                return [
+                    trigger.epoch
+                ];
+            case 'prune':
+                return trigger.affectedEpochs;
+            case 'tick':
+                {
+                    const epoch = await this.nextUnprovenEpoch();
+                    return epoch === undefined ? [] : [
+                        epoch
+                    ];
+                }
+            case 'start-proof':
+                return [];
+        }
+    }
+    /**
+   * The next epoch to prove: the epoch containing the first block after the proven tip.
+   * Returns undefined when that block has not been mined yet (e.g. nothing new to prove).
+   * Subsequent ticks advance only once the chain's proven height moves forward, so epochs
+   * are proven in order rather than all at once.
+   */ async nextUnprovenEpoch() {
+        const lastProven = await this.deps.l2BlockSource.getBlockNumber({
+            tag: 'proven'
+        }) ?? BlockNumber.ZERO;
+        const firstToProve = BlockNumber(lastProven + 1);
+        const header = (await this.deps.l2BlockSource.getBlockData({
+            number: firstToProve
+        }))?.header;
+        if (!header) {
+            return undefined;
+        }
+        return getEpochAtSlot(header.getSlot(), await this.getL1Constants());
+    }
+    checkpointsForSpec(spec) {
+        return this.deps.checkpointStore.listInSlotRange(spec.fromSlot, spec.toSlot);
+    }
+    /**
+   * True if any prover in the set has failed. The epoch cannot be proven over a failed prover (it can
+   * never produce its block proofs), so a session must not be built or rebuilt over it until a prune/re-add
+   * has replaced it with a fresh prover.
+   */ hasFailedProver(checkpoints) {
+        return checkpoints.some((c)=>c.isFailed());
+    }
+    fireAndForgetCancel(session, reason) {
+        void session.cancel(reason).catch((err)=>this.log.warn(`Error cancelling session ${session.getId()}`, err));
+    }
+    checkpointsMatch(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for(let i = 0; i < a.length; i++){
+            if (a[i].id !== b[i].id || a[i].isCancelled()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    archiverFullyCovered(archiverCps, storeCps) {
+        if (storeCps.length < archiverCps.length) {
+            return false;
+        }
+        // Compare by content-addressed id (number, slot, archive root) rather than checkpoint number:
+        // a reorg can keep the number while changing the checkpoint's post-state archive root.
+        const storeIds = new Set(storeCps.map((p)=>p.id));
+        return archiverCps.every((cp)=>storeIds.has(CheckpointProver.idFor(cp.checkpoint)));
+    }
+    /**
+   * Returns true if the L1 proven tip already covers every canonical checkpoint in the set — i.e.
+   * the epoch has already been fully proven, so there is no point starting a new proof for it.
+   * Conservatively returns false when nothing is proven yet.
+   */ async isProvenChainEncompassing(canonical) {
+        const provenBlock = await this.deps.l2BlockSource.getBlockNumber({
+            tag: 'proven'
+        });
+        if (!provenBlock || provenBlock <= 0) {
+            return false;
+        }
+        const lastCheckpoint = canonical[canonical.length - 1].checkpoint;
+        const lastBlock = lastCheckpoint.blocks[lastCheckpoint.blocks.length - 1].number;
+        return provenBlock >= lastBlock;
+    }
+    async getL1Constants() {
+        if (!this.cachedL1Constants) {
+            this.cachedL1Constants = await this.deps.l2BlockSource.getL1Constants();
+        }
+        return this.cachedL1Constants;
+    }
+}
+class EmptyEpochError extends Error {
+    constructor(epochNumber){
+        super(`No blocks found for epoch ${epochNumber}`);
+        this.name = 'EmptyEpochError';
+    }
+}
+class EpochAlreadyProvenError extends Error {
+    constructor(epochNumber){
+        super(`Epoch ${epochNumber} is already proven on L1`);
+        this.name = 'EpochAlreadyProvenError';
+    }
+}

package/dest/test/index.d.ts

@@ -1,12 +1,13 @@
+import type { EpochProverFactory } from '@aztec/prover-client';
 import type { EpochProverManager } from '@aztec/stdlib/interfaces/server';
-import type { EpochProvingJob } from '../job/epoch-proving-job.js';
-import type { ProverNodePublisher } from '../prover-node-publisher.js';
+import type { ProofPublishingService } from '../proof-publishing-service.js';
 import { ProverNode } from '../prover-node.js';
+import type { SessionManager } from '../session-manager.js';
 declare abstract class TestProverNodeClass extends ProverNode {
-    prover: EpochProverManager;
-    publisher: ProverNodePublisher;
-    abstract tryUploadEpochFailure(job: EpochProvingJob): Promise<string | undefined>;
+    prover: EpochProverManager & EpochProverFactory;
+    publishingService: ProofPublishingService;
+    sessionManager: SessionManager;
 }
 export type TestProverNode = TestProverNodeClass;
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFMUUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUN2RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFL0MsdUJBQWUsbUJBQW9CLFNBQVEsVUFBVTtJQUNwQyxNQUFNLEVBQUUsa0JBQWtCLENBQUM7SUFDM0IsU0FBUyxFQUFFLG1CQUFtQixDQUFDO0lBRTlDLFNBQXlCLHFCQUFxQixDQUFDLEdBQUcsRUFBRSxlQUFlLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FBQztDQUNuRztBQUVELE1BQU0sTUFBTSxjQUFjLEdBQUcsbUJBQW1CLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDL0QsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUUxRSxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCx1QkFBZSxtQkFBb0IsU0FBUSxVQUFVO0lBQ3BDLE1BQU0sRUFBRSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztJQUNoRCxpQkFBaUIsRUFBRSxzQkFBc0IsQ0FBQztJQUMxQyxjQUFjLEVBQUUsY0FBYyxDQUFDO0NBQy9DO0FBRUQsTUFBTSxNQUFNLGNBQWMsR0FBRyxtQkFBbUIsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,uBAAe,mBAAoB,SAAQ,UAAU;IACpC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,EAAE,mBAAmB,CAAC;IAE9C,SAAyB,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACnG;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,uBAAe,mBAAoB,SAAQ,UAAU;IACpC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;IAChD,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,cAAc,EAAE,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-node",
-  "version": "0.0.1-commit.993d240",
+  "version": "0.0.1-commit.9a89641",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -56,28 +56,29 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "0.0.1-commit.993d240",
-    "@aztec/bb-prover": "0.0.1-commit.993d240",
-    "@aztec/blob-client": "0.0.1-commit.993d240",
-    "@aztec/blob-lib": "0.0.1-commit.993d240",
-    "@aztec/constants": "0.0.1-commit.993d240",
-    "@aztec/epoch-cache": "0.0.1-commit.993d240",
-    "@aztec/ethereum": "0.0.1-commit.993d240",
-    "@aztec/foundation": "0.0.1-commit.993d240",
-    "@aztec/kv-store": "0.0.1-commit.993d240",
-    "@aztec/l1-artifacts": "0.0.1-commit.993d240",
-    "@aztec/native": "0.0.1-commit.993d240",
-    "@aztec/node-keystore": "0.0.1-commit.993d240",
-    "@aztec/node-lib": "0.0.1-commit.993d240",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.993d240",
-    "@aztec/p2p": "0.0.1-commit.993d240",
-    "@aztec/protocol-contracts": "0.0.1-commit.993d240",
-    "@aztec/prover-client": "0.0.1-commit.993d240",
-    "@aztec/sequencer-client": "0.0.1-commit.993d240",
-    "@aztec/simulator": "0.0.1-commit.993d240",
-    "@aztec/stdlib": "0.0.1-commit.993d240",
-    "@aztec/telemetry-client": "0.0.1-commit.993d240",
-    "@aztec/world-state": "0.0.1-commit.993d240",
+    "@aztec/archiver": "0.0.1-commit.9a89641",
+    "@aztec/bb-prover": "0.0.1-commit.9a89641",
+    "@aztec/bb.js": "6.0.0-nightly.20260807",
+    "@aztec/blob-client": "0.0.1-commit.9a89641",
+    "@aztec/blob-lib": "0.0.1-commit.9a89641",
+    "@aztec/constants": "0.0.1-commit.9a89641",
+    "@aztec/epoch-cache": "0.0.1-commit.9a89641",
+    "@aztec/ethereum": "0.0.1-commit.9a89641",
+    "@aztec/foundation": "0.0.1-commit.9a89641",
+    "@aztec/kv-store": "0.0.1-commit.9a89641",
+    "@aztec/l1-artifacts": "6.0.0-nightly.20260807",
+    "@aztec/native": "0.0.1-commit.9a89641",
+    "@aztec/node-keystore": "0.0.1-commit.9a89641",
+    "@aztec/node-lib": "0.0.1-commit.9a89641",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.9a89641",
+    "@aztec/p2p": "0.0.1-commit.9a89641",
+    "@aztec/protocol-contracts": "0.0.1-commit.9a89641",
+    "@aztec/prover-client": "0.0.1-commit.9a89641",
+    "@aztec/sequencer-client": "0.0.1-commit.9a89641",
+    "@aztec/simulator": "0.0.1-commit.9a89641",
+    "@aztec/stdlib": "0.0.1-commit.9a89641",
+    "@aztec/telemetry-client": "0.0.1-commit.9a89641",
+    "@aztec/world-state": "0.0.1-commit.9a89641",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2"