@aztec/prover-node 0.76.4 → 0.77.0-testnet-ignition.21

package/src/config.ts

@@ -1,35 +1,29 @@
-import { type ArchiverConfig, archiverConfigMappings, getArchiverConfigFromEnv } from '@aztec/archiver/config';
-import { type ACVMConfig, type BBConfig } from '@aztec/bb-prover/config';
-import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
-import { type DataStoreConfig, dataConfigMappings, getDataConfigFromEnv } from '@aztec/kv-store/config';
-import { type P2PConfig, getP2PConfigFromEnv, p2pConfigMappings } from '@aztec/p2p/config';
+import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
+import type { ACVMConfig, BBConfig } from '@aztec/bb-prover/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import {
   type ProverAgentConfig,
   type ProverBrokerConfig,
   proverAgentConfigMappings,
   proverBrokerConfigMappings,
 } from '@aztec/prover-client/broker';
-import {
-  type ProverClientConfig,
-  bbConfigMappings,
-  getProverEnvVars,
-  proverClientConfigMappings,
-} from '@aztec/prover-client/config';
+import { type ProverClientConfig, bbConfigMappings, proverClientConfigMappings } from '@aztec/prover-client/config';
 import {
   type PublisherConfig,
   type TxSenderConfig,
-  getPublisherConfigFromEnv,
   getPublisherConfigMappings,
-  getTxSenderConfigFromEnv,
   getTxSenderConfigMappings,
 } from '@aztec/sequencer-client/config';
-import { type WorldStateConfig, getWorldStateConfigFromEnv, worldStateConfigMappings } from '@aztec/world-state/config';
+import { type WorldStateConfig, worldStateConfigMappings } from '@aztec/world-state/config';
 
-import {
-  type ProverCoordinationConfig,
-  getTxProviderConfigFromEnv,
-  proverCoordinationConfigMappings,
-} from './prover-coordination/config.js';
+import { type ProverCoordinationConfig, proverCoordinationConfigMappings } from './prover-coordination/config.js';
 
 export type ProverNodeConfig = ArchiverConfig &
   ProverClientConfig &
@@ -39,7 +33,10 @@ export type ProverNodeConfig = ArchiverConfig &
   TxSenderConfig &
   DataStoreConfig &
   ProverCoordinationConfig &
-  SpecificProverNodeConfig;
+  SpecificProverNodeConfig & {
+    /** Whether to populate the genesis state with initial fee juice for the test accounts */
+    testAccounts: boolean;
+  };
 
 type SpecificProverNodeConfig = {
   proverNodeMaxPendingJobs: number;
@@ -93,20 +90,15 @@ export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
   ...getTxSenderConfigMappings('PROVER'),
   ...proverCoordinationConfigMappings,
   ...specificProverNodeConfigMappings,
+  testAccounts: {
+    env: 'TEST_ACCOUNTS',
+    description: 'Whether to populate the genesis state with initial fee juice for the test accounts.',
+    ...booleanConfigHelper(false),
+  },
 };
 
 export function getProverNodeConfigFromEnv(): ProverNodeConfig {
-  return {
-    ...getP2PConfigFromEnv(),
-    ...getDataConfigFromEnv(),
-    ...getArchiverConfigFromEnv(),
-    ...getProverEnvVars(),
-    ...getWorldStateConfigFromEnv(),
-    ...getPublisherConfigFromEnv('PROVER'),
-    ...getTxSenderConfigFromEnv('PROVER'),
-    ...getTxProviderConfigFromEnv(),
-    ...getConfigFromMappings(specificProverNodeConfigMappings),
-  };
+  return getConfigFromMappings(proverNodeConfigMappings);
 }
 
 export function getProverNodeBrokerConfigFromEnv(): ProverBrokerConfig {

package/src/factory.ts

@@ -1,16 +1,17 @@
 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 { L1TxUtils, RollupContract, createEthereumChain, createL1Clients } from '@aztec/ethereum';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
+import type { ProverCoordination, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
-import { type ProverNodeConfig } from './config.js';
+import type { ProverNodeConfig } from './config.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
 import { createProverCoordination } from './prover-coordination/factory.js';
 import { ProverNodePublisher } from './prover-node-publisher.js';
@@ -29,6 +30,9 @@ export async function createProverNode(
     broker?: ProvingJobBroker;
     l1TxUtils?: L1TxUtils;
   } = {},
+  options: {
+    prefilledPublicData?: PublicDataTreeLeaf[];
+  } = {},
 ) {
   const telemetry = deps.telemetry ?? getTelemetryClient();
   const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
@@ -37,15 +41,20 @@ export async function createProverNode(
   log.verbose(`Created archiver and synced to block ${await archiver.getBlockNumber()}`);
 
   const worldStateConfig = { ...config, worldStateProvenBlocksOnly: false };
-  const worldStateSynchronizer = await createWorldStateSynchronizer(worldStateConfig, archiver, telemetry);
+  const worldStateSynchronizer = await createWorldStateSynchronizer(
+    worldStateConfig,
+    archiver,
+    options.prefilledPublicData,
+    telemetry,
+  );
   await worldStateSynchronizer.start();
 
   const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
   const prover = await createProverClient(config, worldStateSynchronizer, broker, telemetry);
 
-  const { l1RpcUrl: rpcUrl, l1ChainId: chainId, publisherPrivateKey } = config;
-  const chain = createEthereumChain(rpcUrl, chainId);
-  const { publicClient, walletClient } = createL1Clients(rpcUrl, publisherPrivateKey, chain.chainInfo);
+  const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
 
   const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
 
@@ -73,7 +82,7 @@ export async function createProverNode(
     txGatheringTimeoutMs: config.txGatheringTimeoutMs,
   };
 
-  const epochMonitor = new EpochMonitor(archiver, proverNodeConfig, telemetry);
+  const epochMonitor = await EpochMonitor.create(archiver, proverNodeConfig, telemetry);
 
   return new ProverNode(
     prover,

package/src/http.ts

@@ -1,7 +1,7 @@
-import { ProverNodeApiSchema } from '@aztec/circuit-types';
+import { ProverNodeApiSchema } from '@aztec/stdlib/interfaces/server';
 import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
 
-import { type ProverNode } from './prover-node.js';
+import type { ProverNode } from './prover-node.js';
 
 /**
  * Wrap a ProverNode instance with a JSON RPC HTTP server.

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

@@ -1,25 +1,23 @@
+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 { PublicProcessor, PublicProcessorFactory } from '@aztec/simulator/server';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
 import {
   type EpochProver,
   type EpochProvingJobState,
   EpochProvingJobTerminalState,
   type ForkMerkleTreeOperations,
-  type L1ToL2MessageSource,
-  type L2Block,
-  type L2BlockSource,
-  type ProcessedTx,
-  type Tx,
-} from '@aztec/circuit-types';
-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 PublicProcessor, type PublicProcessorFactory } from '@aztec/simulator/server';
+} from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { ProcessedTx, Tx } from '@aztec/stdlib/tx';
 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';
+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,

package/src/metrics.ts

@@ -1,6 +1,8 @@
-import { type L1PublishProofStats, type L1PublishStats } from '@aztec/circuit-types/stats';
+import { createLogger } from '@aztec/foundation/log';
+import type { L1PublishProofStats, L1PublishStats } from '@aztec/stdlib/stats';
 import {
   Attributes,
+  type Gauge,
   type Histogram,
   Metrics,
   type TelemetryClient,
@@ -25,7 +27,13 @@ export class ProverNodeMetrics {
   txBlobDataGasUsed: Histogram;
   txBlobDataGasCost: Histogram;
 
-  constructor(public readonly client: TelemetryClient, name = 'ProverNode') {
+  private senderBalance: Gauge;
+
+  constructor(
+    public readonly client: TelemetryClient,
+    name = 'ProverNode',
+    private logger = createLogger('prover-node:publisher:metrics'),
+  ) {
     const meter = client.getMeter(name);
     this.proverEpochExecutionDuration = meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION, {
       description: 'Duration of execution of an epoch by the prover',
@@ -34,8 +42,8 @@ export class ProverNodeMetrics {
     });
     this.provingJobDuration = meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION, {
       description: 'Duration of proving job',
-      unit: 'ms',
-      valueType: ValueType.INT,
+      unit: 's',
+      valueType: ValueType.DOUBLE,
     });
     this.provingJobBlocks = meter.createHistogram(Metrics.PROVER_NODE_JOB_BLOCKS, {
       description: 'Number of blocks in a proven epoch',
@@ -91,6 +99,12 @@ export class ProverNodeMetrics {
       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() {
@@ -106,11 +120,18 @@ export class ProverNodeMetrics {
 
   public recordProvingJob(executionTimeMs: number, totalTimeMs: number, numBlocks: number, numTxs: number) {
     this.proverEpochExecutionDuration.record(Math.ceil(executionTimeMs));
-    this.provingJobDuration.record(Math.ceil(totalTimeMs));
+    this.provingJobDuration.record(totalTimeMs / 1000);
     this.provingJobBlocks.record(Math.floor(numBlocks));
     this.provingJobTransactions.record(Math.floor(numTxs));
   }
 
+  public recordSenderBalance(wei: bigint, senderAddress: string) {
+    const eth = parseFloat(formatEther(wei, 'wei'));
+    this.senderBalance.record(eth, {
+      [Attributes.SENDER_ADDRESS]: senderAddress,
+    });
+  }
+
   private recordTx(durationMs: number, stats: L1PublishStats) {
     const attributes = {
       [Attributes.L1_TX_TYPE]: 'submitProof',

package/src/monitors/epoch-monitor.ts

@@ -1,6 +1,7 @@
-import { type L2BlockSource } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import {
   type TelemetryClient,
   type Traceable,
@@ -10,20 +11,31 @@ import {
 } from '@aztec/telemetry-client';
 
 export interface EpochMonitorHandler {
-  handleEpochCompleted(epochNumber: bigint): Promise<void>;
+  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 class EpochMonitor implements Traceable {
   private runningPromise: RunningPromise;
   private log = createLogger('prover-node:epoch-monitor');
   public readonly tracer: Tracer;
 
   private handler: EpochMonitorHandler | undefined;
-
   private latestEpochNumber: bigint | undefined;
 
   constructor(
     private readonly l2BlockSource: L2BlockSource,
+    private readonly l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
     private options: { pollingIntervalMs: number },
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {
@@ -31,12 +43,26 @@ export class EpochMonitor implements Traceable {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.options.pollingIntervalMs);
   }
 
+  public static async create(
+    l2BlockSource: L2BlockSource,
+    options: { pollingIntervalMs: number },
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ): Promise<EpochMonitor> {
+    const l1Constants = await l2BlockSource.getL1Constants();
+    return new EpochMonitor(l2BlockSource, l1Constants, options, telemetry);
+  }
+
   public start(handler: EpochMonitorHandler) {
     this.handler = handler;
     this.runningPromise.start();
     this.log.info('Started EpochMonitor', this.options);
   }
 
+  /** Exposed for testing */
+  public setHandler(handler: EpochMonitorHandler) {
+    this.handler = handler;
+  }
+
   public async stop() {
     await this.runningPromise.stop();
     this.log.info('Stopped EpochMonitor');
@@ -44,18 +70,37 @@ export class EpochMonitor implements Traceable {
 
   @trackSpan('EpochMonitor.work')
   public async work() {
-    if (!this.latestEpochNumber) {
-      const epochNumber = await this.l2BlockSource.getL2EpochNumber();
-      if (epochNumber > 0n) {
-        await this.handler?.handleEpochCompleted(epochNumber - 1n);
-      }
-      this.latestEpochNumber = epochNumber;
+    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;
     }
 
-    if (await this.l2BlockSource.isEpochComplete(this.latestEpochNumber)) {
-      await this.handler?.handleEpochCompleted(this.latestEpochNumber);
-      this.latestEpochNumber += 1n;
+    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;
+  }
+
+  private 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 };
   }
 }

package/src/prover-coordination/factory.ts

@@ -1,21 +1,18 @@
-import { type ArchiveSource, type Archiver } from '@aztec/archiver';
+import type { ArchiveSource, Archiver } from '@aztec/archiver';
 import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import {
-  P2PClientType,
-  type ProverCoordination,
-  type WorldStateSynchronizer,
-  createAztecNodeClient,
-  getComponentsVersionsFromConfig,
-} from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import type { EpochCache } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+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 type { ProverCoordination, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { type TelemetryClient, makeTracedFetch } from '@aztec/telemetry-client';
 
-import { type ProverNodeConfig } from '../config.js';
+import type { ProverNodeConfig } from '../config.js';
 
 // We return a reference to the P2P client so that the prover node can stop the service when it shuts down.
 type ProverCoordinationDeps = {

package/src/prover-node-publisher.ts

@@ -1,7 +1,5 @@
-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 { AGGREGATION_OBJECT_LENGTH, AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import type { L1TxUtils, RollupContract } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
 import { areArraysEqual, times } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -11,7 +9,10 @@ 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 { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { FeeRecipient, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { L1PublishProofStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { type Hex, type TransactionReceipt, encodeFunctionData } from 'viem';
@@ -105,6 +106,12 @@ export class ProverNodePublisher {
         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);
@@ -251,15 +258,15 @@ export class ProverNodePublisher {
     return [
       BigInt(args.fromBlock),
       BigInt(args.toBlock),
-      [
-        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(),
-      ],
+      {
+        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()

package/src/prover-node.ts

@@ -1,28 +1,26 @@
+import { compact } from '@aztec/foundation/collection';
+import { memoize } from '@aztec/foundation/decorators';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { Maybe } from '@aztec/foundation/types';
+import type { P2P } from '@aztec/p2p';
+import { PublicProcessorFactory } from '@aztec/simulator/server';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import {
   type EpochProverManager,
   EpochProvingJobTerminalState,
-  type L1ToL2MessageSource,
-  type L2Block,
-  type L2BlockSource,
-  type P2PClientType,
   type ProverCoordination,
   type ProverNodeApi,
   type Service,
-  type Tx,
-  type TxHash,
   type WorldStateSynchronizer,
-  getTimestampRangeForEpoch,
   tryStop,
-} from '@aztec/circuit-types';
-import { type ContractDataSource } from '@aztec/circuits.js';
-import { compact } from '@aztec/foundation/collection';
-import { memoize } from '@aztec/foundation/decorators';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { DateProvider } from '@aztec/foundation/timer';
-import { type Maybe } from '@aztec/foundation/types';
-import { type P2P } from '@aztec/p2p';
-import { PublicProcessorFactory } from '@aztec/simulator/server';
+} from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
 import {
   Attributes,
   type TelemetryClient,
@@ -34,8 +32,8 @@ import {
 
 import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-job.js';
 import { ProverNodeMetrics } from './metrics.js';
-import { type EpochMonitor, type EpochMonitorHandler } from './monitors/epoch-monitor.js';
-import { type ProverNodePublisher } from './prover-node-publisher.js';
+import type { EpochMonitor, EpochMonitorHandler } from './monitors/epoch-monitor.js';
+import type { ProverNodePublisher } from './prover-node-publisher.js';
 
 export type ProverNodeOptions = {
   pollingIntervalMs: number;
@@ -94,6 +92,10 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     this.txFetcher = new RunningPromise(() => this.checkForTxs(), this.log, this.options.txGatheringIntervalMs);
   }
 
+  public getProverId() {
+    return this.prover.getProverId();
+  }
+
   public getP2P() {
     const asP2PClient = this.coordination as P2P<P2PClientType.Prover>;
     if (typeof asP2PClient.isP2PClient === 'function' && asP2PClient.isP2PClient()) {
@@ -106,7 +108,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
    * Handles an epoch being completed by starting a proof for it if there are no active jobs for it.
    * @param epochNumber - The epoch number that was just completed.
    */
-  async handleEpochCompleted(epochNumber: bigint): Promise<void> {
+  async handleEpochReadyToProve(epochNumber: bigint): Promise<void> {
     try {
       this.log.debug('jobs', JSON.stringify(this.jobs, null, 2));
       const activeJobs = await this.getActiveJobsForEpoch(epochNumber);
@@ -216,7 +218,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
 
     // Fast forward world state to right before the target block and get a fork
     this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
-    await this.worldState.syncImmediate(fromBlock - 1);
+    await this.worldState.syncImmediate(toBlock);
 
     // Create a processor using the forked world state
     const publicProcessorFactory = new PublicProcessorFactory(
@@ -253,7 +255,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
         return;
       }
       const txHashes = block.body.txEffects.map(tx => tx.txHash);
-      this.log.verbose(`Fetching ${txHashes.length} for block number ${blockNumber} from coordination`);
+      this.log.verbose(`Fetching ${txHashes.length} tx hashes for block number ${blockNumber} from coordination`);
       await this.coordination.getTxsByHash(txHashes); // This stores the txs in the tx pool, no need to persist them here
       this.lastBlockNumber = blockNumber;
     }

package/src/test/index.ts

@@ -1,6 +1,6 @@
-import { type EpochProverManager } from '@aztec/circuit-types';
+import type { EpochProverManager } from '@aztec/stdlib/interfaces/server';
 
-import { type ProverNodePublisher } from '../prover-node-publisher.js';
+import type { ProverNodePublisher } from '../prover-node-publisher.js';
 import { ProverNode } from '../prover-node.js';
 
 class TestProverNode_ extends ProverNode {