@aztec/prover-node 1.0.0-nightly.20250708 → 1.0.0-staging.0

package/dest/prover-node.js

@@ -8,6 +8,7 @@ import { assertRequired, compact, pick, sum } from '@aztec/foundation/collection
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
 import { DateProvider } from '@aztec/foundation/timer';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
@@ -27,7 +28,7 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
     l1ToL2MessageSource;
     contractDataSource;
     worldState;
-    p2pClient;
+    coordination;
     epochsMonitor;
     telemetryClient;
     log;
@@ -37,15 +38,17 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
     jobMetrics;
     rewardsMetrics;
     l1Metrics;
+    txFetcher;
+    lastBlockNumber;
     tracer;
-    constructor(prover, publisher, l2BlockSource, l1ToL2MessageSource, contractDataSource, worldState, p2pClient, epochsMonitor, config = {}, telemetryClient = getTelemetryClient()){
+    constructor(prover, publisher, l2BlockSource, l1ToL2MessageSource, contractDataSource, worldState, coordination, epochsMonitor, config = {}, telemetryClient = getTelemetryClient()){
         this.prover = prover;
         this.publisher = publisher;
         this.l2BlockSource = l2BlockSource;
         this.l1ToL2MessageSource = l1ToL2MessageSource;
         this.contractDataSource = contractDataSource;
         this.worldState = worldState;
-        this.p2pClient = p2pClient;
+        this.coordination = coordination;
         this.epochsMonitor = epochsMonitor;
         this.telemetryClient = telemetryClient;
         this.log = createLogger('prover-node');
@@ -61,7 +64,6 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
             txGatheringIntervalMs: 1_000,
             txGatheringBatchSize: 10,
             txGatheringMaxParallelRequestsPerNode: 100,
-            txGatheringTimeoutMs: 120_000,
             proverNodeFailedEpochStore: undefined,
             ...compact(config)
         };
@@ -70,12 +72,13 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
         this.tracer = telemetryClient.getTracer('ProverNode');
         this.jobMetrics = new ProverNodeJobMetrics(meter, telemetryClient.getTracer('EpochProvingJob'));
         this.rewardsMetrics = new ProverNodeRewardsMetrics(meter, EthAddress.fromField(this.prover.getProverId()), this.publisher.getRollupContract());
+        this.txFetcher = new RunningPromise(()=>this.checkForTxs(), this.log, this.config.txGatheringIntervalMs);
     }
     getProverId() {
         return this.prover.getProverId();
     }
     getP2P() {
-        return this.p2pClient;
+        return this.coordination.getP2PClient();
     }
     /**
    * Handles an epoch being completed by starting a proof for it if there are no active jobs for it.
@@ -108,6 +111,7 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
    * Starts the prover node so it periodically checks for unproven epochs in the unfinalised chain from L1 and
    * starts proving jobs for them.
    */ async start() {
+        this.txFetcher.start();
         this.epochsMonitor.start(this);
         this.l1Metrics.start();
         await this.rewardsMetrics.start();
@@ -117,13 +121,14 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
    * Stops the prover node and all its dependencies.
    */ async stop() {
         this.log.info('Stopping ProverNode');
+        await this.txFetcher.stop();
         await this.epochsMonitor.stop();
         await this.prover.stop();
-        await tryStop(this.p2pClient);
         await tryStop(this.l2BlockSource);
         this.publisher.interrupt();
         await Promise.all(Array.from(this.jobs.values()).map((job)=>job.stop()));
         await this.worldState.stop();
+        await tryStop(this.coordination);
         this.l1Metrics.stop();
         this.rewardsMetrics.stop();
         await this.telemetryClient.stop();
@@ -221,6 +226,19 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
     getL1Constants() {
         return this.l2BlockSource.getL1Constants();
     }
+    /** Monitors for new blocks and requests their txs from the p2p layer to ensure they are available for proving. */ async checkForTxs() {
+        const blockNumber = await this.l2BlockSource.getBlockNumber();
+        if (this.lastBlockNumber === undefined || blockNumber > this.lastBlockNumber) {
+            const block = await this.l2BlockSource.getBlock(blockNumber);
+            if (!block) {
+                return;
+            }
+            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+            this.log.verbose(`Fetching ${txHashes.length} tx hashes for block number ${blockNumber} from coordination`);
+            await this.coordination.gatherTxs(txHashes); // This stores the txs in the tx pool, no need to persist them here
+            this.lastBlockNumber = blockNumber;
+        }
+    }
     async gatherEpochData(epochNumber) {
         const blocks = await this.gatherBlocks(epochNumber);
         const txs = await this.gatherTxs(epochNumber, blocks);
@@ -242,20 +260,17 @@ import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
         return blocks;
     }
     async gatherTxs(epochNumber, blocks) {
-        const deadline = new Date(this.dateProvider.now() + this.config.txGatheringTimeoutMs);
-        const txProvider = this.p2pClient.getTxProvider();
-        const txsByBlock = await Promise.all(blocks.map((block)=>txProvider.getTxsForBlock(block, {
-                deadline
-            })));
-        const txs = txsByBlock.map(({ txs })=>txs).flat();
-        const missingTxs = txsByBlock.map(({ missingTxs })=>missingTxs).flat();
-        if (missingTxs.length === 0) {
+        const txsToFind = blocks.flatMap((block)=>block.body.txEffects.map((tx)=>tx.txHash));
+        const txs = await this.coordination.getTxsByHash(txsToFind);
+        if (txs.length === txsToFind.length) {
             this.log.verbose(`Gathered all ${txs.length} txs for epoch ${epochNumber}`, {
                 epochNumber
             });
             return txs;
         }
-        throw new Error(`Txs not found for epoch ${epochNumber}: ${missingTxs.map((hash)=>hash.toString()).join(', ')}`);
+        const txHashesFound = await Promise.all(txs.map((tx)=>tx.getTxHash()));
+        const missingTxHashes = txsToFind.filter((txHashToFind)=>!txHashesFound.some((txHashFound)=>txHashToFind.equals(txHashFound))).join(', ');
+        throw new Error(`Txs not found for epoch ${epochNumber}: ${missingTxHashes}`);
     }
     async gatherMessages(epochNumber, blocks) {
         const messages = await Promise.all(blocks.map((b)=>this.l1ToL2MessageSource.getL1ToL2Messages(b.number)));
@@ -303,6 +318,9 @@ _ts_decorate([
 _ts_decorate([
     memoize
 ], ProverNode.prototype, "getL1Constants", null);
+_ts_decorate([
+    trackSpan('ProverNode.checkForTxs')
+], ProverNode.prototype, "checkForTxs", null);
 _ts_decorate([
     trackSpan('ProverNode.gatherEpochData', (epochNumber)=>({
             [Attributes.EPOCH_NUMBER]: Number(epochNumber)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-node",
-  "version": "1.0.0-nightly.20250708",
+  "version": "1.0.0-staging.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -56,26 +56,26 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "1.0.0-nightly.20250708",
-    "@aztec/bb-prover": "1.0.0-nightly.20250708",
-    "@aztec/blob-lib": "1.0.0-nightly.20250708",
-    "@aztec/blob-sink": "1.0.0-nightly.20250708",
-    "@aztec/constants": "1.0.0-nightly.20250708",
-    "@aztec/epoch-cache": "1.0.0-nightly.20250708",
-    "@aztec/ethereum": "1.0.0-nightly.20250708",
-    "@aztec/foundation": "1.0.0-nightly.20250708",
-    "@aztec/kv-store": "1.0.0-nightly.20250708",
-    "@aztec/l1-artifacts": "1.0.0-nightly.20250708",
-    "@aztec/node-lib": "1.0.0-nightly.20250708",
-    "@aztec/noir-protocol-circuits-types": "1.0.0-nightly.20250708",
-    "@aztec/p2p": "1.0.0-nightly.20250708",
-    "@aztec/protocol-contracts": "1.0.0-nightly.20250708",
-    "@aztec/prover-client": "1.0.0-nightly.20250708",
-    "@aztec/sequencer-client": "1.0.0-nightly.20250708",
-    "@aztec/simulator": "1.0.0-nightly.20250708",
-    "@aztec/stdlib": "1.0.0-nightly.20250708",
-    "@aztec/telemetry-client": "1.0.0-nightly.20250708",
-    "@aztec/world-state": "1.0.0-nightly.20250708",
+    "@aztec/archiver": "1.0.0-staging.0",
+    "@aztec/bb-prover": "1.0.0-staging.0",
+    "@aztec/blob-lib": "1.0.0-staging.0",
+    "@aztec/blob-sink": "1.0.0-staging.0",
+    "@aztec/constants": "1.0.0-staging.0",
+    "@aztec/epoch-cache": "1.0.0-staging.0",
+    "@aztec/ethereum": "1.0.0-staging.0",
+    "@aztec/foundation": "1.0.0-staging.0",
+    "@aztec/kv-store": "1.0.0-staging.0",
+    "@aztec/l1-artifacts": "1.0.0-staging.0",
+    "@aztec/node-lib": "1.0.0-staging.0",
+    "@aztec/noir-protocol-circuits-types": "1.0.0-staging.0",
+    "@aztec/p2p": "1.0.0-staging.0",
+    "@aztec/protocol-contracts": "1.0.0-staging.0",
+    "@aztec/prover-client": "1.0.0-staging.0",
+    "@aztec/sequencer-client": "1.0.0-staging.0",
+    "@aztec/simulator": "1.0.0-staging.0",
+    "@aztec/stdlib": "1.0.0-staging.0",
+    "@aztec/telemetry-client": "1.0.0-staging.0",
+    "@aztec/world-state": "1.0.0-staging.0",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "2.23.7"

package/src/config.ts

@@ -26,6 +26,8 @@ import {
 } from '@aztec/sequencer-client/config';
 import { type WorldStateConfig, worldStateConfigMappings } from '@aztec/world-state/config';
 
+import { type ProverCoordinationConfig, proverCoordinationConfigMappings } from './prover-coordination/config.js';
+
 export type ProverNodeConfig = ArchiverConfig &
   ProverClientUserConfig &
   P2PConfig &
@@ -33,6 +35,7 @@ export type ProverNodeConfig = ArchiverConfig &
   PublisherConfig &
   TxSenderConfig &
   DataStoreConfig &
+  ProverCoordinationConfig &
   SharedNodeConfig &
   SpecificProverNodeConfig &
   GenesisStateConfig;
@@ -42,7 +45,6 @@ export type SpecificProverNodeConfig = {
   proverNodePollingIntervalMs: number;
   proverNodeMaxParallelBlocksPerEpoch: number;
   proverNodeFailedEpochStore: string | undefined;
-  txGatheringTimeoutMs: number;
   txGatheringIntervalMs: number;
   txGatheringBatchSize: number;
   txGatheringMaxParallelRequestsPerNode: number;
@@ -84,11 +86,6 @@ const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeCon
     description: 'How many tx requests to make in parallel to each node',
     ...numberConfigHelper(100),
   },
-  txGatheringTimeoutMs: {
-    env: 'PROVER_NODE_TX_GATHERING_TIMEOUT_MS',
-    description: 'How long to wait for tx data to be available before giving up',
-    ...numberConfigHelper(120_000),
-  },
 };
 
 export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
@@ -99,6 +96,7 @@ export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
   ...worldStateConfigMappings,
   ...getPublisherConfigMappings('PROVER'),
   ...getTxSenderConfigMappings('PROVER'),
+  ...proverCoordinationConfigMappings,
   ...specificProverNodeConfigMappings,
   ...genesisStateConfigMappings,
   ...sharedNodeConfigMappings,

package/src/factory.ts

@@ -1,51 +1,44 @@
 import { type Archiver, createArchiver } from '@aztec/archiver';
-import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
 import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
 import { EpochCache } from '@aztec/epoch-cache';
 import { L1TxUtils, RollupContract, createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import { pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { trySnapshotSync } from '@aztec/node-lib/actions';
-import { NodeRpcTxSource, createP2PClient } from '@aztec/p2p';
 import { createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import type { AztecNode, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType } from '@aztec/stdlib/p2p';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import { getPackageVersion } from '@aztec/stdlib/update-checker';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
 import { type ProverNodeConfig, resolveConfig } from './config.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
+import type { TxSource } from './prover-coordination/combined-prover-coordination.js';
+import { createProverCoordination } from './prover-coordination/factory.js';
 import { ProverNodePublisher } from './prover-node-publisher.js';
 import { ProverNode } from './prover-node.js';
 
-export type ProverNodeDeps = {
-  telemetry?: TelemetryClient;
-  log?: Logger;
-  aztecNodeTxProvider?: Pick<AztecNode, 'getTxsByHash'>;
-  archiver?: Archiver;
-  publisher?: ProverNodePublisher;
-  blobSinkClient?: BlobSinkClientInterface;
-  broker?: ProvingJobBroker;
-  l1TxUtils?: L1TxUtils;
-  dateProvider?: DateProvider;
-};
-
 /** Creates a new prover node given a config. */
 export async function createProverNode(
   userConfig: ProverNodeConfig & DataStoreConfig,
-  deps: ProverNodeDeps = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    log?: Logger;
+    aztecNodeTxProvider?: TxSource;
+    archiver?: Archiver;
+    publisher?: ProverNodePublisher;
+    blobSinkClient?: BlobSinkClientInterface;
+    broker?: ProvingJobBroker;
+    l1TxUtils?: L1TxUtils;
+  } = {},
   options: {
     prefilledPublicData?: PublicDataTreeLeaf[];
   } = {},
 ) {
   const config = resolveConfig(userConfig);
   const telemetry = deps.telemetry ?? getTelemetryClient();
-  const dateProvider = deps.dateProvider ?? new DateProvider();
   const blobSinkClient =
     deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('prover-node:blob-sink:client') });
   const log = deps.log ?? createLogger('prover-node');
@@ -78,29 +71,15 @@ export async function createProverNode(
 
   const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
 
-  const proofVerifier = new QueuedIVCVerifier(
-    config,
-    config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier(),
-  );
-
-  const p2pClient = await createP2PClient(
-    P2PClientType.Prover,
-    config,
-    archiver,
-    proofVerifier,
+  // If config.p2pEnabled is true, createProverCoordination will create a p2p client where txs are requested
+  // If config.proverCoordinationNodeUrls is not empty, createProverCoordination will create set of aztec node clients from which txs are requested
+  const proverCoordination = await createProverCoordination(config, {
+    aztecNodeTxProvider: deps.aztecNodeTxProvider,
     worldStateSynchronizer,
+    archiver,
     epochCache,
-    getPackageVersion() ?? '',
-    dateProvider,
     telemetry,
-    {
-      txCollectionNodeSources: deps.aztecNodeTxProvider
-        ? [new NodeRpcTxSource(deps.aztecNodeTxProvider, 'TestNode')]
-        : [],
-    },
-  );
-
-  await p2pClient.start();
+  });
 
   const proverNodeConfig = {
     ...pick(
@@ -131,7 +110,7 @@ export async function createProverNode(
     archiver,
     archiver,
     worldStateSynchronizer,
-    p2pClient,
+    proverCoordination,
     epochMonitor,
     proverNodeConfig,
     telemetry,

package/src/prover-coordination/combined-prover-coordination.ts

@@ -0,0 +1,164 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
+import { createLogger } from '@aztec/foundation/log';
+import type { P2P } from '@aztec/p2p';
+import type { P2PClient, ProverCoordination } from '@aztec/stdlib/interfaces/server';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+export type CombinedCoordinationOptions = {
+  // These options apply to http tx gathering only
+  txGatheringBatchSize: number;
+  txGatheringMaxParallelRequestsPerNode: number;
+};
+
+interface CoordinationPool {
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]>;
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  addTxs(txs: Tx[]): Promise<number>;
+}
+
+export interface TxSource {
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+}
+
+// Wraps the p2p client into a coordination pool
+class P2PCoordinationPool implements CoordinationPool {
+  constructor(private readonly p2p: P2P) {}
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.p2p.getTxsByHash(txHashes, undefined);
+  }
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]> {
+    return this.p2p.hasTxsInPool(txHashes);
+  }
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.p2p.getTxsByHashFromPool(txHashes);
+  }
+  addTxs(txs: Tx[]): Promise<number> {
+    return this.p2p.addTxsToPool(txs);
+  }
+}
+
+// Wraps an in memory tx pool into a coordination pool. Used for testing when no p2p/tx pool is available.
+class InMemoryCoordinationPool implements CoordinationPool {
+  private txs: Map<string, Tx> = new Map();
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return Promise.resolve(txHashes.map(hash => this.txs.get(hash.toString())));
+  }
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(txHashes.map(hash => this.txs.has(hash.toString())));
+  }
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.getTxsByHash(txHashes);
+  }
+  async addTxs(txs: Tx[]): Promise<number> {
+    const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    txs.forEach((tx, index) => this.txs.set(hashes[index].toString(), tx));
+    return txs.length;
+  }
+}
+
+// Class to implement combined transaction retrieval from p2p and any available nodes
+export class CombinedProverCoordination implements ProverCoordination {
+  constructor(
+    public readonly p2p: P2P | undefined,
+    public readonly aztecNodes: TxSource[],
+    private readonly options: CombinedCoordinationOptions = {
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 10,
+    },
+    private readonly log = createLogger('prover-node:combined-prover-coordination'),
+  ) {}
+
+  public getP2PClient(): P2PClient | undefined {
+    return this.p2p;
+  }
+
+  public async getTxsByHash(txHashes: TxHash[]): Promise<Tx[]> {
+    const pool = this.p2p ? new P2PCoordinationPool(this.p2p) : new InMemoryCoordinationPool();
+    await this.#gatherTxs(txHashes, pool);
+    const availability = await pool.hasTxsInPool(txHashes);
+    const notFound = txHashes.filter((_, index) => !availability[index]);
+    if (notFound.length > 0) {
+      throw new Error(`Could not find txs: ${notFound.map(tx => tx.toString())}`);
+    }
+    const txs = await pool.getTxsByHashFromPool(txHashes);
+    return txs.filter(tx => tx !== undefined) as Tx[];
+  }
+
+  public async gatherTxs(txHashes: TxHash[]): Promise<void> {
+    const pool = this.p2p ? new P2PCoordinationPool(this.p2p) : new InMemoryCoordinationPool();
+    await this.#gatherTxs(txHashes, pool);
+  }
+
+  async #gatherTxs(txHashes: TxHash[], pool: CoordinationPool): Promise<void> {
+    const availability = await pool.hasTxsInPool(txHashes);
+    const notFound = txHashes.filter((_, index) => !availability[index]);
+    const txsToFind = new Set(notFound.map(tx => tx.toString()));
+    if (txsToFind.size === 0) {
+      this.log.info(`Check for ${txHashes.length} txs found all in the pool`);
+      return;
+    }
+    this.log.info(`Check for ${txHashes.length} txs found ${txsToFind.size} missing. Will gather from nodes and p2p`);
+    const originalToFind = txsToFind.size;
+    await this.#gatherTxsFromAllNodes(txsToFind, pool);
+    if (txsToFind.size === 0) {
+      this.log.info(`Found all ${originalToFind} txs directly from nodes`);
+      return;
+    }
+    const toFindFromP2P = txsToFind.size;
+    this.log.verbose(`Gathering ${toFindFromP2P} txs from p2p network`);
+    const foundFromP2P = await pool.getTxsByHash([...txsToFind].map(tx => TxHash.fromString(tx)));
+
+    // TODO(!!): test for this
+    // getTxsByHash returns undefined for transactions that are not found, so it must be filtered to find the true length
+    const foundFromP2PLength = foundFromP2P.filter(tx => !!tx).length;
+
+    const numFoundFromNodes = originalToFind - toFindFromP2P;
+    const numNotFound = toFindFromP2P - foundFromP2PLength;
+    if (numNotFound === 0) {
+      this.log.info(`Found all ${originalToFind} txs. ${numFoundFromNodes} from nodes, ${foundFromP2PLength} from p2p`);
+      return;
+    }
+    this.log.warn(
+      `Failed to find ${numNotFound} txs from any source. Found ${foundFromP2PLength} from p2p and ${numFoundFromNodes} from nodes`,
+    );
+  }
+
+  async #gatherTxsFromAllNodes(txsToFind: Set<string>, pool: CoordinationPool) {
+    if (txsToFind.size === 0 || this.aztecNodes.length === 0) {
+      return;
+    }
+    await Promise.all(this.aztecNodes.map(aztecNode => this.#gatherTxsFromNode(txsToFind, aztecNode, pool)));
+  }
+
+  async #gatherTxsFromNode(txsToFind: Set<string>, aztecNode: TxSource, pool: CoordinationPool) {
+    const totalTxsRequired = txsToFind.size;
+
+    // It's possible that the set is empty as we already found the txs
+    if (totalTxsRequired === 0) {
+      return;
+    }
+    let totalTxsGathered = 0;
+
+    const batches: string[][] = [];
+    const allTxs: string[] = [...txsToFind];
+    while (allTxs.length) {
+      const batch = allTxs.splice(0, this.options.txGatheringBatchSize);
+      batches.push(batch);
+    }
+
+    await asyncPool(this.options.txGatheringMaxParallelRequestsPerNode, batches, async batch => {
+      try {
+        const txs = (await aztecNode.getTxsByHash(batch.map(b => TxHash.fromString(b)))).filter((tx): tx is Tx => !!tx);
+        const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+        await pool.addTxs(txs);
+        hashes.forEach(hash => txsToFind.delete(hash.toString()));
+        totalTxsGathered += txs.length;
+      } catch (err) {
+        this.log.error(`Error gathering txs from aztec node: ${err}`);
+        return;
+      }
+    });
+    this.log.verbose(`Gathered ${totalTxsGathered} of ${totalTxsRequired} txs from a node`);
+  }
+}

package/src/prover-coordination/config.ts

@@ -0,0 +1,18 @@
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+
+export type ProverCoordinationConfig = {
+  proverCoordinationNodeUrls: string[];
+};
+
+export const proverCoordinationConfigMappings: ConfigMappingsType<ProverCoordinationConfig> = {
+  proverCoordinationNodeUrls: {
+    env: 'PROVER_COORDINATION_NODE_URLS',
+    description: 'The URLs of the tx provider nodes',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim().replace(/\/$/, '')),
+    defaultValue: [],
+  },
+};
+
+export function getTxProviderConfigFromEnv(): ProverCoordinationConfig {
+  return getConfigFromMappings<ProverCoordinationConfig>(proverCoordinationConfigMappings);
+}

package/src/prover-coordination/factory.ts

@@ -0,0 +1,86 @@
+import type { ArchiveSource, Archiver } from '@aztec/archiver';
+import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
+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/vk-tree';
+import { createP2PClient } from '@aztec/p2p';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { type AztecNode, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import type { ProverCoordination, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { type TelemetryClient, makeTracedFetch } from '@aztec/telemetry-client';
+
+import type { ProverNodeConfig } from '../config.js';
+import {
+  type CombinedCoordinationOptions,
+  CombinedProverCoordination,
+  type TxSource,
+} from './combined-prover-coordination.js';
+
+// We return a reference to the P2P client so that the prover node can stop the service when it shuts down.
+type ProverCoordinationDeps = {
+  aztecNodeTxProvider?: TxSource;
+  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 async function createProverCoordination(
+  config: ProverNodeConfig & DataStoreConfig,
+  deps: ProverCoordinationDeps,
+): Promise<ProverCoordination> {
+  const log = createLogger('prover-node:prover-coordination');
+
+  const coordinationConfig: CombinedCoordinationOptions = {
+    txGatheringBatchSize: config.txGatheringBatchSize ?? 10,
+    txGatheringMaxParallelRequestsPerNode: config.txGatheringMaxParallelRequestsPerNode ?? 10,
+  };
+
+  if (deps.aztecNodeTxProvider) {
+    log.info('Using prover coordination via aztec node');
+    return new CombinedProverCoordination(undefined, [deps.aztecNodeTxProvider!], coordinationConfig);
+  }
+
+  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');
+    }
+  }
+
+  let nodes: AztecNode[] = [];
+  if (config.proverCoordinationNodeUrls && config.proverCoordinationNodeUrls.length > 0) {
+    log.info('Using prover coordination via node urls');
+    const versions = getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+    nodes = config.proverCoordinationNodeUrls.map(url => {
+      log.info(`Creating aztec node client for prover coordination with url: ${url}`);
+      return createAztecNodeClient(url, versions, makeTracedFetch([1, 2, 3], false));
+    });
+  }
+
+  const proofVerifier = config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier();
+  const p2pClient = await createP2PClient(
+    P2PClientType.Prover,
+    config,
+    deps.archiver,
+    proofVerifier,
+    deps.worldStateSynchronizer,
+    deps.epochCache,
+    getPackageVersion() ?? '',
+    deps.telemetry,
+  );
+  await p2pClient.start();
+
+  return new CombinedProverCoordination(p2pClient, nodes, coordinationConfig);
+}

package/src/prover-coordination/index.ts

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