@aztec/prover-node 0.0.0-test.0

package/dest/metrics.js

@@ -0,0 +1,129 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { formatEther } from 'viem';
+export class ProverNodeMetrics {
+    client;
+    logger;
+    proverEpochExecutionDuration;
+    provingJobDuration;
+    provingJobBlocks;
+    provingJobTransactions;
+    gasPrice;
+    txCount;
+    txDuration;
+    txGas;
+    txCalldataSize;
+    txCalldataGas;
+    txBlobDataGasUsed;
+    txBlobDataGasCost;
+    senderBalance;
+    constructor(client, name = 'ProverNode', logger = createLogger('prover-node:publisher:metrics')){
+        this.client = client;
+        this.logger = logger;
+        const meter = client.getMeter(name);
+        this.proverEpochExecutionDuration = meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION, {
+            description: 'Duration of execution of an epoch by the prover',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.provingJobDuration = meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION, {
+            description: 'Duration of proving job',
+            unit: 's',
+            valueType: ValueType.DOUBLE
+        });
+        this.provingJobBlocks = meter.createGauge(Metrics.PROVER_NODE_JOB_BLOCKS, {
+            description: 'Number of blocks in a proven epoch',
+            valueType: ValueType.INT
+        });
+        this.provingJobTransactions = meter.createGauge(Metrics.PROVER_NODE_JOB_TRANSACTIONS, {
+            description: 'Number of transactions in a proven epoch',
+            valueType: ValueType.INT
+        });
+        this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
+            description: 'The gas price used for transactions',
+            unit: 'gwei',
+            valueType: ValueType.DOUBLE
+        });
+        this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
+            description: 'The number of transactions processed'
+        });
+        this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+            description: 'The duration of transaction processing',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
+            description: 'The gas consumed by transactions',
+            unit: 'gas',
+            valueType: ValueType.INT
+        });
+        this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
+            description: 'The size of the calldata in transactions',
+            unit: 'By',
+            valueType: ValueType.INT
+        });
+        this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
+            description: 'The gas consumed by the calldata in transactions',
+            unit: 'gas',
+            valueType: ValueType.INT
+        });
+        this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED, {
+            description: 'The amount of blob gas used in transactions',
+            unit: 'gas',
+            valueType: ValueType.INT
+        });
+        this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST, {
+            description: 'The gas cost of blobs in transactions',
+            unit: 'gwei',
+            valueType: ValueType.INT
+        });
+        this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
+            unit: 'eth',
+            description: 'The balance of the sender address',
+            valueType: ValueType.DOUBLE
+        });
+    }
+    recordFailedTx() {
+        this.txCount.add(1, {
+            [Attributes.L1_TX_TYPE]: 'submitProof',
+            [Attributes.OK]: false
+        });
+    }
+    recordSubmitProof(durationMs, stats) {
+        this.recordTx(durationMs, stats);
+    }
+    recordProvingJob(executionTimeMs, totalTimeMs, numBlocks, numTxs) {
+        this.proverEpochExecutionDuration.record(Math.ceil(executionTimeMs));
+        this.provingJobDuration.record(totalTimeMs / 1000);
+        this.provingJobBlocks.record(Math.floor(numBlocks));
+        this.provingJobTransactions.record(Math.floor(numTxs));
+    }
+    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 (e) {
+        // ignore
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type TelemetryClient, type Traceable, type Tracer } from '@aztec/telemetry-client';
+export interface EpochMonitorHandler {
+    handleEpochReadyToProve(epochNumber: bigint): Promise<void>;
+}
+/**
+ * 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;
+    }, telemetry?: TelemetryClient);
+    static create(l2BlockSource: L2BlockSource, options: {
+        pollingIntervalMs: 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=epoch-monitor.d.ts.map

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":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,6BAA6B,CAAC;AACrF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IAClC,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;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,CAAqB;gBAG3B,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EAC9D,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE,EAC9C,SAAS,GAAE,eAAsC;WAM/B,MAAM,CACxB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE,EACtC,SAAS,GAAE,eAAsC,GAChD,OAAO,CAAC,YAAY,CAAC;IAKjB,KAAK,CAAC,OAAO,EAAE,mBAAmB;IAMzC,0BAA0B;IACnB,UAAU,CAAC,OAAO,EAAE,mBAAmB;IAIjC,IAAI;IAMJ,IAAI;YAsBH,qBAAqB;CAYpC"}

package/dest/monitors/epoch-monitor.js

@@ -0,0 +1,104 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+/**
+ * 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 class EpochMonitor {
+    l2BlockSource;
+    l1Constants;
+    options;
+    runningPromise;
+    log;
+    tracer;
+    handler;
+    latestEpochNumber;
+    constructor(l2BlockSource, l1Constants, options, telemetry = getTelemetryClient()){
+        this.l2BlockSource = l2BlockSource;
+        this.l1Constants = l1Constants;
+        this.options = options;
+        this.log = createLogger('prover-node:epoch-monitor');
+        this.tracer = telemetry.getTracer('EpochMonitor');
+        this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.options.pollingIntervalMs);
+    }
+    static async create(l2BlockSource, options, telemetry = getTelemetryClient()) {
+        const l1Constants = await l2BlockSource.getL1Constants();
+        return new EpochMonitor(l2BlockSource, l1Constants, options, telemetry);
+    }
+    start(handler) {
+        this.handler = handler;
+        this.runningPromise.start();
+        this.log.info('Started EpochMonitor', this.options);
+    }
+    /** Exposed for testing */ setHandler(handler) {
+        this.handler = handler;
+    }
+    async stop() {
+        await this.runningPromise.stop();
+        this.log.info('Stopped EpochMonitor');
+    }
+    async work() {
+        const { epochToProve, blockNumber, slotNumber } = await this.getEpochNumberToProve();
+        if (epochToProve === undefined) {
+            this.log.trace(`Next block to prove ${blockNumber} not yet mined`, {
+                blockNumber
+            });
+            return;
+        }
+        if (this.latestEpochNumber !== undefined && epochToProve <= this.latestEpochNumber) {
+            this.log.trace(`Epoch ${epochToProve} already processed`, {
+                epochToProve,
+                blockNumber,
+                slotNumber
+            });
+            return;
+        }
+        const isCompleted = await this.l2BlockSource.isEpochComplete(epochToProve);
+        if (!isCompleted) {
+            this.log.trace(`Epoch ${epochToProve} is not complete`, {
+                epochToProve,
+                blockNumber,
+                slotNumber
+            });
+            return;
+        }
+        this.log.debug(`Epoch ${epochToProve} is ready to be proven`);
+        await this.handler?.handleEpochReadyToProve(epochToProve);
+        this.latestEpochNumber = epochToProve;
+    }
+    async getEpochNumberToProve() {
+        const lastBlockProven = await this.l2BlockSource.getProvenBlockNumber();
+        const firstBlockToProve = lastBlockProven + 1;
+        const firstBlockHeaderToProve = await this.l2BlockSource.getBlockHeader(firstBlockToProve);
+        if (!firstBlockHeaderToProve) {
+            return {
+                epochToProve: undefined,
+                blockNumber: firstBlockToProve
+            };
+        }
+        const firstSlotOfEpochToProve = firstBlockHeaderToProve.getSlot();
+        const epochToProve = getEpochAtSlot(firstSlotOfEpochToProve, this.l1Constants);
+        return {
+            epochToProve,
+            blockNumber: firstBlockToProve,
+            slotNumber: firstSlotOfEpochToProve
+        };
+    }
+}
+_ts_decorate([
+    trackSpan('EpochMonitor.work')
+], EpochMonitor.prototype, "work", null);

package/dest/monitors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './epoch-monitor.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monitors/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dest/monitors/index.js

@@ -0,0 +1 @@
+export * from './epoch-monitor.js';

package/dest/prover-coordination/config.d.ts

@@ -0,0 +1,7 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+export type ProverCoordinationConfig = {
+    proverCoordinationNodeUrl: string | undefined;
+};
+export declare const proverCoordinationConfigMappings: ConfigMappingsType<ProverCoordinationConfig>;
+export declare function getTxProviderConfigFromEnv(): ProverCoordinationConfig;
+//# sourceMappingURL=config.d.ts.map

package/dest/prover-coordination/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/prover-coordination/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,0BAA0B,CAAC;AAE1F,MAAM,MAAM,wBAAwB,GAAG;IACrC,yBAAyB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,kBAAkB,CAAC,wBAAwB,CAMzF,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,wBAAwB,CAErE"}

package/dest/prover-coordination/config.js

@@ -0,0 +1,11 @@
+import { getConfigFromMappings } from '@aztec/foundation/config';
+export const proverCoordinationConfigMappings = {
+    proverCoordinationNodeUrl: {
+        env: 'PROVER_COORDINATION_NODE_URL',
+        description: 'The URL of the tx provider node',
+        parseEnv: (val)=>val
+    }
+};
+export function getTxProviderConfigFromEnv() {
+    return getConfigFromMappings(proverCoordinationConfigMappings);
+}

package/dest/prover-coordination/factory.d.ts

@@ -0,0 +1,22 @@
+import type { ArchiveSource, Archiver } from '@aztec/archiver';
+import type { EpochCache } from '@aztec/epoch-cache';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { ProverCoordination, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { ProverNodeConfig } from '../config.js';
+type ProverCoordinationDeps = {
+    aztecNodeTxProvider?: ProverCoordination;
+    worldStateSynchronizer?: WorldStateSynchronizer;
+    archiver?: Archiver | ArchiveSource;
+    telemetry?: TelemetryClient;
+    epochCache?: EpochCache;
+};
+/**
+ * Creates a prover coordination service.
+ * If p2p is enabled, prover coordination is done via p2p.
+ * If an Aztec node URL is provided, prover coordination is done via the Aztec node over http.
+ * If an aztec node is provided, it is returned directly.
+ */
+export declare function createProverCoordination(config: ProverNodeConfig & DataStoreConfig, deps: ProverCoordinationDeps): Promise<ProverCoordination>;
+export {};
+//# sourceMappingURL=factory.d.ts.map

package/dest/prover-coordination/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/prover-coordination/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAGlG,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,yBAAyB,CAAC;AAEhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,KAAK,sBAAsB,GAAG;IAC5B,mBAAmB,CAAC,EAAE,kBAAkB,CAAC;IACzC,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,QAAQ,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;IACpC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAqC7B"}

package/dest/prover-coordination/factory.js

@@ -0,0 +1,42 @@
+import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
+import { createLogger } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { createP2PClient } from '@aztec/p2p';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+/**
+ * Creates a prover coordination service.
+ * If p2p is enabled, prover coordination is done via p2p.
+ * If an Aztec node URL is provided, prover coordination is done via the Aztec node over http.
+ * If an aztec node is provided, it is returned directly.
+ */ export async function createProverCoordination(config, deps) {
+    const log = createLogger('prover-node:prover-coordination');
+    if (deps.aztecNodeTxProvider) {
+        log.info('Using prover coordination via aztec node');
+        return deps.aztecNodeTxProvider;
+    }
+    if (config.p2pEnabled) {
+        log.info('Using prover coordination via p2p');
+        if (!deps.archiver || !deps.worldStateSynchronizer || !deps.telemetry || !deps.epochCache) {
+            throw new Error('Missing dependencies for p2p prover coordination');
+        }
+        const proofVerifier = config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier();
+        const p2pClient = await createP2PClient(P2PClientType.Prover, config, deps.archiver, proofVerifier, deps.worldStateSynchronizer, deps.epochCache, deps.telemetry);
+        await p2pClient.start();
+        return p2pClient;
+    }
+    if (config.proverCoordinationNodeUrl) {
+        log.info('Using prover coordination via node url');
+        const versions = getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+        return createAztecNodeClient(config.proverCoordinationNodeUrl, versions, makeTracedFetch([
+            1,
+            2,
+            3
+        ], false));
+    } else {
+        throw new Error(`Aztec Node URL for Tx Provider is not set.`);
+    }
+}

package/dest/prover-coordination/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/prover-coordination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prover-coordination/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dest/prover-coordination/index.js

@@ -0,0 +1,2 @@
+export * from './config.js';
+export * from './factory.js';

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

@@ -0,0 +1,61 @@
+import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import type { L1TxUtils, RollupContract } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { type Tuple } from '@aztec/foundation/serialize';
+import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { FeeRecipient, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+/**
+ * Stats for a sent transaction.
+ */
+/** Arguments to the submitEpochProof method of the rollup contract */
+export type L1SubmitEpochProofArgs = {
+    epochSize: number;
+    previousArchive: Fr;
+    endArchive: Fr;
+    previousBlockHash: Fr;
+    endBlockHash: Fr;
+    endTimestamp: Fr;
+    outHash: Fr;
+    proverId: Fr;
+    fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>;
+    proof: Proof;
+};
+export declare class ProverNodePublisher {
+    private interruptibleSleep;
+    private sleepTimeMs;
+    private interrupted;
+    private metrics;
+    protected log: import("@aztec/foundation/log").Logger;
+    protected rollupContract: RollupContract;
+    readonly l1TxUtils: L1TxUtils;
+    constructor(config: TxSenderConfig & PublisherConfig, deps: {
+        rollupContract: RollupContract;
+        l1TxUtils: L1TxUtils;
+        telemetry?: TelemetryClient;
+    });
+    /**
+     * 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: number;
+        fromBlock: number;
+        toBlock: number;
+        publicInputs: RootRollupPublicInputs;
+        proof: Proof;
+    }): Promise<boolean>;
+    private validateEpochProofSubmission;
+    private sendSubmitEpochProofTx;
+    private getSubmitEpochProofArgs;
+    protected sleepOrInterrupted(): Promise<void>;
+}
+//# sourceMappingURL=prover-node-publisher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prover-node-publisher.d.ts","sourceRoot":"","sources":["../src/prover-node-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,KAAK,EAAqB,MAAM,6BAA6B,CAAC;AAI5E,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC/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;AAMnF;;GAEG;AACH,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,EAAE,CAAC;IACpB,UAAU,EAAE,EAAE,CAAC;IACf,iBAAiB,EAAE,EAAE,CAAC;IACtB,YAAY,EAAE,EAAE,CAAC;IACjB,YAAY,EAAE,EAAE,CAAC;IACjB,OAAO,EAAE,EAAE,CAAC;IACZ,QAAQ,EAAE,EAAE,CAAC;IACb,IAAI,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,wBAAwB,CAAC,CAAC;IAC3D,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAoB;IAEnC,SAAS,CAAC,GAAG,yCAA+C;IAE5D,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IAEzC,SAAgB,SAAS,EAAE,SAAS,CAAC;gBAGnC,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;IAYH;;;;;OAKG;IACI,SAAS;IAKhB,wDAAwD;IACjD,OAAO;IAIP,gBAAgB;IAIV,gBAAgB,CAAC,IAAI,EAAE;QAClC,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,sBAAsB,CAAC;QACrC,KAAK,EAAE,KAAK,CAAC;KACd,GAAG,OAAO,CAAC,OAAO,CAAC;YAgDN,4BAA4B;YAyD5B,sBAAsB;IAoDpC,OAAO,CAAC,uBAAuB;cA+Bf,kBAAkB;CAGnC"}

package/dest/prover-node-publisher.js

@@ -0,0 +1,192 @@
+import { AGGREGATION_OBJECT_LENGTH, AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { areArraysEqual, times } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { encodeFunctionData } from 'viem';
+import { ProverNodeMetrics } from './metrics.js';
+export class ProverNodePublisher {
+    interruptibleSleep = new InterruptibleSleep();
+    sleepTimeMs;
+    interrupted = false;
+    metrics;
+    log = createLogger('prover-node:l1-tx-publisher');
+    rollupContract;
+    l1TxUtils;
+    constructor(config, deps){
+        this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
+        const telemetry = deps.telemetry ?? getTelemetryClient();
+        this.metrics = new ProverNodeMetrics(telemetry, 'ProverNode');
+        this.rollupContract = deps.rollupContract;
+        this.l1TxUtils = deps.l1TxUtils;
+    }
+    /**
+   * 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() {
+        this.interrupted = true;
+        this.interruptibleSleep.interrupt();
+    }
+    /** Restarts the publisher after calling `interrupt`. */ restart() {
+        this.interrupted = false;
+    }
+    getSenderAddress() {
+        return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+    }
+    async submitEpochProof(args) {
+        const { epochNumber, fromBlock, toBlock } = args;
+        const ctx = {
+            epochNumber,
+            fromBlock,
+            toBlock
+        };
+        if (!this.interrupted) {
+            const timer = new Timer();
+            // Validate epoch proof range and hashes are correct before submitting
+            await this.validateEpochProofSubmission(args);
+            const txReceipt = await this.sendSubmitEpochProofTx(args);
+            if (!txReceipt) {
+                return false;
+            }
+            try {
+                this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress());
+            } catch (err) {
+                this.log.warn(`Failed to record the ETH balance of the prover node: ${err}`);
+            }
+            // Tx was mined successfully
+            if (txReceipt.status) {
+                const tx = await this.l1TxUtils.getTransactionStats(txReceipt.transactionHash);
+                const stats = {
+                    gasPrice: txReceipt.effectiveGasPrice,
+                    gasUsed: txReceipt.gasUsed,
+                    transactionHash: txReceipt.transactionHash,
+                    calldataGas: tx.calldataGas,
+                    calldataSize: tx.calldataSize,
+                    sender: tx.sender,
+                    blobDataGas: 0n,
+                    blobGasUsed: 0n,
+                    eventName: 'proof-published-to-l1'
+                };
+                this.log.info(`Published epoch proof to L1 rollup contract`, {
+                    ...stats,
+                    ...ctx
+                });
+                this.metrics.recordSubmitProof(timer.ms(), stats);
+                return true;
+            }
+            this.metrics.recordFailedTx();
+            this.log.error(`Rollup.submitEpochProof tx status failed: ${txReceipt.transactionHash}`, ctx);
+            await this.sleepOrInterrupted();
+        }
+        this.log.verbose('L2 block data syncing interrupted while processing blocks.', ctx);
+        return false;
+    }
+    async validateEpochProofSubmission(args) {
+        const { fromBlock, toBlock, publicInputs, proof } = args;
+        // Check that the block numbers match the expected epoch to be proven
+        const { pendingBlockNumber: pending, provenBlockNumber: proven } = await this.rollupContract.getTips();
+        if (proven !== BigInt(fromBlock) - 1n) {
+            throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as proven block is ${proven}`);
+        }
+        if (toBlock > pending) {
+            throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as pending block is ${pending}`);
+        }
+        // Check the block hash and archive for the immediate block before the epoch
+        const blockLog = await this.rollupContract.getBlock(proven);
+        if (publicInputs.previousArchive.root.toString() !== blockLog.archive) {
+            throw new Error(`Previous archive root mismatch: ${publicInputs.previousArchive.root.toString()} !== ${blockLog.archive}`);
+        }
+        // TODO: Remove zero check once we inject the proper zero blockhash
+        if (blockLog.blockHash !== Fr.ZERO.toString() && publicInputs.previousBlockHash.toString() !== blockLog.blockHash) {
+            throw new Error(`Previous block hash mismatch: ${publicInputs.previousBlockHash.toString()} !== ${blockLog.blockHash}`);
+        }
+        // Check the block hash and archive for the last block in the epoch
+        const endBlockLog = await this.rollupContract.getBlock(BigInt(toBlock));
+        if (publicInputs.endArchive.root.toString() !== endBlockLog.archive) {
+            throw new Error(`End archive root mismatch: ${publicInputs.endArchive.root.toString()} !== ${endBlockLog.archive}`);
+        }
+        if (publicInputs.endBlockHash.toString() !== endBlockLog.blockHash) {
+            throw new Error(`End block hash mismatch: ${publicInputs.endBlockHash.toString()} !== ${endBlockLog.blockHash}`);
+        }
+        // Compare the public inputs computed by the contract with the ones injected
+        const rollupPublicInputs = await this.rollupContract.getEpochProofPublicInputs(this.getSubmitEpochProofArgs(args));
+        const aggregationObject = proof.isEmpty() ? times(AGGREGATION_OBJECT_LENGTH, Fr.zero) : proof.extractAggregationObject();
+        const argsPublicInputs = [
+            ...publicInputs.toFields(),
+            ...aggregationObject
+        ];
+        if (!areArraysEqual(rollupPublicInputs.map(Fr.fromHexString), argsPublicInputs, (a, b)=>a.equals(b))) {
+            const fmt = (inputs)=>inputs.map((x)=>x.toString()).join(', ');
+            throw new Error(`Root rollup public inputs mismatch:\nRollup:  ${fmt(rollupPublicInputs)}\nComputed:${fmt(argsPublicInputs)}`);
+        }
+    }
+    async sendSubmitEpochProofTx(args) {
+        const proofHex = `0x${args.proof.withoutPublicInputs().toString('hex')}`;
+        const argsArray = this.getSubmitEpochProofArgs(args);
+        const txArgs = [
+            {
+                start: argsArray[0],
+                end: argsArray[1],
+                args: argsArray[2],
+                fees: argsArray[3],
+                blobPublicInputs: argsArray[4],
+                aggregationObject: argsArray[5],
+                proof: proofHex
+            }
+        ];
+        this.log.info(`SubmitEpochProof proofSize=${args.proof.withoutPublicInputs().length} bytes`);
+        const data = encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'submitEpochRootProof',
+            args: txArgs
+        });
+        try {
+            const { receipt } = await this.l1TxUtils.sendAndMonitorTransaction({
+                to: this.rollupContract.address,
+                data
+            });
+            return receipt;
+        } catch (err) {
+            this.log.error(`Rollup submit epoch proof failed`, err);
+            const errorMsg = await this.l1TxUtils.tryGetErrorFromRevertedTx(data, {
+                args: [
+                    ...txArgs
+                ],
+                functionName: 'submitEpochRootProof',
+                abi: RollupAbi,
+                address: this.rollupContract.address
+            }, /*blobInputs*/ undefined, /*stateOverride*/ []);
+            this.log.error(`Rollup submit epoch proof tx reverted. ${errorMsg}`);
+            return undefined;
+        }
+    }
+    getSubmitEpochProofArgs(args) {
+        return [
+            BigInt(args.fromBlock),
+            BigInt(args.toBlock),
+            {
+                previousArchive: args.publicInputs.previousArchive.root.toString(),
+                endArchive: args.publicInputs.endArchive.root.toString(),
+                previousBlockHash: args.publicInputs.previousBlockHash.toString(),
+                endBlockHash: args.publicInputs.endBlockHash.toString(),
+                endTimestamp: args.publicInputs.endTimestamp.toBigInt(),
+                outHash: args.publicInputs.outHash.toString(),
+                proverId: EthAddress.fromField(args.publicInputs.proverId).toString()
+            },
+            makeTuple(AZTEC_MAX_EPOCH_DURATION * 2, (i)=>i % 2 === 0 ? args.publicInputs.fees[i / 2].recipient.toField().toString() : args.publicInputs.fees[(i - 1) / 2].value.toString()),
+            `0x${args.publicInputs.blobPublicInputs.filter((_, i)=>i < args.toBlock - args.fromBlock + 1).map((b)=>b.toString()).join(``)}`,
+            `0x${serializeToBuffer(args.proof.extractAggregationObject()).toString('hex')}`
+        ];
+    }
+    async sleepOrInterrupted() {
+        await this.interruptibleSleep.sleep(this.sleepTimeMs);
+    }
+}