@aztec/prover-node 0.72.1 → 0.74.0

package/src/factory.ts

@@ -2,14 +2,14 @@ import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
 import { type ProverCoordination, type ProvingJobBroker } from '@aztec/circuit-types';
 import { EpochCache } from '@aztec/epoch-cache';
-import { createEthereumChain } from '@aztec/ethereum';
+import { L1TxUtils, RollupContract, createEthereumChain, createL1Clients } from '@aztec/ethereum';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import { createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import { L1Publisher } from '@aztec/sequencer-client';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
@@ -20,6 +20,7 @@ import { type ProverNodeConfig, type QuoteProviderConfig } from './config.js';
 import { ClaimsMonitor } from './monitors/claims-monitor.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
 import { createProverCoordination } from './prover-coordination/factory.js';
+import { ProverNodePublisher } from './prover-node-publisher.js';
 import { ProverNode, type ProverNodeOptions } from './prover-node.js';
 import { HttpQuoteProvider } from './quote-provider/http.js';
 import { SimpleQuoteProvider } from './quote-provider/simple.js';
@@ -33,13 +34,14 @@ export async function createProverNode(
     log?: Logger;
     aztecNodeTxProvider?: ProverCoordination;
     archiver?: Archiver;
-    publisher?: L1Publisher;
+    publisher?: ProverNodePublisher;
     blobSinkClient?: BlobSinkClientInterface;
     broker?: ProvingJobBroker;
+    l1TxUtils?: L1TxUtils;
   } = {},
 ) {
   const telemetry = deps.telemetry ?? getTelemetryClient();
-  const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config.blobSinkUrl);
+  const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
   const log = deps.log ?? createLogger('prover-node');
   const archiver = deps.archiver ?? (await createArchiver(config, blobSinkClient, { blockUntilSync: true }, telemetry));
   log.verbose(`Created archiver and synced to block ${await archiver.getBlockNumber()}`);
@@ -51,8 +53,14 @@ export async function createProverNode(
   const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
   const prover = await createProverClient(config, worldStateSynchronizer, broker, telemetry);
 
-  // REFACTOR: Move publisher out of sequencer package and into an L1-related package
-  const publisher = deps.publisher ?? new L1Publisher(config, { telemetry, blobSinkClient });
+  const { l1RpcUrl: rpcUrl, l1ChainId: chainId, publisherPrivateKey } = config;
+  const chain = createEthereumChain(rpcUrl, chainId);
+  const { publicClient, walletClient } = createL1Clients(rpcUrl, publisherPrivateKey, chain.chainInfo);
+
+  const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+
+  const l1TxUtils = deps.l1TxUtils ?? new L1TxUtils(publicClient, walletClient, log, config);
+  const publisher = deps.publisher ?? new ProverNodePublisher(config, { telemetry, rollupContract, l1TxUtils });
 
   const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
 
@@ -81,9 +89,8 @@ export async function createProverNode(
   const claimsMonitor = new ClaimsMonitor(publisher, proverNodeConfig, telemetry);
   const epochMonitor = new EpochMonitor(archiver, proverNodeConfig, telemetry);
 
-  const rollupContract = publisher.getRollupContract();
-  const walletClient = publisher.getClient();
-  const bondManager = await createBondManager(rollupContract, walletClient, config);
+  const escrowContractAddress = await rollupContract.getProofCommitmentEscrow();
+  const bondManager = await createBondManager(EthAddress.fromString(escrowContractAddress), walletClient, config);
 
   return new ProverNode(
     prover,

package/src/index.ts

@@ -1,4 +1,5 @@
-export * from './factory.js';
 export * from './config.js';
-export * from './prover-node.js';
+export * from './factory.js';
 export * from './http.js';
+export * from './prover-node-publisher.js';
+export * from './prover-node.js';

package/src/job/epoch-proving-job.ts

@@ -13,13 +13,13 @@ import { asyncPool } from '@aztec/foundation/async-pool';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { Timer } from '@aztec/foundation/timer';
-import { type L1Publisher } from '@aztec/sequencer-client';
 import { type PublicProcessor, type PublicProcessorFactory } from '@aztec/simulator/server';
 import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import * as crypto from 'node:crypto';
 
 import { type ProverNodeMetrics } from '../metrics.js';
+import { type ProverNodePublisher } from '../prover-node-publisher.js';
 
 /**
  * Job that grabs a range of blocks from the unfinalised chain from L1, gets their txs given their hashes,
@@ -43,7 +43,7 @@ export class EpochProvingJob implements Traceable {
     private txs: Tx[],
     private prover: EpochProver,
     private publicProcessorFactory: PublicProcessorFactory,
-    private publisher: L1Publisher,
+    private publisher: ProverNodePublisher,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private metrics: ProverNodeMetrics,
@@ -91,19 +91,19 @@ export class EpochProvingJob implements Traceable {
 
     try {
       this.prover.startNewEpoch(epochNumber, fromBlock, epochSizeBlocks);
-      this.prover.startTubeCircuits(this.txs);
+      await this.prover.startTubeCircuits(this.txs);
 
       await asyncPool(this.config.parallelBlockLimit, this.blocks, async block => {
         this.checkState();
 
         const globalVariables = block.header.globalVariables;
-        const txs = this.getTxs(block);
+        const txs = await this.getTxs(block);
         const l1ToL2Messages = await this.getL1ToL2Messages(block);
         const previousHeader = (await this.getBlockHeader(block.number - 1))!;
 
         this.log.verbose(`Starting processing block ${block.number}`, {
           number: block.number,
-          blockHash: block.hash().toString(),
+          blockHash: (await block.hash()).toString(),
           lastArchive: block.header.lastArchive.root,
           noteHashTreeRoot: block.header.state.partial.noteHashTree.root,
           nullifierTreeRoot: block.header.state.partial.nullifierTree.root,
@@ -124,7 +124,7 @@ export class EpochProvingJob implements Traceable {
         await db.close();
         this.log.verbose(`Processed all ${txs.length} txs for block ${block.number}`, {
           blockNumber: block.number,
-          blockHash: block.hash().toString(),
+          blockHash: (await block.hash()).toString(),
           uuid: this.uuid,
         });
 
@@ -144,7 +144,10 @@ export class EpochProvingJob implements Traceable {
         throw new Error('Failed to submit epoch proof to L1');
       }
 
-      this.log.info(`Submitted proof for epoch`, { epochNumber, uuid: this.uuid });
+      this.log.info(`Submitted proof for epoch ${epochNumber} (blocks ${fromBlock} to ${toBlock})`, {
+        epochNumber,
+        uuid: this.uuid,
+      });
       this.state = 'completed';
       this.metrics.recordProvingJob(executionTime, timer.ms(), epochSizeBlocks, epochSizeTxs);
     } catch (err: any) {
@@ -210,9 +213,12 @@ export class EpochProvingJob implements Traceable {
     return this.l2BlockSource.getBlockHeader(blockNumber);
   }
 
-  private getTxs(block: L2Block): Tx[] {
+  private async getTxs(block: L2Block): Promise<Tx[]> {
     const txHashes = block.body.txEffects.map(tx => tx.txHash.toBigInt());
-    return this.txs.filter(tx => txHashes.includes(tx.getTxHash().toBigInt()));
+    const txsAndHashes = await Promise.all(this.txs.map(async tx => ({ tx, hash: await tx.getTxHash() })));
+    return txsAndHashes
+      .filter(txAndHash => txHashes.includes(txAndHash.hash.toBigInt()))
+      .map(txAndHash => txAndHash.tx);
   }
 
   private getL1ToL2Messages(block: L2Block) {

package/src/metrics.ts

@@ -1,4 +1,14 @@
-import { type Histogram, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
+import { type L1PublishProofStats, type L1PublishStats } from '@aztec/circuit-types/stats';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { formatEther } from 'viem';
 
 export class ProverNodeMetrics {
   proverEpochExecutionDuration: Histogram;
@@ -6,6 +16,15 @@ export class ProverNodeMetrics {
   provingJobBlocks: Histogram;
   provingJobTransactions: Histogram;
 
+  gasPrice: Histogram;
+  txCount: UpDownCounter;
+  txDuration: Histogram;
+  txGas: Histogram;
+  txCalldataSize: Histogram;
+  txCalldataGas: Histogram;
+  txBlobDataGasUsed: Histogram;
+  txBlobDataGasCost: Histogram;
+
   constructor(public readonly client: TelemetryClient, name = 'ProverNode') {
     const meter = client.getMeter(name);
     this.proverEpochExecutionDuration = meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION, {
@@ -26,6 +45,63 @@ export class ProverNodeMetrics {
       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,
+    });
+  }
+
+  recordFailedTx() {
+    this.txCount.add(1, {
+      [Attributes.L1_TX_TYPE]: 'submitProof',
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordSubmitProof(durationMs: number, stats: L1PublishProofStats) {
+    this.recordTx(durationMs, stats);
   }
 
   public recordProvingJob(executionTimeMs: number, totalTimeMs: number, numBlocks: number, numTxs: number) {
@@ -34,4 +110,34 @@ export class ProverNodeMetrics {
     this.provingJobBlocks.record(Math.floor(numBlocks));
     this.provingJobTransactions.record(Math.floor(numTxs));
   }
+
+  private recordTx(durationMs: number, stats: L1PublishStats) {
+    const attributes = {
+      [Attributes.L1_TX_TYPE]: 'submitProof',
+      [Attributes.L1_SENDER]: stats.sender,
+    } as const;
+
+    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/src/monitors/claims-monitor.ts

@@ -2,7 +2,6 @@ import { type EpochProofClaim } from '@aztec/circuit-types';
 import { type EthAddress } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { type L1Publisher } from '@aztec/sequencer-client';
 import {
   type TelemetryClient,
   type Traceable,
@@ -11,6 +10,8 @@ import {
   trackSpan,
 } from '@aztec/telemetry-client';
 
+import { type ProverNodePublisher } from '../prover-node-publisher.js';
+
 export interface ClaimsMonitorHandler {
   handleClaim(proofClaim: EpochProofClaim): Promise<void>;
 }
@@ -25,7 +26,7 @@ export class ClaimsMonitor implements Traceable {
   public readonly tracer: Tracer;
 
   constructor(
-    private readonly l1Publisher: L1Publisher,
+    private readonly l1Publisher: ProverNodePublisher,
     private options: { pollingIntervalMs: number },
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {

package/src/prover-node-publisher.ts

@@ -0,0 +1,281 @@
+import { type L1PublishProofStats } from '@aztec/circuit-types/stats';
+import { AGGREGATION_OBJECT_LENGTH, AZTEC_MAX_EPOCH_DURATION, type Proof } from '@aztec/circuits.js';
+import { type FeeRecipient, type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
+import { type L1TxUtils, type RollupContract } from '@aztec/ethereum';
+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 { type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { type PublisherConfig, type TxSenderConfig } from '@aztec/sequencer-client';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { type Hex, type TransactionReceipt, encodeFunctionData } from 'viem';
+
+import { ProverNodeMetrics } from './metrics.js';
+
+/**
+ * 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 class ProverNodePublisher {
+  private interruptibleSleep = new InterruptibleSleep();
+  private sleepTimeMs: number;
+  private interrupted = false;
+  private metrics: ProverNodeMetrics;
+
+  protected log = createLogger('prover-node:l1-tx-publisher');
+
+  protected rollupContract: RollupContract;
+
+  public readonly l1TxUtils: L1TxUtils;
+
+  constructor(
+    config: TxSenderConfig & PublisherConfig,
+    deps: {
+      rollupContract: RollupContract;
+      l1TxUtils: L1TxUtils;
+      telemetry?: TelemetryClient;
+    },
+  ) {
+    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.
+   */
+  public interrupt() {
+    this.interrupted = true;
+    this.interruptibleSleep.interrupt();
+  }
+
+  /** Restarts the publisher after calling `interrupt`. */
+  public restart() {
+    this.interrupted = false;
+  }
+
+  public getSenderAddress() {
+    return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+  }
+
+  public getProofClaim() {
+    return this.rollupContract.getProofClaim();
+  }
+
+  public async submitEpochProof(args: {
+    epochNumber: number;
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }): Promise<boolean> {
+    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;
+      }
+
+      // Tx was mined successfully
+      if (txReceipt.status) {
+        const tx = await this.l1TxUtils.getTransactionStats(txReceipt.transactionHash);
+        const stats: L1PublishProofStats = {
+          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;
+  }
+
+  private async validateEpochProofSubmission(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }) {
+    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: Fr[] | readonly string[]) => inputs.map(x => x.toString()).join(', ');
+      throw new Error(
+        `Root rollup public inputs mismatch:\nRollup:  ${fmt(rollupPublicInputs)}\nComputed:${fmt(argsPublicInputs)}`,
+      );
+    }
+  }
+
+  private async sendSubmitEpochProofTx(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }): Promise<TransactionReceipt | undefined> {
+    const proofHex: Hex = `0x${args.proof.withoutPublicInputs().toString('hex')}`;
+    const argsArray = this.getSubmitEpochProofArgs(args);
+
+    const txArgs = [
+      {
+        epochSize: argsArray[0],
+        args: argsArray[1],
+        fees: argsArray[2],
+        blobPublicInputs: argsArray[3],
+        aggregationObject: argsArray[4],
+        proof: proofHex,
+      },
+    ] as const;
+
+    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;
+    }
+  }
+
+  private getSubmitEpochProofArgs(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }) {
+    return [
+      BigInt(args.toBlock - args.fromBlock + 1),
+      [
+        args.publicInputs.previousArchive.root.toString(),
+        args.publicInputs.endArchive.root.toString(),
+        args.publicInputs.previousBlockHash.toString(),
+        args.publicInputs.endBlockHash.toString(),
+        args.publicInputs.endTimestamp.toString(),
+        args.publicInputs.outHash.toString(),
+        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')}`,
+    ] as const;
+  }
+
+  protected async sleepOrInterrupted() {
+    await this.interruptibleSleep.sleep(this.sleepTimeMs);
+  }
+}

package/src/prover-node.ts

@@ -26,7 +26,6 @@ import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
 import { type Maybe } from '@aztec/foundation/types';
 import { type P2P } from '@aztec/p2p';
-import { type L1Publisher } from '@aztec/sequencer-client';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import {
   Attributes,
@@ -42,6 +41,7 @@ import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-
 import { ProverNodeMetrics } from './metrics.js';
 import { type ClaimsMonitor, type ClaimsMonitorHandler } from './monitors/claims-monitor.js';
 import { type EpochMonitor, type EpochMonitorHandler } from './monitors/epoch-monitor.js';
+import { type ProverNodePublisher } from './prover-node-publisher.js';
 import { type QuoteProvider } from './quote-provider/index.js';
 import { type QuoteSigner } from './quote-signer.js';
 
@@ -74,7 +74,7 @@ export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, Pr
 
   constructor(
     protected readonly prover: EpochProverManager,
-    protected readonly publisher: L1Publisher,
+    protected readonly publisher: ProverNodePublisher,
     protected readonly l2BlockSource: L2BlockSource & Maybe<Service>,
     protected readonly l1ToL2MessageSource: L1ToL2MessageSource,
     protected readonly contractDataSource: ContractDataSource,

package/src/test/index.ts

@@ -1,11 +1,11 @@
 import { type EpochProverManager } from '@aztec/circuit-types';
-import { type L1Publisher } from '@aztec/sequencer-client';
 
+import { type ProverNodePublisher } from '../prover-node-publisher.js';
 import { ProverNode } from '../prover-node.js';
 
 class TestProverNode_ extends ProverNode {
   public override prover!: EpochProverManager;
-  public override publisher!: L1Publisher;
+  public override publisher!: ProverNodePublisher;
 }
 
 export type TestProverNode = TestProverNode_;