@aztec/stdlib 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/interfaces/l2_logs_source.ts

@@ -1,54 +1,28 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 
-import type { AztecAddress } from '../aztec-address/index.js';
-import type { LogFilter } from '../logs/log_filter.js';
-import type { SiloedTag } from '../logs/siloed_tag.js';
-import type { Tag } from '../logs/tag.js';
-import type { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
-import type { GetContractClassLogsResponse, GetPublicLogsResponse } from './get_logs_response.js';
+import type { LogResult } from '../logs/log_result.js';
+import type { PrivateLogsQuery, PublicLogsQuery } from '../logs/logs_query.js';
 
 /**
  * Interface of classes allowing for the retrieval of logs.
+ *
+ * The return type is always the widest {@link LogResult} shape (noteHashes/nullifiers optional). To
+ * narrow at the call site after passing `includeEffects: true`, use the typed wrapper functions in
+ * `pxe/src/tagging/get_all_logs_by_tags.ts` (or cast — the wire payload is the widest shape, so a
+ * stricter generic on this interface would not survive the JSON-RPC boundary anyway).
  */
 export interface L2LogsSource {
   /**
-   * Gets private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
-   * array implies no logs match that tag.
-   * @param tags - The tags to search for.
-   * @param page - The page number (0-indexed) for pagination.
-   * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
-   * for a tag, the caller should fetch the next page to check for more logs.
+   * Gets private logs matching the given tags. Returns one inner array per element of `query.tags`, in
+   * input order. An empty inner array means no logs matched that tag.
    */
-  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
+  getPrivateLogsByTags(query: PrivateLogsQuery): Promise<LogResult[][]>;
 
   /**
-   * Gets public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
-   * logs is returned. An empty array implies no logs match that tag.
-   * @param contractAddress - The contract address to search logs for.
-   * @param tags - The tags to search for.
-   * @param page - The page number (0-indexed) for pagination.
-   * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
-   * for a tag, the caller should fetch the next page to check for more logs.
+   * Gets public logs matching the given tags for the given contract. Returns one inner array per element
+   * of `query.tags`, in input order. An empty inner array means no logs matched that tag.
    */
-  getPublicLogsByTagsFromContract(
-    contractAddress: AztecAddress,
-    tags: Tag[],
-    page?: number,
-  ): Promise<TxScopedL2Log[][]>;
-
-  /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse>;
-
-  /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse>;
+  getPublicLogsByTags(query: PublicLogsQuery): Promise<LogResult[][]>;
 
   /**
    * Gets the number of the latest L2 block processed by the implementation.

package/src/interfaces/merkle_tree_operations.ts

@@ -3,6 +3,7 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 
+import type { BlockHash } from '../block/block_hash.js';
 import type { MerkleTreeId, TreeHeights } from '../trees/merkle_tree_id.js';
 import type { NullifierLeaf } from '../trees/nullifier_leaf.js';
 import type { PublicDataTreeLeaf } from '../trees/public_data_leaf.js';
@@ -99,7 +100,7 @@ type LeafTypes = {
   [MerkleTreeId.NOTE_HASH_TREE]: Fr;
   [MerkleTreeId.PUBLIC_DATA_TREE]: Buffer;
   [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: Fr;
-  [MerkleTreeId.ARCHIVE]: Fr;
+  [MerkleTreeId.ARCHIVE]: BlockHash;
 };
 
 type LeafValueTypes = {
@@ -107,7 +108,7 @@ type LeafValueTypes = {
   [MerkleTreeId.NOTE_HASH_TREE]: Fr;
   [MerkleTreeId.PUBLIC_DATA_TREE]: PublicDataTreeLeaf;
   [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: Fr;
-  [MerkleTreeId.ARCHIVE]: Fr;
+  [MerkleTreeId.ARCHIVE]: BlockHash;
 };
 
 export type MerkleTreeLeafType<ID extends MerkleTreeId> = LeafTypes[ID];
@@ -225,36 +226,26 @@ export interface MerkleTreeReadOperations {
 }
 
 export interface MerkleTreeCheckpointOperations {
-  /**
-   * Checkpoints the current fork state
-   */
-  createCheckpoint(): Promise<void>;
+  /** Checkpoints the current fork state. Returns the depth of the new checkpoint. */
+  createCheckpoint(): Promise<number>;
 
-  /**
-   * Commits the current checkpoint
-   */
+  /** Commits the current checkpoint. */
   commitCheckpoint(): Promise<void>;
 
-  /**
-   * Reverts the current checkpoint
-   */
+  /** Reverts the current checkpoint. */
   revertCheckpoint(): Promise<void>;
 
-  /**
-   * Commits all checkpoints
-   */
-  commitAllCheckpoints(): Promise<void>;
+  /** Commits all checkpoints above the given depth, leaving checkpoint depth at the given value. */
+  commitAllCheckpointsTo(depth: number): Promise<void>;
 
-  /**
-   * Reverts all checkpoints
-   */
-  revertAllCheckpoints(): Promise<void>;
+  /** Reverts all checkpoints above the given depth, leaving checkpoint depth at the given value. */
+  revertAllCheckpointsTo(depth: number): Promise<void>;
 }
 
 export interface MerkleTreeWriteOperations
   extends MerkleTreeReadOperations,
     MerkleTreeCheckpointOperations,
-    Disposable {
+    AsyncDisposable {
   /**
    * Appends leaves to a given tree.
    * @param treeId - The tree to be updated.

package/src/interfaces/p2p-bootstrap.ts

@@ -16,6 +16,6 @@ export interface P2PBootstrapApi {
 }
 
 export const P2PBootstrapApiSchema: ApiSchemaFor<P2PBootstrapApi> = {
-  getEncodedEnr: z.function().returns(z.string()),
-  getRoutingTable: z.function().returns(z.array(z.string())),
+  getEncodedEnr: z.function({ input: z.tuple([]), output: z.string() }),
+  getRoutingTable: z.function({ input: z.tuple([]), output: z.array(z.string()) }),
 };

package/src/interfaces/p2p.ts

@@ -1,20 +1,23 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import { BlockProposal } from '../p2p/block_proposal.js';
 import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
-import type { P2PClientType } from '../p2p/client_type.js';
+import { CheckpointProposal, type CheckpointProposalCore } from '../p2p/checkpoint_proposal.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
 import { TxHash } from '../tx/tx_hash.js';
 import { MAX_RPC_TXS_LEN } from './api_limit.js';
+import { type GetTxByHashOptions, GetTxByHashOptionsSchema } from './get_tx_by_hash_options.js';
 
 export type PeerInfo =
   | { status: 'connected'; score: number; id: string }
   | { status: 'dialing'; dialStatus: string; id: string; addresses: string[] }
   | { status: 'cached'; id: string; addresses: string[]; enr: string; dialAttempts: number };
 
-const PeerInfoSchema = z.discriminatedUnion('status', [
+export const PeerInfoSchema = z.discriminatedUnion('status', [
   z.object({ status: z.literal('connected'), score: z.number(), id: z.string() }),
   z.object({ status: z.literal('dialing'), dialStatus: z.string(), id: z.string(), addresses: z.array(z.string()) }),
   z.object({
@@ -26,15 +29,30 @@ const PeerInfoSchema = z.discriminatedUnion('status', [
   }),
 ]);
 
+/** Connectivity of the p2p stack: whether it is enabled at all, and how many peers are currently connected. */
+export type P2PConnectivity = {
+  /** False when the node runs without a p2p stack (eg sandbox or single-node setups). */
+  enabled: boolean;
+  /** Number of peers currently connected. Always zero when p2p is disabled. */
+  connectedPeers: number;
+};
+
+export const P2PConnectivitySchema = z.object({
+  enabled: z.boolean(),
+  connectedPeers: z.number(),
+});
+
 /** Exposed API to the P2P module. */
-export interface P2PApiWithoutAttestations {
+export interface P2PApi {
   /**
-   * Returns all pending transactions in the transaction pool.
+   * Returns all pending transactions in the transaction pool. The txs' proofs are stripped unless
+   * `includeProof` is set.
    * @param limit - The number of items to returns
    * @param after - The last known pending tx. Used for pagination
+   * @param options - Options for the returned txs (eg whether to include their proofs).
    * @returns An array of Txs.
    */
-  getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]>;
+  getPendingTxs(limit?: number, after?: TxHash, options?: GetTxByHashOptions): Promise<Tx[]>;
 
   /** Returns the number of pending txs in the p2p tx pool. */
   getPendingTxCount(): Promise<number>;
@@ -48,43 +66,75 @@ export interface P2PApiWithoutAttestations {
    * Returns info for all connected, dialing, and cached peers.
    */
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
-}
 
-export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
-   * Queries the Attestation pool for checkpoint attestations for the given slot
+   * Returns whether the p2p stack is enabled on this node, and the number of peers it is connected to.
+   * Nodes running without p2p report `enabled: false`, so consumers can tell a disabled stack apart from a
+   * stack that is enabled but has no peers.
+   */
+  getP2PConnectivity(): Promise<P2PConnectivity>;
+
+  /**
+   * Queries the Attestation pool for checkpoint attestations for the given slot.
    *
    * @param slot - the slot to query
-   * @param proposalId - the proposal id to query, or undefined to query all proposals for the slot
+   * @param proposalPayloadHash - hex-encoded keccak256 of the target proposal's signed
+   *        payload (`CheckpointProposal.getPayloadHash()`). When provided, only
+   *        attestations whose own signed payload hashes to the same value are returned.
+   *        When omitted, all attestations for the slot are returned.
    * @returns CheckpointAttestations
    */
-  getCheckpointAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<CheckpointAttestation[]>;
+  getCheckpointAttestationsForSlot(
+    slot: SlotNumber,
+    proposalPayloadHash?: CheckpointProposalHash,
+  ): Promise<CheckpointAttestation[]>;
 }
 
-export interface P2PClient extends P2PApiWithAttestations {
+export type ProposalsForSlot = {
+  blockProposals: BlockProposal[];
+  checkpointProposals: CheckpointProposalCore[];
+};
+
+export interface P2PClient extends P2PApi {
   /** Manually adds checkpoint attestations to the p2p client attestation pool. */
   addOwnCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
+
+  /** Returns retained signed proposals for a slot. */
+  getProposalsForSlot(slot: SlotNumber): Promise<ProposalsForSlot>;
+
+  /** Returns whether a checkpoint proposal was retained for a slot. */
+  hasCheckpointProposalForSlot(slot: SlotNumber): Promise<boolean>;
 }
 
-export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PApiWithAttestations
-  : P2PApiWithoutAttestations;
+const MAX_PROPOSALS_FOR_SLOT_RPC_LEN = 256;
+
+export const BlockProposalSchema = bufferSchemaFor(BlockProposal);
+export const CheckpointProposalSchema = bufferSchemaFor(CheckpointProposal);
 
-export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PApiWithAttestations & P2PClient
-  : P2PApiWithoutAttestations;
+export const ProposalsForSlotSchema = z.object({
+  blockProposals: z.array(BlockProposalSchema).max(MAX_PROPOSALS_FOR_SLOT_RPC_LEN),
+  checkpointProposals: z.array(CheckpointProposalSchema).max(MAX_PROPOSALS_FOR_SLOT_RPC_LEN),
+});
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
-  getCheckpointAttestationsForSlot: z
-    .function()
-    .args(schemas.SlotNumber, optional(z.string()))
-    .returns(z.array(CheckpointAttestation.schema)),
-  getPendingTxs: z
-    .function()
-    .args(optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)), optional(TxHash.schema))
-    .returns(z.array(Tx.schema)),
-
-  getPendingTxCount: z.function().returns(schemas.Integer),
-  getEncodedEnr: z.function().returns(z.string().optional()),
-  getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
+  getCheckpointAttestationsForSlot: z.function({
+    input: z.tuple([
+      schemas.SlotNumber,
+      optional(z.string().regex(/^0x[0-9a-fA-F]+$/) as unknown as z.ZodType<CheckpointProposalHash>),
+    ]),
+    output: z.array(CheckpointAttestation.schema),
+  }),
+  getPendingTxs: z.function({
+    input: z.tuple([
+      optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)),
+      optional(TxHash.schema),
+      optional(GetTxByHashOptionsSchema),
+    ]),
+    output: z.array(Tx.schema),
+  }),
+
+  getPendingTxCount: z.function({ input: z.tuple([]), output: schemas.Integer }),
+  getEncodedEnr: z.function({ input: z.tuple([]), output: z.string().optional() }),
+  getPeers: z.function({ input: z.tuple([optional(z.boolean())]), output: z.array(PeerInfoSchema) }),
+  getP2PConnectivity: z.function({ input: z.tuple([]), output: P2PConnectivitySchema }),
 };

package/src/interfaces/private_kernel_prover.ts

@@ -3,11 +3,15 @@ import type {
   HidingKernelToRollupPrivateInputs,
   PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
+  PrivateKernelInit2CircuitPrivateInputs,
+  PrivateKernelInit3CircuitPrivateInputs,
   PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInner2CircuitPrivateInputs,
+  PrivateKernelInner3CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelResetTailCircuitPrivateInputs,
   PrivateKernelSimulateOutput,
-  PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
 import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
@@ -37,6 +41,48 @@ export interface PrivateKernelProver {
     privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
+  /**
+   * Creates a proof output for a batched first iteration that processes two app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInit2 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInit2Output(
+    privateKernelInputsInit2: PrivateKernelInit2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched first kernel iteration (two app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInit2 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInit2(
+    privateKernelInputsInit2: PrivateKernelInit2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a batched first iteration that processes three app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInit3 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInit3Output(
+    privateKernelInputsInit3: PrivateKernelInit3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched first kernel iteration (three app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInit3 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInit3(
+    privateKernelInputsInit3: PrivateKernelInit3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
   /**
    * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
    *
@@ -57,6 +103,48 @@ export interface PrivateKernelProver {
     privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
+  /**
+   * Creates a proof output for a batched inner iteration that processes two app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInner2 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInner2Output(
+    privateKernelInputsInner2: PrivateKernelInner2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched inner kernel iteration (two app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInner2 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInner2(
+    privateKernelInputsInner2: PrivateKernelInner2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a batched inner iteration that processes three app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInner3 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInner3Output(
+    privateKernelInputsInner3: PrivateKernelInner3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched inner kernel iteration (three app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInner3 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInner3(
+    privateKernelInputsInner3: PrivateKernelInner3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
   /**
    * Creates a proof output by resetting the arrays using the reset circuit.
    *
@@ -78,23 +166,21 @@ export interface PrivateKernelProver {
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
   /**
-   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   * Creates a proof output for the terminal reset+tail step. Dispatches to the rollup-bound or
+   * public-bound family based on `inputs.isForPublic()`.
    *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   * @param privateKernelInputs - Reset hints, dimensions, and tail params.
+   * @returns A Promise resolving to a ProofOutput containing the tail-shaped public inputs.
    */
-  generateTailOutput(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  generateResetTailOutput(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   /**
-   * Executes the final ordering iteration circuit.
-   *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs an empty kernel proof.
+   * Simulates the terminal reset+tail step without generating a proof.
    */
-  simulateTail(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  simulateResetTail(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   generateHidingToRollupOutput(

package/src/interfaces/prover-agent.ts

@@ -15,5 +15,5 @@ export interface ProverAgentApi {
 }
 
 export const ProverAgentApiSchema: ApiSchemaFor<ProverAgentApi> = {
-  getStatus: z.function().args().returns(ProverAgentStatusSchema),
+  getStatus: z.function({ input: z.tuple([]), output: ProverAgentStatusSchema }),
 };

package/src/interfaces/prover-client.ts

@@ -5,7 +5,6 @@ import { z } from 'zod';
 
 import { schemas, zodFor } from '../schemas/index.js';
 import type { TxHash } from '../tx/tx_hash.js';
-import type { EpochProver } from './epoch-prover.js';
 import type { ProvingJobConsumer } from './prover-broker.js';
 
 export type ActualProverConfig = {
@@ -23,6 +22,8 @@ export type ActualProverConfig = {
    * When true, jobs are explicitly cancelled with the broker, which prevents reuse.
    */
   cancelJobsOnStop: boolean;
+  /** Max concurrent jobs the orchestrator serializes and enqueues to the broker. */
+  enqueueConcurrency: number;
 };
 
 /**
@@ -53,6 +54,7 @@ export const ProverConfigSchema = zodFor<ProverConfig>()(
     proofStore: z.string().optional(),
     failedProofStore: z.string().optional(),
     cancelJobsOnStop: z.boolean(),
+    enqueueConcurrency: z.number(),
   }),
 );
 
@@ -68,7 +70,7 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   },
   proverId: {
     env: 'PROVER_ID',
-    parseEnv: (val?: string) => parseProverId(val),
+    parseEnv: (val: string) => parseProverId(val),
     description: 'Hex value that identifies the prover. Defaults to the address used for submitting proofs if not set.',
   },
   proverTestDelayType: {
@@ -107,22 +109,23 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
       'When true, jobs are explicitly cancelled with the broker, which prevents reuse.',
     ...booleanConfigHelper(false),
   },
+  enqueueConcurrency: {
+    env: 'PROVER_ENQUEUE_CONCURRENCY',
+    description: 'Max concurrent jobs the orchestrator serializes and enqueues to the broker.',
+    ...numberConfigHelper(50),
+  },
 };
 
-function parseProverId(str?: string) {
-  if (!str) {
-    return undefined;
-  }
+function parseProverId(str: string) {
   return EthAddress.fromString(str);
 }
 
 /**
  * The interface to the prover client.
  * Provides the ability to generate proofs and build rollups.
+ *
  */
 export interface EpochProverManager {
-  createEpochProver(): EpochProver;
-
   start(): Promise<void>;
 
   stop(): Promise<void>;

package/src/interfaces/prover-node.ts

@@ -1,54 +1,69 @@
+import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+
 import { z } from 'zod';
 
-import { type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
 import { type ApiSchemaFor, schemas } from '../schemas/index.js';
-import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_state.js';
+import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 
 const EpochProvingJobState = [
   'initialized',
-  'processing',
-  'awaiting-prover',
+  'awaiting-checkpoints',
+  'awaiting-root',
+  'awaiting-predecessor',
   'publishing-proof',
   'completed',
+  'superseded',
   'failed',
   'stopped',
+  'cancelled',
   'timed-out',
-  'reorg',
 ] as const;
 
 export type EpochProvingJobState = (typeof EpochProvingJobState)[number];
 
 export const EpochProvingJobTerminalState: EpochProvingJobState[] = [
   'completed',
+  'superseded',
   'failed',
   'stopped',
+  'cancelled',
   'timed-out',
-  'reorg',
 ] as const;
 
 export type EpochProvingJobTerminalState = (typeof EpochProvingJobTerminalState)[number];
 
-/** JSON RPC public interface to a prover node. */
+/** JSON RPC admin interface to a prover node. */
 export interface ProverNodeApi {
   getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]>;
 
-  startProof(epochNumber: number): Promise<void>;
-
-  getL2Tips(): Promise<L2Tips>;
-
-  getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
+  /**
+   * Schedules proving for the given epoch and returns the job id immediately, without waiting for
+   * the proof to complete (proving can take far longer than an HTTP request). Poll `getJobs()` to
+   * track the returned job's progress.
+   */
+  startProof(epochNumber: number): Promise<string>;
 }
 
 /** Schemas for prover node API functions. */
 export const ProverNodeApiSchema: ApiSchemaFor<ProverNodeApi> = {
-  getJobs: z
-    .function()
-    .args()
-    .returns(z.array(z.object({ uuid: z.string(), status: z.enum(EpochProvingJobState), epochNumber: z.number() }))),
-
-  startProof: z.function().args(schemas.Integer).returns(z.void()),
+  getJobs: z.function({
+    input: z.tuple([]),
+    output: z.array(z.object({ uuid: z.string(), status: z.enum(EpochProvingJobState), epochNumber: z.number() })),
+  }),
 
-  getL2Tips: z.function().args().returns(L2TipsSchema),
-
-  getWorldStateSyncStatus: z.function().args().returns(WorldStateSyncStatusSchema),
+  startProof: z.function({ input: z.tuple([schemas.Integer]), output: z.string() }),
 };
+
+export function createProverNodeAdminClient(
+  url: string,
+  versions: Partial<ComponentsVersions> = {},
+  fetch = defaultFetch,
+  apiKey?: string,
+): ProverNodeApi {
+  return createSafeJsonRpcClient<ProverNodeApi>(url, ProverNodeApiSchema, {
+    namespaceMethods: 'prover',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+    ...(apiKey ? { extraHeaders: { 'x-api-key': apiKey } } : {}),
+  });
+}

package/src/interfaces/proving-job-source.ts

@@ -33,8 +33,8 @@ export interface ProvingJobSource {
 }
 
 export const ProvingJobSourceSchema: ApiSchemaFor<ProvingJobSource> = {
-  getProvingJob: z.function().args().returns(ProvingJob.optional()),
-  heartbeat: z.function().args(ProvingJobId).returns(z.void()),
-  resolveProvingJob: z.function().args(ProvingJobId, ProvingJobResult).returns(z.void()),
-  rejectProvingJob: z.function().args(ProvingJobId, z.string()).returns(z.void()),
+  getProvingJob: z.function({ input: z.tuple([]), output: ProvingJob.optional() }),
+  heartbeat: z.function({ input: z.tuple([ProvingJobId]), output: z.void() }),
+  resolveProvingJob: z.function({ input: z.tuple([ProvingJobId, ProvingJobResult]), output: z.void() }),
+  rejectProvingJob: z.function({ input: z.tuple([ProvingJobId, z.string()]), output: z.void() }),
 };