@aztec/prover-node 0.71.0 → 0.73.0

package/src/bond/factory.ts

@@ -1,19 +1,6 @@
-import { EthAddress } from '@aztec/circuits.js';
+import { type EthAddress } from '@aztec/circuits.js';
+import { type L1Clients } from '@aztec/ethereum';
 import { compact } from '@aztec/foundation/collection';
-import { type RollupAbi } from '@aztec/l1-artifacts';
-
-import {
-  type Chain,
-  type Client,
-  type GetContractReturnType,
-  type HttpTransport,
-  type PrivateKeyAccount,
-  type PublicActions,
-  type PublicClient,
-  type PublicRpcSchema,
-  type WalletActions,
-  type WalletRpcSchema,
-} from 'viem';
 
 import { BondManager } from './bond-manager.js';
 import { type ProverBondManagerConfig, getProverBondManagerConfigFromEnv } from './config.js';
@@ -21,21 +8,14 @@ import { EscrowContract } from './escrow-contract.js';
 import { TokenContract } from './token-contract.js';
 
 export async function createBondManager(
-  rollupContract: GetContractReturnType<typeof RollupAbi, PublicClient>,
-  client: Client<
-    HttpTransport,
-    Chain,
-    PrivateKeyAccount,
-    [...WalletRpcSchema, ...PublicRpcSchema],
-    PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
-  >,
+  escrowContractAddress: EthAddress,
+  client: L1Clients['walletClient'],
   overrides: Partial<ProverBondManagerConfig> = {},
 ) {
   const config = { ...getProverBondManagerConfigFromEnv(), ...compact(overrides) };
   const { proverMinimumEscrowAmount: minimumStake, proverTargetEscrowAmount: maybeTargetStake } = config;
   const targetStake = maybeTargetStake ?? minimumStake * 2n;
 
-  const escrowContractAddress = EthAddress.fromString(await rollupContract.read.PROOF_COMMITMENT_ESCROW());
   const escrow = new EscrowContract(client, escrowContractAddress);
 
   const tokenContractAddress = await escrow.getTokenAddress();

package/src/bond/token-contract.ts

@@ -1,18 +1,14 @@
 import { EthAddress } from '@aztec/circuits.js';
+import { type L1Clients } from '@aztec/ethereum';
 import { createLogger } from '@aztec/foundation/log';
 import { IERC20Abi, TestERC20Abi } from '@aztec/l1-artifacts';
 
 import {
   type Chain,
-  type Client,
   type GetContractReturnType,
   type HttpTransport,
   type PrivateKeyAccount,
-  type PublicActions,
-  type PublicRpcSchema,
-  type WalletActions,
   type WalletClient,
-  type WalletRpcSchema,
   getContract,
 } from 'viem';
 
@@ -23,16 +19,7 @@ export class TokenContract {
   private token: GetContractReturnType<typeof IERC20Abi, WalletClient<HttpTransport, Chain, PrivateKeyAccount>>;
   private logger = createLogger('prover-node:token-contract');
 
-  constructor(
-    private readonly client: Client<
-      HttpTransport,
-      Chain,
-      PrivateKeyAccount,
-      [...WalletRpcSchema, ...PublicRpcSchema],
-      PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
-    >,
-    address: EthAddress,
-  ) {
+  constructor(private readonly client: L1Clients['walletClient'], address: EthAddress) {
     this.token = getContract({ address: address.toString(), abi: IERC20Abi, client });
   }
 

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/http.ts

@@ -1,5 +1,5 @@
 import { ProverNodeApiSchema } from '@aztec/circuit-types';
-import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
 
 import { type ProverNode } from './prover-node.js';
 
@@ -9,5 +9,5 @@ import { type ProverNode } from './prover-node.js';
  * @returns An JSON-RPC HTTP server
  */
 export function createProverNodeRpcServer(node: ProverNode) {
-  return createSafeJsonRpcServer(node, ProverNodeApiSchema);
+  return createTracedJsonRpcServer(node, ProverNodeApiSchema);
 }

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,40 +91,40 @@ 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);
+        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,
           publicDataTreeRoot: block.header.state.partial.publicDataTree.root,
-          previousHeader: previousHeader?.hash(),
+          previousHeader: previousHeader.hash(),
           uuid: this.uuid,
           ...globalVariables,
         });
 
         // Start block proving
-        await this.prover.startNewBlock(globalVariables, l1ToL2Messages);
+        await this.prover.startNewBlock(globalVariables, l1ToL2Messages, previousHeader);
 
         // Process public fns
         const db = await this.dbProvider.fork(block.number - 1);
-        const publicProcessor = this.publicProcessorFactory.create(db, previousHeader, globalVariables, true);
+        const publicProcessor = this.publicProcessorFactory.create(db, globalVariables, true);
         const processed = await this.processTxs(publicProcessor, txs);
         await this.prover.addTxs(processed);
         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) {
@@ -202,17 +205,20 @@ export class EpochProvingJob implements Traceable {
     }
   }
 
-  /* Returns the header for the given block number, or undefined for block zero. */
-  private getBlockHeader(blockNumber: number) {
+  /* Returns the header for the given block number, or the genesis block for block zero. */
+  private async getBlockHeader(blockNumber: number) {
     if (blockNumber === 0) {
-      return undefined;
+      return (await this.dbProvider.fork()).getInitialHeader();
     }
     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-coordination/factory.ts

@@ -10,7 +10,7 @@ import { type EpochCache } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createP2PClient } from '@aztec/p2p';
-import { type TelemetryClient } from '@aztec/telemetry-client';
+import { type TelemetryClient, makeTracedFetch } from '@aztec/telemetry-client';
 
 import { type ProverNodeConfig } from '../config.js';
 
@@ -64,7 +64,7 @@ export async function createProverCoordination(
 
   if (config.proverCoordinationNodeUrl) {
     log.info('Using prover coordination via node url');
-    return createAztecNodeClient(config.proverCoordinationNodeUrl);
+    return createAztecNodeClient(config.proverCoordinationNodeUrl, makeTracedFetch([1, 2, 3], false));
   } else {
     throw new Error(`Aztec Node URL for Tx Provider is not set.`);
   }