@aztec-labs/prover-node 6.0.0-nightly.20260829

package/dest/job/top-tree-job.d.ts

@@ -0,0 +1,82 @@
+import type { BatchedBlob } from '@aztec-labs/blob-lib/types';
+import type { CheckpointNumber, EpochNumber } from '@aztec-labs/foundation/branded-types';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { type PromiseWithResolvers } from '@aztec-labs/foundation/promise';
+import type { EpochProverFactory } from '@aztec-labs/prover-client';
+import type { Proof } from '@aztec-labs/stdlib/proofs';
+import type { RootRollupPublicInputs } from '@aztec-labs/stdlib/rollup';
+import type { ProverNodeJobMetrics } from '../metrics.js';
+import type { CheckpointProver } from './checkpoint-prover.js';
+/** Result of a successful top-tree run. */
+export type TopTreeProof = {
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+    batchedBlobInputs: BatchedBlob;
+};
+/**
+ * Hooks for tests to interpose around the underlying `topTree.prove(...)` call without
+ * monkey-patching the orchestrator.
+ */
+export type TopTreeJobHooks = {
+    /** Called immediately before the top tree's `prove` runs. */
+    beforeProve?: () => Promise<void> | void;
+    /** Called after `prove` returns successfully (not on failure / cancellation). */
+    afterProve?: () => Promise<void> | void;
+    /**
+     * If set, called instead of running the underlying prove. Receives a thunk that
+     * runs the real call. Lets tests substitute a synthetic proof or delay/throw without
+     * re-implementing the rest of the finalize flow.
+     */
+    proveOverride?: (defaultProve: () => Promise<TopTreeProof>) => Promise<TopTreeProof>;
+};
+/**
+ * Self-contained top-tree job. Constructed from a snapshot of `CheckpointProver`s; runs
+ * `topTree.prove(...)` against their pending `subTreeProofs` promises and exposes the
+ * final epoch proof via `result`.
+ *
+ */
+export declare class TopTreeJob {
+    private readonly epochNumber;
+    private readonly deps;
+    /** Resolves with the final proof on success; rejects on cancellation or any prove error. */
+    readonly result: PromiseWithResolvers<TopTreeProof>;
+    /** Snapshot of checkpoint jobs the top tree is built from, in checkpoint-number order. */
+    readonly snapshot: readonly CheckpointProver[];
+    private readonly topTree;
+    private readonly fromCheckpoint;
+    private readonly toCheckpoint;
+    private cancelled;
+    /** Tracks the cancel-driven background teardown so `whenDone()` can await it. */
+    private cancelPromise?;
+    private readonly executionTimer;
+    constructor(epochNumber: EpochNumber, snapshot: readonly CheckpointProver[], deps: {
+        proverFactory: EpochProverFactory;
+        metrics: ProverNodeJobMetrics;
+        log: Logger;
+        hooks?: TopTreeJobHooks;
+    });
+    /** Range covered by this attempt — useful for logging and L1 submission. */
+    getRange(): {
+        fromCheckpoint: CheckpointNumber;
+        toCheckpoint: CheckpointNumber;
+        count: number;
+    };
+    isCancelled(): boolean;
+    /** Wall-time since construction — used by the owning job for metrics. */
+    elapsedMs(): number;
+    /** Kicks off the prove. Returns the result promise (also available as `result.promise`). */
+    start(): Promise<TopTreeProof>;
+    /**
+     * Cancels the in-flight prove. Idempotent. Rejects the result promise with
+     * `TopTreeCancelledError`, then kicks off the underlying orchestrator's teardown
+     * in the background so callers don't block on it. The teardown promise is exposed
+     * via `whenDone()` — the parent collects the cancelled job and awaits all
+     * pending top-tree teardowns at the end of the epoch.
+     */
+    cancel(abortJobs?: boolean): void;
+    /** Resolves once the cancel-driven teardown of the underlying orchestrator has unwound. */
+    whenDone(): Promise<void>;
+    private runCancel;
+    private run;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/job/top-tree-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"top-tree-job.d.ts","sourceRoot":"","sources":["../../src/job/top-tree-job.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAC1F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,KAAK,oBAAoB,EAAwB,MAAM,gCAAgC,CAAC;AAEjG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAOpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,sBAAsB,CAAC;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,iBAAiB,EAAE,WAAW,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzC,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CACtF,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAU;IAgBnB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAjBvB,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC,YAAY,CAAC,CAA0B;IAE7E,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAE/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmB;IAChD,OAAO,CAAC,SAAS,CAAS;IAC1B,iFAAiF;IACjF,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAE9C,YACmB,WAAW,EAAE,WAAW,EACzC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACpB,IAAI,EAAE;QACrB,aAAa,EAAE,kBAAkB,CAAC;QAClC,OAAO,EAAE,oBAAoB,CAAC;QAC9B,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,CAAC,EAAE,eAAe,CAAC;KACzB,EA8BF;IAED,8EAA4E;IACrE,QAAQ,IAAI;QAAE,cAAc,EAAE,gBAAgB,CAAC;QAAC,YAAY,EAAE,gBAAgB,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAErG;IAEM,WAAW,IAAI,OAAO,CAE5B;IAED,2EAAyE;IAClE,SAAS,IAAI,MAAM,CAEzB;IAED,4FAA4F;IACrF,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC,CAGpC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,SAAS,UAAO,GAAG,IAAI,CAmBpC;IAED,2FAA2F;IAC9E,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAIrC;YAEa,SAAS;YAaT,GAAG;CAuDlB"}

package/dest/job/top-tree-job.js

@@ -0,0 +1,152 @@
+import { promiseWithResolvers } from '@aztec-labs/foundation/promise';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { buildFinalBlobChallenges } from '@aztec-labs/prover-client/helpers';
+import { TopTreeCancelledError } from '@aztec-labs/prover-client/orchestrator';
+/**
+ * Self-contained top-tree job. Constructed from a snapshot of `CheckpointProver`s; runs
+ * `topTree.prove(...)` against their pending `subTreeProofs` promises and exposes the
+ * final epoch proof via `result`.
+ *
+ */ export class TopTreeJob {
+    epochNumber;
+    deps;
+    /** Resolves with the final proof on success; rejects on cancellation or any prove error. */ result;
+    /** Snapshot of checkpoint jobs the top tree is built from, in checkpoint-number order. */ snapshot;
+    topTree;
+    fromCheckpoint;
+    toCheckpoint;
+    cancelled;
+    /** Tracks the cancel-driven background teardown so `whenDone()` can await it. */ cancelPromise;
+    executionTimer;
+    constructor(epochNumber, snapshot, deps){
+        this.epochNumber = epochNumber;
+        this.deps = deps;
+        this.result = promiseWithResolvers();
+        this.cancelled = false;
+        this.executionTimer = new Timer();
+        if (snapshot.length === 0) {
+            throw new Error(`Cannot construct TopTreeJob for epoch ${epochNumber}: empty snapshot`);
+        }
+        for(let i = 1; i < snapshot.length; i++){
+            const prev = snapshot[i - 1].checkpoint.number;
+            const curr = snapshot[i].checkpoint.number;
+            if (curr !== prev + 1) {
+                throw new Error(`Cannot construct TopTreeJob for epoch ${epochNumber}: checkpoint numbers must be contiguous, got gap between ${prev} and ${curr}`);
+            }
+        }
+        this.snapshot = snapshot;
+        this.fromCheckpoint = snapshot[0].checkpoint.number;
+        this.toCheckpoint = snapshot[snapshot.length - 1].checkpoint.number;
+        this.topTree = deps.proverFactory.createTopTreeOrchestrator();
+        deps.log.info(`Created TopTreeJob for epoch ${epochNumber} covering checkpoints ${this.fromCheckpoint}..${this.toCheckpoint}`, {
+            epochNumber,
+            fromCheckpoint: this.fromCheckpoint,
+            toCheckpoint: this.toCheckpoint,
+            checkpointCount: snapshot.length
+        });
+        // Mark the result's rejection branch as observed so a cancellation before any
+        // consumer awaits does not surface as unhandled.
+        this.result.promise.catch(()=>{});
+    }
+    /** Range covered by this attempt — useful for logging and L1 submission. */ getRange() {
+        return {
+            fromCheckpoint: this.fromCheckpoint,
+            toCheckpoint: this.toCheckpoint,
+            count: this.snapshot.length
+        };
+    }
+    isCancelled() {
+        return this.cancelled;
+    }
+    /** Wall-time since construction — used by the owning job for metrics. */ elapsedMs() {
+        return this.executionTimer.ms();
+    }
+    /** Kicks off the prove. Returns the result promise (also available as `result.promise`). */ start() {
+        void this.run();
+        return this.result.promise;
+    }
+    /**
+   * Cancels the in-flight prove. Idempotent. Rejects the result promise with
+   * `TopTreeCancelledError`, then kicks off the underlying orchestrator's teardown
+   * in the background so callers don't block on it. The teardown promise is exposed
+   * via `whenDone()` — the parent collects the cancelled job and awaits all
+   * pending top-tree teardowns at the end of the epoch.
+   */ cancel(abortJobs = true) {
+        if (this.cancelled) {
+            return;
+        }
+        this.cancelled = true;
+        this.deps.log.info(`Cancelling TopTreeJob for epoch ${this.epochNumber} (checkpoints ${this.fromCheckpoint}..${this.toCheckpoint})`, {
+            epochNumber: this.epochNumber,
+            fromCheckpoint: this.fromCheckpoint,
+            toCheckpoint: this.toCheckpoint,
+            elapsedMs: this.executionTimer.ms()
+        });
+        this.result.reject(new TopTreeCancelledError());
+        // Fire and forget: parent awaits the cancel-driven teardown via whenDone(); the
+        // chained .catch swallows rejections so the unawaited promise doesn't surface
+        // as an unhandled rejection.
+        this.cancelPromise = this.runCancel(abortJobs).catch(()=>{});
+    }
+    /** Resolves once the cancel-driven teardown of the underlying orchestrator has unwound. */ async whenDone() {
+        if (this.cancelPromise) {
+            await this.cancelPromise;
+        }
+    }
+    async runCancel(abortJobs) {
+        try {
+            this.topTree.cancel({
+                abortJobs
+            });
+        } catch (err) {
+            this.deps.log.error('Error cancelling top tree', err);
+        }
+        try {
+            await this.topTree.stop();
+        } catch (err) {
+            this.deps.log.error('Error stopping top tree', err);
+        }
+    }
+    async run() {
+        try {
+            const blobTimer = new Timer();
+            const blobFieldsPerCheckpoint = this.snapshot.map((j)=>j.checkpoint.toBlobFields());
+            const finalBlobBatchingChallenges = await buildFinalBlobChallenges(blobFieldsPerCheckpoint);
+            this.deps.metrics.recordBlobProcessing(blobTimer.ms());
+            this.deps.log.verbose(`Built final blob batching challenges for epoch ${this.epochNumber} in ${blobTimer.ms()}ms`, {
+                epochNumber: this.epochNumber,
+                checkpointCount: this.snapshot.length,
+                durationMs: blobTimer.ms()
+            });
+            const checkpointData = this.snapshot.map((j)=>({
+                    subTreeProofs: j.whenSubTreeProofsReady(),
+                    l2ToL1MsgsPerBlock: j.checkpoint.blocks.map((b)=>b.body.txEffects.map((tx)=>tx.l2ToL1Msgs)),
+                    blobFields: j.checkpoint.toBlobFields(),
+                    previousBlockHeader: j.previousBlockHeader,
+                    previousArchiveSiblingPath: j.previousArchiveSiblingPath
+                }));
+            const defaultProve = ()=>this.topTree.prove(this.epochNumber, this.snapshot.length, finalBlobBatchingChallenges, checkpointData);
+            await this.deps.hooks?.beforeProve?.();
+            const proveTimer = new Timer();
+            this.deps.log.info(`Starting top-tree prove for epoch ${this.epochNumber} (checkpoints ${this.fromCheckpoint}..${this.toCheckpoint})`, {
+                epochNumber: this.epochNumber,
+                fromCheckpoint: this.fromCheckpoint,
+                toCheckpoint: this.toCheckpoint,
+                checkpointCount: this.snapshot.length
+            });
+            const proof = await (this.deps.hooks?.proveOverride ? this.deps.hooks.proveOverride(defaultProve) : defaultProve());
+            await this.deps.hooks?.afterProve?.();
+            this.deps.log.info(`Top-tree prove succeeded for epoch ${this.epochNumber} in ${proveTimer.ms()}ms`, {
+                epochNumber: this.epochNumber,
+                fromCheckpoint: this.fromCheckpoint,
+                toCheckpoint: this.toCheckpoint,
+                durationMs: proveTimer.ms(),
+                totalElapsedMs: this.executionTimer.ms()
+            });
+            this.result.resolve(proof);
+        } catch (err) {
+            // Cancel paths surface as TopTreeCancelledError; everything else propagates as-is.
+            this.result.reject(err);
+        }
+    }
+}

package/dest/metrics.d.ts

@@ -0,0 +1,88 @@
+import type { RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { L1PublishProofStats } from '@aztec-labs/stdlib/stats';
+import { type Gauge, type Histogram, type Meter, type TelemetryClient, type Tracer, type UpDownCounter } from '@aztec-labs/telemetry-client';
+import type { CheckpointStore } from './checkpoint-store.js';
+import type { SessionManager } from './session-manager.js';
+export declare class ProverNodeJobMetrics {
+    private meter;
+    readonly tracer: Tracer;
+    private logger;
+    provingJobDuration: Histogram;
+    provingJobCheckpoints: Gauge;
+    provingJobBlocks: Gauge;
+    provingJobTransactions: Gauge;
+    private blobProcessingDuration;
+    private blockProcessingDuration;
+    private checkpointProcessingDuration;
+    private checkpointProvingDuration;
+    private checkpointBlocks;
+    private checkpointTransactions;
+    /** Observable gauges for live state. Registered via `observeState(...)` once the
+     *  CheckpointStore and SessionManager are available. */
+    private activeCheckpoints;
+    private activeEpochSessions;
+    private stateObserver;
+    private stateObservedMetrics;
+    constructor(meter: Meter, tracer: Tracer, logger?: import("@aztec-labs/foundation/log").Logger);
+    recordProvingJob(totalTimeMs: number, numCheckpoints: number, numBlocks: number, numTxs: number): void;
+    recordBlobProcessing(durationMs: number): void;
+    recordBlockProcessing(durationMs: number): void;
+    recordCheckpointProcessing(durationMs: number, numBlocks: number, numTxs: number): void;
+    recordCheckpointProving(durationMs: number): void;
+    /**
+     * Registers observable gauges for the prover-node's live state: how many canonical
+     * checkpoint provers are in the store, and how many epoch sessions are live (broken
+     * down by kind). Idempotent — repeated calls re-arm with the latest references.
+     *
+     * Call this once the `SessionManager` has been constructed (i.e. inside `ProverNode.start()`).
+     */
+    observeState(checkpointStore: CheckpointStore, sessionManager: SessionManager): void;
+    /** Tears down the observable callback registered by `observeState`. Idempotent. */
+    stopObservingState(): void;
+}
+export declare class ProverNodeRewardsMetrics {
+    private meter;
+    private coinbase;
+    private rollup;
+    private logger;
+    private rewards;
+    private accumulatedRewards;
+    private prevEpoch;
+    private proofSubmissionEpochs;
+    constructor(meter: Meter, coinbase: EthAddress, rollup: RollupContract, logger?: import("@aztec-labs/foundation/log").Logger);
+    start(): Promise<void>;
+    stop(): void;
+    private observe;
+}
+export type EstimatedSubmitProofStats = {
+    gasLimit: bigint;
+    baseFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    estimatedTotalFee: bigint;
+};
+export declare class ProverNodePublisherMetrics {
+    readonly client: TelemetryClient;
+    private logger;
+    gasPrice: Histogram;
+    txCount: UpDownCounter;
+    txDuration: Histogram;
+    txGas: Histogram;
+    txCalldataSize: Histogram;
+    txCalldataGas: Histogram;
+    txBlobDataGasUsed: Histogram;
+    txBlobDataGasCost: Histogram;
+    txTotalFee: Histogram;
+    private txGasEstimated;
+    private gasPriceEstimated;
+    private txTotalFeeEstimated;
+    private senderBalance;
+    private meter;
+    constructor(client: TelemetryClient, name?: string, logger?: import("@aztec-labs/foundation/log").Logger);
+    recordFailedTx(): void;
+    recordSubmitProof(durationMs: number, stats: L1PublishProofStats): void;
+    recordEstimatedSubmitProof(stats: EstimatedSubmitProofStats): void;
+    recordSenderBalance(wei: bigint, senderAddress: string): void;
+    private recordTx;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/metrics.d.ts.map

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

package/dest/metrics.js

@@ -0,0 +1,264 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec-labs/telemetry-client';
+import { formatEther, formatUnits } from 'viem';
+export class ProverNodeJobMetrics {
+    meter;
+    tracer;
+    logger;
+    provingJobDuration;
+    provingJobCheckpoints;
+    provingJobBlocks;
+    provingJobTransactions;
+    blobProcessingDuration;
+    blockProcessingDuration;
+    checkpointProcessingDuration;
+    checkpointProvingDuration;
+    checkpointBlocks;
+    checkpointTransactions;
+    /** Observable gauges for live state. Registered via `observeState(...)` once the
+   *  CheckpointStore and SessionManager are available. */ activeCheckpoints;
+    activeEpochSessions;
+    stateObserver;
+    stateObservedMetrics;
+    constructor(meter, tracer, logger = createLogger('prover-node:publisher:metrics')){
+        this.meter = meter;
+        this.tracer = tracer;
+        this.logger = logger;
+        this.stateObservedMetrics = [];
+        this.provingJobDuration = this.meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION);
+        this.provingJobCheckpoints = this.meter.createGauge(Metrics.PROVER_NODE_JOB_CHECKPOINTS);
+        this.provingJobBlocks = this.meter.createGauge(Metrics.PROVER_NODE_JOB_BLOCKS);
+        this.provingJobTransactions = this.meter.createGauge(Metrics.PROVER_NODE_JOB_TRANSACTIONS);
+        this.blobProcessingDuration = this.meter.createGauge(Metrics.PROVER_NODE_BLOB_PROCESSING_LAST_DURATION);
+        this.blockProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_BLOCK_PROCESSING_DURATION);
+        this.checkpointProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_PROCESSING_DURATION);
+        this.checkpointProvingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_PROVING_DURATION);
+        this.checkpointBlocks = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_BLOCKS);
+        this.checkpointTransactions = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_TRANSACTIONS);
+    }
+    recordProvingJob(totalTimeMs, numCheckpoints, numBlocks, numTxs) {
+        this.provingJobDuration.record(totalTimeMs / 1000);
+        this.provingJobCheckpoints.record(Math.floor(numCheckpoints));
+        this.provingJobBlocks.record(Math.floor(numBlocks));
+        this.provingJobTransactions.record(Math.floor(numTxs));
+    }
+    recordBlobProcessing(durationMs) {
+        this.blobProcessingDuration.record(Math.ceil(durationMs));
+    }
+    recordBlockProcessing(durationMs) {
+        this.blockProcessingDuration.record(Math.ceil(durationMs));
+    }
+    recordCheckpointProcessing(durationMs, numBlocks, numTxs) {
+        this.checkpointProcessingDuration.record(Math.ceil(durationMs));
+        this.checkpointBlocks.record(Math.floor(numBlocks));
+        this.checkpointTransactions.record(Math.floor(numTxs));
+    }
+    recordCheckpointProving(durationMs) {
+        this.checkpointProvingDuration.record(Math.ceil(durationMs));
+    }
+    /**
+   * Registers observable gauges for the prover-node's live state: how many canonical
+   * checkpoint provers are in the store, and how many epoch sessions are live (broken
+   * down by kind). Idempotent — repeated calls re-arm with the latest references.
+   *
+   * Call this once the `SessionManager` has been constructed (i.e. inside `ProverNode.start()`).
+   */ observeState(checkpointStore, sessionManager) {
+        this.stopObservingState();
+        this.activeCheckpoints = this.meter.createObservableGauge(Metrics.PROVER_NODE_ACTIVE_CHECKPOINTS);
+        this.activeEpochSessions = this.meter.createObservableGauge(Metrics.PROVER_NODE_ACTIVE_EPOCH_SESSIONS);
+        this.stateObserver = (observer)=>{
+            observer.observe(this.activeCheckpoints, checkpointStore.listAll().length);
+            let full = 0;
+            let partial = 0;
+            for (const session of sessionManager.allSessions()){
+                if (session.isTerminal()) {
+                    continue;
+                }
+                if (session.getKind() === 'full') {
+                    full++;
+                } else {
+                    partial++;
+                }
+            }
+            observer.observe(this.activeEpochSessions, full, {
+                [Attributes.EPOCH_SESSION_KIND]: 'full'
+            });
+            observer.observe(this.activeEpochSessions, partial, {
+                [Attributes.EPOCH_SESSION_KIND]: 'partial'
+            });
+        };
+        this.stateObservedMetrics = [
+            this.activeCheckpoints,
+            this.activeEpochSessions
+        ];
+        this.meter.addBatchObservableCallback(this.stateObserver, this.stateObservedMetrics);
+    }
+    /** Tears down the observable callback registered by `observeState`. Idempotent. */ stopObservingState() {
+        if (this.stateObserver) {
+            this.meter.removeBatchObservableCallback(this.stateObserver, this.stateObservedMetrics);
+            this.stateObserver = undefined;
+            this.stateObservedMetrics = [];
+            this.activeCheckpoints = undefined;
+            this.activeEpochSessions = undefined;
+        }
+    }
+}
+export class ProverNodeRewardsMetrics {
+    meter;
+    coinbase;
+    rollup;
+    logger;
+    rewards;
+    accumulatedRewards;
+    prevEpoch;
+    proofSubmissionEpochs;
+    constructor(meter, coinbase, rollup, logger = createLogger('prover-node:publisher:metrics')){
+        this.meter = meter;
+        this.coinbase = coinbase;
+        this.rollup = rollup;
+        this.logger = logger;
+        this.prevEpoch = -1n;
+        this.proofSubmissionEpochs = 0;
+        this.observe = async (observer)=>{
+            const epoch = await this.rollup.getCurrentEpochNumber();
+            if (epoch > this.proofSubmissionEpochs) {
+                // look at the prev epoch so that we get an accurate value, after proof submission window has closed
+                // For example, if proof submission window is 1 epoch, and we are in epoch 2, we should be looking at epoch 0.
+                // Similarly, if the proof submission window is 0, and we are in epoch 1, we should be looking at epoch 0.
+                const closedEpoch = BigInt(epoch) - BigInt(this.proofSubmissionEpochs) - 1n;
+                const rewards = await this.rollup.getSpecificProverRewardsForEpoch(closedEpoch, this.coinbase);
+                const fmt = parseFloat(formatUnits(rewards, 18));
+                observer.observe(this.rewards, fmt, {
+                    [Attributes.COINBASE]: this.coinbase.toString()
+                });
+                // only accumulate once per epoch
+                if (closedEpoch > this.prevEpoch) {
+                    this.prevEpoch = closedEpoch;
+                    this.accumulatedRewards.add(fmt, {
+                        [Attributes.COINBASE]: this.coinbase.toString()
+                    });
+                }
+            }
+        };
+        this.rewards = this.meter.createObservableGauge(Metrics.PROVER_NODE_REWARDS_PER_EPOCH);
+        this.accumulatedRewards = createUpDownCounterWithDefault(this.meter, Metrics.PROVER_NODE_REWARDS_TOTAL);
+    }
+    async start() {
+        const proofSubmissionEpochs = await this.rollup.getProofSubmissionEpochs();
+        this.proofSubmissionEpochs = Number(proofSubmissionEpochs);
+        this.meter.addBatchObservableCallback(this.observe, [
+            this.rewards
+        ]);
+    }
+    stop() {
+        this.meter.removeBatchObservableCallback(this.observe, [
+            this.rewards
+        ]);
+    }
+    observe;
+}
+export class ProverNodePublisherMetrics {
+    client;
+    logger;
+    gasPrice;
+    txCount;
+    txDuration;
+    txGas;
+    txCalldataSize;
+    txCalldataGas;
+    txBlobDataGasUsed;
+    txBlobDataGasCost;
+    txTotalFee;
+    txGasEstimated;
+    gasPriceEstimated;
+    txTotalFeeEstimated;
+    senderBalance;
+    meter;
+    constructor(client, name = 'ProverNode', logger = createLogger('prover-node:publisher:metrics')){
+        this.client = client;
+        this.logger = logger;
+        this.meter = client.getMeter(name);
+        this.gasPrice = this.meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE);
+        this.txCount = createUpDownCounterWithDefault(this.meter, Metrics.L1_PUBLISHER_TX_COUNT, {
+            [Attributes.L1_TX_TYPE]: [
+                'submitProof'
+            ],
+            [Attributes.OK]: [
+                true,
+                false
+            ]
+        });
+        this.txDuration = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION);
+        this.txGas = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS);
+        this.txCalldataSize = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE);
+        this.txCalldataGas = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS);
+        this.txBlobDataGasUsed = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED);
+        this.txBlobDataGasCost = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST);
+        this.txTotalFee = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
+        this.txGasEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_GAS);
+        this.gasPriceEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_GAS_PRICE);
+        this.txTotalFeeEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_TOTAL_FEE);
+        this.senderBalance = this.meter.createGauge(Metrics.L1_PUBLISHER_BALANCE);
+    }
+    recordFailedTx() {
+        this.txCount.add(1, {
+            [Attributes.L1_TX_TYPE]: 'submitProof',
+            [Attributes.OK]: false
+        });
+    }
+    recordSubmitProof(durationMs, stats) {
+        this.recordTx(durationMs, stats);
+    }
+    recordEstimatedSubmitProof(stats) {
+        const attributes = {
+            [Attributes.L1_TX_TYPE]: 'submitProof'
+        };
+        this.txGasEstimated.record(Number(stats.gasLimit), attributes);
+        try {
+            this.gasPriceEstimated.record(parseInt(formatEther(stats.baseFeePerGas + stats.maxPriorityFeePerGas, 'gwei'), 10));
+        } catch  {
+        // ignore
+        }
+        try {
+            this.txTotalFeeEstimated.record(parseFloat(formatEther(stats.estimatedTotalFee)));
+        } catch  {
+        // ignore
+        }
+    }
+    recordSenderBalance(wei, senderAddress) {
+        const eth = parseFloat(formatEther(wei, 'wei'));
+        this.senderBalance.record(eth, {
+            [Attributes.SENDER_ADDRESS]: senderAddress
+        });
+    }
+    recordTx(durationMs, stats) {
+        const attributes = {
+            [Attributes.L1_TX_TYPE]: 'submitProof',
+            [Attributes.L1_SENDER]: stats.sender
+        };
+        this.txCount.add(1, {
+            ...attributes,
+            [Attributes.OK]: true
+        });
+        this.txDuration.record(Math.ceil(durationMs), attributes);
+        this.txGas.record(// safe to downcast - total block limit is 30M gas which fits in a JS number
+        Number(stats.gasUsed), attributes);
+        this.txCalldataGas.record(stats.calldataGas, attributes);
+        this.txCalldataSize.record(stats.calldataSize, attributes);
+        this.txBlobDataGasCost.record(Number(stats.blobDataGas), attributes);
+        this.txBlobDataGasUsed.record(Number(stats.blobGasUsed), attributes);
+        try {
+            this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+        } catch  {
+        // ignore
+        }
+        const executionFee = stats.gasUsed * stats.gasPrice;
+        const blobFee = stats.blobGasUsed * stats.blobDataGas;
+        const totalFee = executionFee + blobFee;
+        try {
+            this.txTotalFee.record(parseFloat(formatEther(totalFee)));
+        } catch  {
+        // ignore
+        }
+    }
+}

package/dest/monitors/epoch-monitor.d.ts

@@ -0,0 +1,43 @@
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import type { L2BlockSource } from '@aztec-labs/stdlib/block';
+import { type L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import { type TelemetryClient, type Traceable, type Tracer } from '@aztec-labs/telemetry-client';
+export interface EpochMonitorHandler {
+    handleEpochReadyToProve(epochNumber: EpochNumber): Promise<boolean>;
+}
+/**
+ * Fires an event when a new epoch ready to prove is detected.
+ *
+ * We define an epoch as ready to prove when:
+ * - The epoch is complete
+ * - Its blocks have not been reorg'd out due to a missing L2 proof
+ * - Its first block is the immediate successor of the last proven block
+ *
+ * This class periodically hits the L2BlockSource.
+ * On start it will trigger the event for the last epoch ready to prove.
+ */
+export declare class EpochMonitor implements Traceable {
+    private readonly l2BlockSource;
+    private readonly l1Constants;
+    private options;
+    private runningPromise;
+    private log;
+    readonly tracer: Tracer;
+    private handler;
+    private latestEpochNumber;
+    constructor(l2BlockSource: L2BlockSource, l1Constants: Pick<L1RollupConstants, 'epochDuration'>, options: {
+        pollingIntervalMs: number;
+        provingDelayMs?: number;
+    }, telemetry?: TelemetryClient);
+    static create(l2BlockSource: L2BlockSource, options: {
+        pollingIntervalMs: number;
+        provingDelayMs?: number;
+    }, telemetry?: TelemetryClient): Promise<EpochMonitor>;
+    start(handler: EpochMonitorHandler): void;
+    /** Exposed for testing */
+    setHandler(handler: EpochMonitorHandler): void;
+    stop(): Promise<void>;
+    work(): Promise<void>;
+    private getEpochNumberToProve;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2gtbW9uaXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vbml0b3JzL2Vwb2NoLW1vbml0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFlLFdBQVcsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBSWhGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzlELE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUFrQixNQUFNLGtDQUFrQyxDQUFDO0FBQzFGLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBRSxLQUFLLFNBQVMsRUFBRSxLQUFLLE1BQU0sRUFBc0IsTUFBTSw4QkFBOEIsQ0FBQztBQUVySCxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLHVCQUF1QixDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0NBQ3JFO0FBRUQ7Ozs7Ozs7Ozs7R0FVRztBQUNILHFCQUFhLFlBQWEsWUFBVyxTQUFTO0lBUzFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsYUFBYTtJQUM5QixPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVc7SUFDNUIsT0FBTyxDQUFDLE9BQU87SUFWakIsT0FBTyxDQUFDLGNBQWMsQ0FBaUI7SUFDdkMsT0FBTyxDQUFDLEdBQUcsQ0FBNkM7SUFDeEQsU0FBZ0IsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUUvQixPQUFPLENBQUMsT0FBTyxDQUFrQztJQUNqRCxPQUFPLENBQUMsaUJBQWlCLENBQTBCO0lBRW5ELFlBQ21CLGFBQWEsRUFBRSxhQUFhLEVBQzVCLFdBQVcsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLEVBQzlELE9BQU8sRUFBRTtRQUFFLGlCQUFpQixFQUFFLE1BQU0sQ0FBQztRQUFDLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtLQUFFLEVBQ3ZFLFNBQVMsR0FBRSxlQUFzQyxFQU9sRDtJQUVELE9BQW9CLE1BQU0sQ0FDeEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsT0FBTyxFQUFFO1FBQUUsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO1FBQUMsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFDL0QsU0FBUyxHQUFFLGVBQXNDLEdBQ2hELE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FHdkI7SUFFTSxLQUFLLENBQUMsT0FBTyxFQUFFLG1CQUFtQixRQUl4QztJQUVELDBCQUEwQjtJQUNuQixVQUFVLENBQUMsT0FBTyxFQUFFLG1CQUFtQixRQUU3QztJQUVZLElBQUksa0JBR2hCO0lBRVksSUFBSSxrQkEwQmhCO1lBRWEscUJBQXFCO0NBWXBDIn0=

package/dest/monitors/epoch-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-monitor.d.ts","sourceRoot":"","sources":["../../src/monitors/epoch-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAIhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,kCAAkC,CAAC;AAC1F,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAAsB,MAAM,8BAA8B,CAAC;AAErH,MAAM,WAAW,mBAAmB;IAClC,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACrE;AAED;;;;;;;;;;GAUG;AACH,qBAAa,YAAa,YAAW,SAAS;IAS1C,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,OAAO;IAVjB,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,GAAG,CAA6C;IACxD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,iBAAiB,CAA0B;IAEnD,YACmB,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EAC9D,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,EACvE,SAAS,GAAE,eAAsC,EAOlD;IAED,OAAoB,MAAM,CACxB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,EAC/D,SAAS,GAAE,eAAsC,GAChD,OAAO,CAAC,YAAY,CAAC,CAGvB;IAEM,KAAK,CAAC,OAAO,EAAE,mBAAmB,QAIxC;IAED,0BAA0B;IACnB,UAAU,CAAC,OAAO,EAAE,mBAAmB,QAE7C;IAEY,IAAI,kBAGhB;IAEY,IAAI,kBA0BhB;YAEa,qBAAqB;CAYpC"}