@aztec/prover-node 5.0.0-private.20260319 → 5.0.0-rc.1

package/dest/proof-publishing-service.d.ts

@@ -0,0 +1,159 @@
+import type { BatchedBlob } from '@aztec/blob-lib';
+import type { ViemCommitteeAttestation } from '@aztec/ethereum/contracts';
+import { BlockNumber, type CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { ProverNodePublisher } from './prover-node-publisher.js';
+import type { ProverPublisherFactory } from './prover-publisher-factory.js';
+/** A single proof candidate offered to the publishing service by an `EpochSession`. */
+export type PublishCandidate = {
+    /** Stable id; matches the originating session so `withdraw` can target this entry. */
+    id: string;
+    epoch: EpochNumber;
+    /**
+     * Full vs partial. A `partial` candidate is an early-finish optimisation: if the chain's
+     * proven tip catches up to or past its `endBlock` before it publishes, it's superseded —
+     * publishing would be wasted L1 gas. A `full` candidate covers the entire epoch and is
+     * useful to publish even after some other prover-node has already submitted (the rollup
+     * contract records the submission per prover-id), so it is never auto-superseded by the
+     * proven tip alone.
+     */
+    kind: 'full' | 'partial';
+    /** First L2 block in the candidate's range. */
+    startBlock: BlockNumber;
+    /** Last L2 block in the candidate's range. */
+    endBlock: BlockNumber;
+    /**
+     * Wall-clock time after which the candidate is no longer worth publishing — typically
+     * the L1 proof-submission window deadline. If the candidate is still queued at this
+     * time it resolves as `'expired'`. If it's already in flight, the publish runs to
+     * completion (the L1 tx may still mine; the deadline only governs whether the service
+     * will start a publish). `undefined` disables the per-candidate timer.
+     */
+    deadline: Date | undefined;
+    /** Everything `ProverNodePublisher.submitEpochProof` needs. */
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+    batchedBlobInputs: BatchedBlob;
+    attestations: ViemCommitteeAttestation[];
+};
+/** Terminal outcome for a candidate. The promise from `submit()` resolves with one of these. */
+export type PublishOutcome = 'published' | 'superseded' | 'failed' | 'withdrawn' | 'expired';
+/** Subset of `ProverPublisherFactory` the service uses — single async `create()` call. */
+export type PublisherFactoryLike = Pick<ProverPublisherFactory, 'create'>;
+/** Subset of `ProverNodePublisher` the service drives — one publish per fresh publisher. */
+export type PublisherLike = Pick<ProverNodePublisher, 'submitEpochProof' | 'analyzeEpochProofSubmission'>;
+/** Config for the publishing service. */
+export type ProofPublishingServiceConfig = {
+    /** When true, submitting a candidate runs `analyzeEpochProofSubmission` instead of publishing. */
+    skipSubmitProof: boolean;
+};
+export type ProofPublishingServiceDeps = {
+    publisherFactory: PublisherFactoryLike;
+    l2BlockSource: Pick<L2BlockSource, 'getBlockNumber'>;
+    dateProvider: DateProvider;
+    config: ProofPublishingServiceConfig;
+    bindings?: LoggerBindings;
+};
+/**
+ * Central owner of L1 proof submission. Sessions offer their proofs here as
+ * `PublishCandidate`s; the service serialises one publish at a time, picks the
+ * longest candidate per epoch as the winner, and resolves the rest as
+ * `'superseded'` without spending L1 gas.
+ *
+ * Construction-time invariants:
+ * - Every publish runs against a freshly-created `ProverNodePublisher` from the factory.
+ * - Only one publish is ever in flight (`SerialQueue` drain) — no defensive locks.
+ * - Once an L1 publish starts, it runs to completion. `withdraw` is a queue-only
+ *   operation: it removes a candidate that has not yet started publishing. An in-flight
+ *   candidate is left alone and its outcome (`'published'` / `'failed'`) is reported as
+ *   usual — the originating session has already moved to a terminal state via `cancel()`
+ *   and ignores the late outcome.
+ *
+ * Eligibility for publication is decided against the proven block number read inside
+ * the drain (so the value is consistent with the publish that runs on the same drain
+ * pass): a candidate is eligible when its predecessor block is proven and (for partial
+ * candidates) the candidate's range extends past the proven tip. `onChainProven` is a
+ * wake-up signal; it does not pass state into the drain.
+ */
+export declare class ProofPublishingService {
+    private readonly deps;
+    private readonly log;
+    private readonly epochs;
+    /**
+     * One drain task at a time. Submits, withdrawals, chain-proven advances, and prunes
+     * all schedule a `drain` here, so the eligibility re-check and the L1 publish never
+     * interleave.
+     *
+     * Protected so unit tests can `await drainQueue.syncPoint()` to wait for pending
+     * drain work to settle deterministically (no sleeps).
+     */
+    protected readonly drainQueue: SerialQueue;
+    /** Tracks the candidate currently being published. Set while drain is awaiting the L1 publish. */
+    private inFlight;
+    private stopped;
+    constructor(deps: ProofPublishingServiceDeps);
+    /**
+     * Offers a proof candidate to the service. The returned promise resolves once the
+     * service settles the candidate's fate: `'published'` if it wins and L1 accepts it,
+     * `'superseded'` if a longer candidate for the same epoch wins, `'failed'` if the
+     * L1 submission errored, `'withdrawn'` if the originating session cancelled,
+     * `'expired'` if the candidate's `deadline` elapsed before publishing started.
+     */
+    submit(candidate: PublishCandidate): Promise<PublishOutcome>;
+    /**
+     * Pulls a queued candidate from the bucket and resolves its promise as `'withdrawn'`.
+     * If the candidate is already being published, the publish runs to completion and the
+     * outcome reports whatever L1 returned — callers that cancelled mid-publish must rely
+     * on their own terminal-state check to ignore the late outcome. No-op if the candidate
+     * is unknown.
+     */
+    withdraw(candidateId: string): void;
+    /**
+     * Signals that the L1 proven tip has advanced and the queue should be re-evaluated.
+     * The drain reads the proven block number from `l2BlockSource` itself rather than
+     * relying on the value passed here — that way the eligibility check uses a value read
+     * inside the serial drain, not one captured by a concurrent caller of `onChainProven`.
+     */
+    onChainProven(_provenBlock: BlockNumber): void;
+    /**
+     * Stops accepting new submissions, waits for any in-flight publish to settle, and
+     * resolves remaining queued candidates as `'withdrawn'`.
+     */
+    stop(): Promise<void>;
+    private scheduleDrain;
+    private drain;
+    /**
+     * Picks the winning candidate for a given epoch. Partial candidates whose `endBlock` is
+     * already proven on-chain resolve `'superseded'`.
+     * Full candidates are never auto-superseded by the proven tip — multiple prover-nodes
+     * legitimately submit redundant full epoch proofs (one per prover-id) and L1 records each.
+     * Among the remaining candidates with their predecessor proven, the one with the highest
+     * `endBlock` wins; the others resolve `'superseded'`.
+     */
+    private pickEpochWinner;
+    private publishWinner;
+    private runPublish;
+    private resolveCandidate;
+    /**
+     * Arms a per-candidate expiry timer if the candidate carries a deadline. When the timer
+     * fires, the candidate resolves as `'expired'` — unless it is already in flight, in
+     * which case the publish runs to completion (the timer becomes a no-op). The timer is
+     * cleared by `resolveCandidate` whenever the candidate settles for any other reason.
+     */
+    private scheduleExpiry;
+    /**
+     * Protected so unit tests can drive the deadline path without waiting on the real
+     * `setTimeout` to fire. Production code calls this only via the per-candidate timer
+     * armed in `scheduleExpiry`.
+     */
+    protected handleExpiry(candidateId: string): void;
+    private readProvenBlockNumber;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/proof-publishing-service.d.ts.map

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

package/dest/proof-publishing-service.js

@@ -0,0 +1,334 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { SerialQueue } from '@aztec/foundation/queue';
+/**
+ * Backoff after a transient `publisherFactory.create()` failure. The candidate stays
+ * in the queue and the drain is re-scheduled after this delay; if the failure persists
+ * the candidate's own `deadline` timer caps the total wait.
+ */ const PUBLISHER_ACQUIRE_RETRY_DELAY_MS = 1_000;
+/**
+ * Central owner of L1 proof submission. Sessions offer their proofs here as
+ * `PublishCandidate`s; the service serialises one publish at a time, picks the
+ * longest candidate per epoch as the winner, and resolves the rest as
+ * `'superseded'` without spending L1 gas.
+ *
+ * Construction-time invariants:
+ * - Every publish runs against a freshly-created `ProverNodePublisher` from the factory.
+ * - Only one publish is ever in flight (`SerialQueue` drain) — no defensive locks.
+ * - Once an L1 publish starts, it runs to completion. `withdraw` is a queue-only
+ *   operation: it removes a candidate that has not yet started publishing. An in-flight
+ *   candidate is left alone and its outcome (`'published'` / `'failed'`) is reported as
+ *   usual — the originating session has already moved to a terminal state via `cancel()`
+ *   and ignores the late outcome.
+ *
+ * Eligibility for publication is decided against the proven block number read inside
+ * the drain (so the value is consistent with the publish that runs on the same drain
+ * pass): a candidate is eligible when its predecessor block is proven and (for partial
+ * candidates) the candidate's range extends past the proven tip. `onChainProven` is a
+ * wake-up signal; it does not pass state into the drain.
+ */ export class ProofPublishingService {
+    deps;
+    log;
+    epochs;
+    /**
+   * One drain task at a time. Submits, withdrawals, chain-proven advances, and prunes
+   * all schedule a `drain` here, so the eligibility re-check and the L1 publish never
+   * interleave.
+   *
+   * Protected so unit tests can `await drainQueue.syncPoint()` to wait for pending
+   * drain work to settle deterministically (no sleeps).
+   */ drainQueue;
+    /** Tracks the candidate currently being published. Set while drain is awaiting the L1 publish. */ inFlight;
+    stopped;
+    constructor(deps){
+        this.deps = deps;
+        this.epochs = new Map();
+        this.drainQueue = new SerialQueue();
+        this.stopped = false;
+        this.log = createLogger('prover-node:proof-publishing-service', deps.bindings);
+        this.drainQueue.start();
+    }
+    /**
+   * Offers a proof candidate to the service. The returned promise resolves once the
+   * service settles the candidate's fate: `'published'` if it wins and L1 accepts it,
+   * `'superseded'` if a longer candidate for the same epoch wins, `'failed'` if the
+   * L1 submission errored, `'withdrawn'` if the originating session cancelled,
+   * `'expired'` if the candidate's `deadline` elapsed before publishing started.
+   */ submit(candidate) {
+        if (this.stopped) {
+            return Promise.resolve('withdrawn');
+        }
+        const { promise, resolve } = promiseWithResolvers();
+        let bucket = this.epochs.get(candidate.epoch);
+        if (!bucket) {
+            bucket = {
+                candidates: new Map(),
+                resolvers: new Map(),
+                expiryTimers: new Map()
+            };
+            this.epochs.set(candidate.epoch, bucket);
+        }
+        bucket.candidates.set(candidate.id, candidate);
+        bucket.resolvers.set(candidate.id, resolve);
+        this.scheduleExpiry(bucket, candidate);
+        this.log.info(`Candidate proof ${candidate.id} submitted for publishing`, {
+            candidateId: candidate.id,
+            epoch: candidate.epoch,
+            startBlock: candidate.startBlock,
+            endBlock: candidate.endBlock,
+            deadline: candidate.deadline?.toISOString()
+        });
+        this.scheduleDrain();
+        return promise;
+    }
+    /**
+   * Pulls a queued candidate from the bucket and resolves its promise as `'withdrawn'`.
+   * If the candidate is already being published, the publish runs to completion and the
+   * outcome reports whatever L1 returned — callers that cancelled mid-publish must rely
+   * on their own terminal-state check to ignore the late outcome. No-op if the candidate
+   * is unknown.
+   */ withdraw(candidateId) {
+        if (this.inFlight?.id === candidateId) {
+            this.log.debug(`Withdraw for in-flight candidate ${candidateId} ignored; publish will run to completion`, {
+                candidateId
+            });
+            return;
+        }
+        for (const bucket of this.epochs.values()){
+            if (bucket.candidates.has(candidateId)) {
+                this.log.info(`Candidate ${candidateId} withdrawn`, {
+                    candidateId
+                });
+                this.resolveCandidate(bucket, candidateId, 'withdrawn');
+                this.scheduleDrain();
+                return;
+            }
+        }
+    }
+    /**
+   * Signals that the L1 proven tip has advanced and the queue should be re-evaluated.
+   * The drain reads the proven block number from `l2BlockSource` itself rather than
+   * relying on the value passed here — that way the eligibility check uses a value read
+   * inside the serial drain, not one captured by a concurrent caller of `onChainProven`.
+   */ onChainProven(_provenBlock) {
+        this.scheduleDrain();
+    }
+    /**
+   * Stops accepting new submissions, waits for any in-flight publish to settle, and
+   * resolves remaining queued candidates as `'withdrawn'`.
+   */ async stop() {
+        this.stopped = true;
+        await this.drainQueue.end();
+        // Anything still parked in a bucket never ran through drain — resolve it as withdrawn so
+        // callers awaiting `submit()` aren't left hanging.
+        for (const bucket of Array.from(this.epochs.values())){
+            for (const id of Array.from(bucket.candidates.keys())){
+                this.resolveCandidate(bucket, id, 'withdrawn');
+            }
+        }
+        this.epochs.clear();
+    }
+    // ---------------- drain ----------------
+    scheduleDrain() {
+        if (this.stopped) {
+            return;
+        }
+        void this.drainQueue.put(()=>this.drain()).catch((err)=>{
+            this.log.error(`Drain task threw`, err);
+        });
+    }
+    async drain() {
+        if (this.stopped) {
+            return;
+        }
+        // Read the proven block number afresh inside the serial drain so the eligibility
+        // check is consistent with the publish that follows it on the same drain pass.
+        const proven = await this.readProvenBlockNumber();
+        // Process epochs in ascending order: the proven tip advances monotonically, so the lower
+        // epoch is the natural next eligible candidate.
+        const orderedEpochs = Array.from(this.epochs.keys()).sort((a, b)=>Number(a) - Number(b));
+        for (const epoch of orderedEpochs){
+            const bucket = this.epochs.get(epoch);
+            const eligible = this.pickEpochWinner(bucket, proven);
+            if (!eligible) {
+                continue;
+            }
+            await this.publishWinner(epoch, eligible.winner, bucket);
+        }
+        // Drop empty buckets
+        for (const [key, bucket] of Array.from(this.epochs.entries())){
+            if (bucket.candidates.size === 0) {
+                this.epochs.delete(key);
+            }
+        }
+    }
+    /**
+   * Picks the winning candidate for a given epoch. Partial candidates whose `endBlock` is
+   * already proven on-chain resolve `'superseded'`.
+   * Full candidates are never auto-superseded by the proven tip — multiple prover-nodes
+   * legitimately submit redundant full epoch proofs (one per prover-id) and L1 records each.
+   * Among the remaining candidates with their predecessor proven, the one with the highest
+   * `endBlock` wins; the others resolve `'superseded'`.
+   */ pickEpochWinner(bucket, proven) {
+        const now = this.deps.dateProvider.now();
+        // Resolve any candidate whose deadline has already passed.
+        for (const candidate of Array.from(bucket.candidates.values())){
+            if (candidate.deadline && candidate.deadline.getTime() <= now) {
+                this.resolveCandidate(bucket, candidate.id, 'expired');
+            }
+        }
+        // Drop partial candidates the proven chain has already caught up to.
+        for (const candidate of Array.from(bucket.candidates.values())){
+            if (candidate.kind === 'partial' && candidate.endBlock <= proven) {
+                this.resolveCandidate(bucket, candidate.id, 'superseded');
+            }
+        }
+        const remaining = Array.from(bucket.candidates.values()).filter((c)=>c.startBlock - 1 <= proven);
+        if (remaining.length === 0) {
+            return undefined;
+        }
+        const winner = remaining.reduce((best, c)=>c.endBlock > best.endBlock ? c : best);
+        // Every other same-epoch candidate is superseded by the winner.
+        for (const candidate of remaining){
+            if (candidate.id !== winner.id) {
+                this.resolveCandidate(bucket, candidate.id, 'superseded');
+            }
+        }
+        return {
+            winner
+        };
+    }
+    async publishWinner(epoch, winner, bucket) {
+        let publisher;
+        try {
+            publisher = await this.deps.publisherFactory.create();
+        } catch (err) {
+            // Treat this as transient: the publisher pool may be temporarily exhausted
+            // (every signer busy, funding tx in flight, etc.). Leave the candidate queued and
+            // schedule another drain after a short backoff. If the failure persists past the
+            // candidate's deadline the expiry timer will resolve it as `'expired'`.
+            this.log.warn(`Failed to acquire publisher for candidate ${winner.id}; retrying`, {
+                candidateId: winner.id,
+                epoch: winner.epoch,
+                retryDelayMs: PUBLISHER_ACQUIRE_RETRY_DELAY_MS,
+                err
+            });
+            setTimeout(()=>this.scheduleDrain(), PUBLISHER_ACQUIRE_RETRY_DELAY_MS);
+            return;
+        }
+        this.inFlight = {
+            id: winner.id
+        };
+        this.log.info(`Publishing candidate ${winner.id}`, {
+            candidateId: winner.id,
+            epoch: winner.epoch,
+            startBlock: winner.startBlock,
+            endBlock: winner.endBlock,
+            fromCheckpoint: winner.fromCheckpoint,
+            toCheckpoint: winner.toCheckpoint
+        });
+        const outcome = await this.runPublish(winner, publisher);
+        this.inFlight = undefined;
+        this.resolveCandidate(bucket, winner.id, outcome);
+        if (bucket.candidates.size === 0) {
+            this.epochs.delete(epoch);
+        }
+    }
+    async runPublish(candidate, publisher) {
+        const submitArgs = {
+            epochNumber: candidate.epoch,
+            fromCheckpoint: candidate.fromCheckpoint,
+            toCheckpoint: candidate.toCheckpoint,
+            publicInputs: candidate.publicInputs,
+            proof: candidate.proof,
+            batchedBlobInputs: candidate.batchedBlobInputs,
+            attestations: candidate.attestations,
+            // Stop the L1 tx retrying past the candidate's submission-window deadline.
+            deadline: candidate.deadline
+        };
+        if (this.deps.config.skipSubmitProof) {
+            try {
+                await publisher.analyzeEpochProofSubmission(submitArgs);
+                return 'published';
+            } catch (err) {
+                this.log.warn(`Failed to analyze estimated L1 fees for candidate ${candidate.id}`, {
+                    err,
+                    candidateId: candidate.id,
+                    epoch: candidate.epoch
+                });
+                // Analyze-mode failures are recorded but the session shouldn't enter `failed` —
+                // the operator opted out of submission. Match the previous EpochSession behaviour.
+                return 'published';
+            }
+        }
+        try {
+            const success = await publisher.submitEpochProof(submitArgs);
+            return success ? 'published' : 'failed';
+        } catch (err) {
+            this.log.error(`Error publishing candidate ${candidate.id}`, err, {
+                candidateId: candidate.id,
+                epoch: candidate.epoch
+            });
+            return 'failed';
+        }
+    }
+    resolveCandidate(bucket, id, outcome) {
+        const resolve = bucket.resolvers.get(id);
+        const timer = bucket.expiryTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            bucket.expiryTimers.delete(id);
+        }
+        bucket.candidates.delete(id);
+        bucket.resolvers.delete(id);
+        if (resolve) {
+            this.log.info(`Candidate ${id} resolved as ${outcome}`, {
+                candidateId: id,
+                outcome
+            });
+            resolve(outcome);
+        }
+    }
+    /**
+   * Arms a per-candidate expiry timer if the candidate carries a deadline. When the timer
+   * fires, the candidate resolves as `'expired'` — unless it is already in flight, in
+   * which case the publish runs to completion (the timer becomes a no-op). The timer is
+   * cleared by `resolveCandidate` whenever the candidate settles for any other reason.
+   */ scheduleExpiry(bucket, candidate) {
+        if (!candidate.deadline) {
+            return;
+        }
+        const delay = Math.max(candidate.deadline.getTime() - this.deps.dateProvider.now(), 0);
+        const timer = setTimeout(()=>this.handleExpiry(candidate.id), delay);
+        bucket.expiryTimers.set(candidate.id, timer);
+    }
+    /**
+   * Protected so unit tests can drive the deadline path without waiting on the real
+   * `setTimeout` to fire. Production code calls this only via the per-candidate timer
+   * armed in `scheduleExpiry`.
+   */ handleExpiry(candidateId) {
+        if (this.inFlight?.id === candidateId) {
+            this.log.debug(`Expiry for in-flight candidate ${candidateId} ignored; publish will run to completion`, {
+                candidateId
+            });
+            return;
+        }
+        for (const bucket of this.epochs.values()){
+            if (bucket.candidates.has(candidateId)) {
+                this.log.info(`Candidate ${candidateId} expired before publishing`, {
+                    candidateId
+                });
+                this.resolveCandidate(bucket, candidateId, 'expired');
+                this.scheduleDrain();
+                return;
+            }
+        }
+    }
+    async readProvenBlockNumber() {
+        const proven = await this.deps.l2BlockSource.getBlockNumber({
+            tag: 'proven'
+        });
+        return BlockNumber(proven ?? 0);
+    }
+}

package/dest/prover-node-publisher.d.ts

@@ -23,7 +23,6 @@ export type L1SubmitEpochProofArgs = {
     proof: Proof;
 };
 export declare class ProverNodePublisher {
-    private interrupted;
     private metrics;
     protected log: Logger;
     protected rollupContract: RollupContract;
@@ -34,15 +33,6 @@ export declare class ProverNodePublisher {
         telemetry?: TelemetryClient;
     }, bindings?: LoggerBindings);
     getRollupContract(): RollupContract;
-    /**
-     * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
-     * Be warned, the call may return false even if the tx subsequently gets successfully mined.
-     * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
-     * A call to `restart` is required before you can continue publishing.
-     */
-    interrupt(): void;
-    /** Restarts the publisher after calling `interrupt`. */
-    restart(): void;
     getSenderAddress(): EthAddress;
     submitEpochProof(args: {
         epochNumber: EpochNumber;
@@ -52,10 +42,27 @@ export declare class ProverNodePublisher {
         proof: Proof;
         batchedBlobInputs: BatchedBlob;
         attestations: ViemCommitteeAttestation[];
+        /** Wall-clock deadline (proof-submission window end) past which the L1 tx should stop retrying. */
+        deadline?: Date;
     }): Promise<boolean>;
     private validateEpochProofSubmission;
+    /**
+     * Estimates what submitting the epoch proof would have cost on L1 without actually sending it.
+     * Runs the same validation as `submitEpochProof`, encodes the calldata, estimates gas, and records metrics.
+     * Used when proof publishing is disabled (e.g. PROVER_NODE_DISABLE_PROOF_PUBLISH=true on mainnet).
+     */
+    analyzeEpochProofSubmission(args: {
+        epochNumber: EpochNumber;
+        fromCheckpoint: CheckpointNumber;
+        toCheckpoint: CheckpointNumber;
+        publicInputs: RootRollupPublicInputs;
+        proof: Proof;
+        batchedBlobInputs: BatchedBlob;
+        attestations: ViemCommitteeAttestation[];
+    }): Promise<void>;
+    private encodeSubmitEpochProofCalldata;
     private sendSubmitEpochProofTx;
     private getEpochProofPublicInputsArgs;
     private getSubmitEpochProofArgs;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-node-publisher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA8B,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAOnF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,EAAE,CAAC;IACpB,UAAU,EAAE,EAAE,CAAC;IACf,YAAY,EAAE,EAAE,CAAC;IACjB,OAAO,EAAE,EAAE,CAAC;IACZ,QAAQ,EAAE,EAAE,CAAC;IACb,IAAI,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,yBAAyB,CAAC,CAAC;IAC5D,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAA6B;IAE5C,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IAEzC,SAAgB,SAAS,EAAE,SAAS,CAAC;IAErC,YACE,MAAM,EAAE,cAAc,GAAG,eAAe,EACxC,IAAI,EAAE;QACJ,cAAc,EAAE,cAAc,CAAC;QAC/B,SAAS,EAAE,SAAS,CAAC;QACrB,SAAS,CAAC,EAAE,eAAe,CAAC;KAC7B,EACD,QAAQ,CAAC,EAAE,cAAc,EAS1B;IAEM,iBAAiB,mBAEvB;IAED;;;;;OAKG;IACI,SAAS,SAGf;IAED,wDAAwD;IACjD,OAAO,SAGb;IAEM,gBAAgB,eAEtB;IAEY,gBAAgB,CAAC,IAAI,EAAE;QAClC,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;KAC1C,GAAG,OAAO,CAAC,OAAO,CAAC,CAiDnB;YAEa,4BAA4B;YA+D5B,sBAAsB;IA4CpC,OAAO,CAAC,6BAA6B;IA0BrC,OAAO,CAAC,uBAAuB;CAuBhC"}
+{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA8B,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAOnF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,EAAE,CAAC;IACpB,UAAU,EAAE,EAAE,CAAC;IACf,YAAY,EAAE,EAAE,CAAC;IACjB,OAAO,EAAE,EAAE,CAAC;IACZ,QAAQ,EAAE,EAAE,CAAC;IACb,IAAI,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,yBAAyB,CAAC,CAAC;IAC5D,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAA6B;IAE5C,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IAEzC,SAAgB,SAAS,EAAE,SAAS,CAAC;IAErC,YACE,MAAM,EAAE,cAAc,GAAG,eAAe,EACxC,IAAI,EAAE;QACJ,cAAc,EAAE,cAAc,CAAC;QAC/B,SAAS,EAAE,SAAS,CAAC;QACrB,SAAS,CAAC,EAAE,eAAe,CAAC;KAC7B,EACD,QAAQ,CAAC,EAAE,cAAc,EAS1B;IAEM,iBAAiB,mBAEvB;IAEM,gBAAgB,eAEtB;IAEY,gBAAgB,CAAC,IAAI,EAAE;QAClC,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;QACzC,mGAAmG;QACnG,QAAQ,CAAC,EAAE,IAAI,CAAC;KACjB,GAAG,OAAO,CAAC,OAAO,CAAC,CA6CnB;YAEa,4BAA4B;IAmE1C;;;;OAIG;IACU,2BAA2B,CAAC,IAAI,EAAE;QAC7C,WAAW,EAAE,WAAW,CAAC;QACzB,cAAc,EAAE,gBAAgB,CAAC;QACjC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;QACb,iBAAiB,EAAE,WAAW,CAAC;QAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;KAC1C,GAAG,OAAO,CAAC,IAAI,CAAC,CAsChB;IAED,OAAO,CAAC,8BAA8B;YAexB,sBAAsB;IAgDpC,OAAO,CAAC,6BAA6B;IA0BrC,OAAO,CAAC,uBAAuB;CAuBhC"}