feat(prover-client): existing prover agents handle BLOCK_EXECUTION via a composite prover

Drops the separate `InternalExecutionAgents` agent pool added in Issue 7 and
replaces it with a single composite `ServerCircuitProver` shared by the
existing prover-client agents. One agent count, one polling loop, one allowlist
— the broker hands jobs to whichever agent is free and the composite dispatches
internally:

- Proving methods (`getAvmProof`, `getPrivateTxBaseRollupProof`, parity, merge,
  block-root, etc.) delegate to the regular prover (`BBNativeRollupProver` or
  `TestCircuitProver`).
- `executeBlock` delegates to a `BlockExecutionHandler` instance constructed
  against the supplied world state, public processor factory and tx fetcher.

Wiring:

- `ProverClient.new(...)` and `createProverClient(...)` take an optional
  `ProverClientBlockExecutionDeps` (`publicProcessorFactory + txFetcher`).
  When supplied, every agent gets the composite. When absent, agents stay
  proving-only and `executeBlock` rejects.
- The prover node factory now always supplies these deps (it has every
  ingredient already — archiver, world state synchronizer, p2p client). No
  new config switch — execution capability is automatic when the prover
  node has the prerequisites.
- `proverAgentCount` continues to control the agent count. There is no
  second pool.

Removes:
- `InternalExecutionAgents` class + its test.
- `proverNodeExecutionAgentCount` / `proverNodeExecutionAgentPollIntervalMs`
  config and the matching env vars.
- The optional `internalExecutionAgents` constructor arg on `ProverNode` and
  the corresponding start/stop calls.

Adds a small unit test exercising the composite's dispatch behaviour.

Author: PhilWindle

yarn-project/foundation/src/config/env_var.ts

@@ -187,8 +187,6 @@ export type EnvVar =
   | 'PROVER_NODE_TX_GATHERING_BATCH_SIZE'
   | 'PROVER_NODE_TX_GATHERING_MAX_PARALLEL_REQUESTS_PER_NODE'
   | 'PROVER_NODE_TX_GATHERING_TIMEOUT_MS'
-  | 'PROVER_NODE_EXECUTION_AGENT_COUNT'
-  | 'PROVER_NODE_EXECUTION_AGENT_POLL_INTERVAL_MS'
   | 'PROVER_PUBLISHER_PRIVATE_KEY'
   | 'PROVER_PUBLISHER_PRIVATE_KEYS'
   | 'PROVER_PUBLISHER_ADDRESSES'

yarn-project/prover-client/src/block_execution/composite_circuit_prover.test.ts

@@ -0,0 +1,69 @@
+import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+
+import { jest } from '@jest/globals';
+import { type MockProxy, mock } from 'jest-mock-extended';
+
+import { CompositeServerCircuitProver } from './composite_circuit_prover.js';
+
+describe('CompositeServerCircuitProver', () => {
+  let base: MockProxy<ServerCircuitProver>;
+  let execution: MockProxy<ServerCircuitProver>;
+  let composite: CompositeServerCircuitProver;
+
+  beforeEach(() => {
+    base = mock<ServerCircuitProver>();
+    execution = mock<ServerCircuitProver>();
+    composite = new CompositeServerCircuitProver(base, execution);
+  });
+
+  it('routes proving methods to the base prover', async () => {
+    base.getAvmProof.mockResolvedValue('avm' as unknown as Awaited<ReturnType<ServerCircuitProver['getAvmProof']>>);
+    base.getBaseParityProof.mockResolvedValue(
+      'parity' as unknown as Awaited<ReturnType<ServerCircuitProver['getBaseParityProof']>>,
+    );
+
+    await composite.getAvmProof({} as any);
+    await composite.getBaseParityProof({} as any);
+
+    expect(base.getAvmProof).toHaveBeenCalledTimes(1);
+    expect(base.getBaseParityProof).toHaveBeenCalledTimes(1);
+    expect(execution.getAvmProof).not.toHaveBeenCalled();
+    expect(execution.getBaseParityProof).not.toHaveBeenCalled();
+  });
+
+  it('routes executeBlock to the execution prover', async () => {
+    execution.executeBlock.mockResolvedValue(
+      'block-execution-result' as unknown as Awaited<ReturnType<ServerCircuitProver['executeBlock']>>,
+    );
+
+    await composite.executeBlock({} as any);
+
+    expect(execution.executeBlock).toHaveBeenCalledTimes(1);
+    expect(base.executeBlock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the base prover for executeBlock when no execution prover is supplied', async () => {
+    const fallback = new CompositeServerCircuitProver(base);
+    base.executeBlock.mockRejectedValue(new Error('not supported'));
+
+    await expect(fallback.executeBlock({} as any)).rejects.toThrow(/not supported/);
+    expect(base.executeBlock).toHaveBeenCalledTimes(1);
+  });
+
+  it('preserves rejection from the underlying prover', async () => {
+    base.getRootRollupProof.mockRejectedValue(new Error('boom'));
+
+    await expect(composite.getRootRollupProof({} as any)).rejects.toThrow('boom');
+  });
+
+  it('forwards multiple arguments through to the underlying prover', async () => {
+    base.getAvmProof.mockResolvedValue('avm' as any);
+
+    const inputs = {} as any;
+    const signal = new AbortController().signal;
+    const epochNumber = 5;
+    await composite.getAvmProof(inputs, signal, epochNumber);
+
+    expect(base.getAvmProof).toHaveBeenCalledWith(inputs, signal, epochNumber);
+  });
+});

yarn-project/prover-client/src/block_execution/composite_circuit_prover.ts

@@ -0,0 +1,60 @@
+import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+
+/**
+ * `ServerCircuitProver` that composes a "base" prover for circuit-proving methods
+ * with an execution prover for `executeBlock`. Used so a single `ProvingAgent`
+ * can take any kind of job from the broker — proving jobs route to the base
+ * prover, `BLOCK_EXECUTION` jobs route to the execution handler.
+ *
+ * Every method other than `executeBlock` delegates to the base prover. If the
+ * caller does not provide an execution prover, `executeBlock` falls back to the
+ * base prover (which rejects).
+ */
+export class CompositeServerCircuitProver implements ServerCircuitProver {
+  constructor(
+    private readonly base: ServerCircuitProver,
+    private readonly execution: ServerCircuitProver = base,
+  ) {}
+
+  // --- Proving methods: delegate to base ---
+  public getBaseParityProof: ServerCircuitProver['getBaseParityProof'] = (...args) =>
+    this.base.getBaseParityProof(...args);
+  public getRootParityProof: ServerCircuitProver['getRootParityProof'] = (...args) =>
+    this.base.getRootParityProof(...args);
+  public getPublicChonkVerifierProof: ServerCircuitProver['getPublicChonkVerifierProof'] = (...args) =>
+    this.base.getPublicChonkVerifierProof(...args);
+  public getPrivateTxBaseRollupProof: ServerCircuitProver['getPrivateTxBaseRollupProof'] = (...args) =>
+    this.base.getPrivateTxBaseRollupProof(...args);
+  public getPublicTxBaseRollupProof: ServerCircuitProver['getPublicTxBaseRollupProof'] = (...args) =>
+    this.base.getPublicTxBaseRollupProof(...args);
+  public getTxMergeRollupProof: ServerCircuitProver['getTxMergeRollupProof'] = (...args) =>
+    this.base.getTxMergeRollupProof(...args);
+  public getBlockRootFirstRollupProof: ServerCircuitProver['getBlockRootFirstRollupProof'] = (...args) =>
+    this.base.getBlockRootFirstRollupProof(...args);
+  public getBlockRootSingleTxFirstRollupProof: ServerCircuitProver['getBlockRootSingleTxFirstRollupProof'] = (
+    ...args
+  ) => this.base.getBlockRootSingleTxFirstRollupProof(...args);
+  public getBlockRootEmptyTxFirstRollupProof: ServerCircuitProver['getBlockRootEmptyTxFirstRollupProof'] = (...args) =>
+    this.base.getBlockRootEmptyTxFirstRollupProof(...args);
+  public getBlockRootRollupProof: ServerCircuitProver['getBlockRootRollupProof'] = (...args) =>
+    this.base.getBlockRootRollupProof(...args);
+  public getBlockRootSingleTxRollupProof: ServerCircuitProver['getBlockRootSingleTxRollupProof'] = (...args) =>
+    this.base.getBlockRootSingleTxRollupProof(...args);
+  public getBlockMergeRollupProof: ServerCircuitProver['getBlockMergeRollupProof'] = (...args) =>
+    this.base.getBlockMergeRollupProof(...args);
+  public getCheckpointRootRollupProof: ServerCircuitProver['getCheckpointRootRollupProof'] = (...args) =>
+    this.base.getCheckpointRootRollupProof(...args);
+  public getCheckpointRootSingleBlockRollupProof: ServerCircuitProver['getCheckpointRootSingleBlockRollupProof'] = (
+    ...args
+  ) => this.base.getCheckpointRootSingleBlockRollupProof(...args);
+  public getCheckpointPaddingRollupProof: ServerCircuitProver['getCheckpointPaddingRollupProof'] = (...args) =>
+    this.base.getCheckpointPaddingRollupProof(...args);
+  public getCheckpointMergeRollupProof: ServerCircuitProver['getCheckpointMergeRollupProof'] = (...args) =>
+    this.base.getCheckpointMergeRollupProof(...args);
+  public getRootRollupProof: ServerCircuitProver['getRootRollupProof'] = (...args) =>
+    this.base.getRootRollupProof(...args);
+  public getAvmProof: ServerCircuitProver['getAvmProof'] = (...args) => this.base.getAvmProof(...args);
+
+  // --- Block execution: delegate to execution prover ---
+  public executeBlock: ServerCircuitProver['executeBlock'] = (...args) => this.execution.executeBlock(...args);
+}

yarn-project/prover-client/src/block_execution/index.ts

@@ -1,2 +1,17 @@
+import type { PublicProcessorFactory } from '@aztec/simulator/server';
+
+import type { TxFetcher } from './block_execution_handler.js';
+
 export { BlockExecutionHandler, type TxFetcher } from './block_execution_handler.js';
-export { InternalExecutionAgents, type InternalExecutionAgentsConfig } from './internal_execution_agents.js';
+export { CompositeServerCircuitProver } from './composite_circuit_prover.js';
+
+/**
+ * Optional dependencies the prover-client needs to run BLOCK_EXECUTION jobs in its
+ * agents. When provided, every agent the prover-client spins up gets a composite
+ * `ServerCircuitProver` that handles BLOCK_EXECUTION via a `BlockExecutionHandler`
+ * and routes everything else to the regular proving prover.
+ */
+export type ProverClientBlockExecutionDeps = {
+  publicProcessorFactory: PublicProcessorFactory;
+  txFetcher: TxFetcher;
+};

yarn-project/prover-client/src/block_execution/internal_execution_agents.test.ts

@@ -5,6 +5,7 @@ import type {
 } from '@aztec/stdlib/interfaces/server';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import type { ProverClientBlockExecutionDeps } from '../block_execution/index.js';
 import type { ProverClientConfig } from '../config.js';
 import { ProverClient } from './prover-client.js';
 
@@ -13,6 +14,7 @@ export function createProverClient(
   worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
   broker: ProvingJobBroker,
   telemetry: TelemetryClient = getTelemetryClient(),
+  blockExecutionDeps?: ProverClientBlockExecutionDeps,
 ) {
-  return ProverClient.new(config, worldState, broker, telemetry);
+  return ProverClient.new(config, worldState, broker, telemetry, blockExecutionDeps);
 }