@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/interfaces/private_kernel_prover.ts

@@ -1,6 +1,7 @@
-import type { WitnessMap } from '@noir-lang/acvm_js';
-
 import type {
+  HidingKernelToPublicPrivateInputs,
+  HidingKernelToRollupPrivateInputs,
+  PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
@@ -9,7 +10,7 @@ import type {
   PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
 
 /**
  * PrivateKernelProver provides functionality to simulate and validate circuits, and retrieve
@@ -96,12 +97,20 @@ export interface PrivateKernelProver {
     privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
+  generateHidingToRollupOutput(
+    inputs: HidingKernelToRollupPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+
+  generateHidingToPublicOutput(
+    inputs: HidingKernelToPublicPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+
   /**
    * Based of a program stack, create a folding proof.
    * @param acirs The program bytecode.
    * @param witnessStack The witnessses for each program bytecode.
    */
-  createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
+  createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
 
   /**
    * Compute the gate count for a given circuit.

package/src/interfaces/prover-agent.ts

@@ -2,19 +2,18 @@ import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/index.js';
 
-export interface ProverAgentApi {
-  setMaxConcurrency(maxConcurrency: number): Promise<void>;
+export const ProverAgentStatusSchema = z.discriminatedUnion('status', [
+  z.object({ status: z.literal('stopped') }),
+  z.object({ status: z.literal('running') }),
+  z.object({ status: z.literal('proving'), jobId: z.string(), proofType: z.number(), startedAtISO: z.string() }),
+]);
 
-  isRunning(): Promise<boolean>;
+export type ProverAgentStatus = z.infer<typeof ProverAgentStatusSchema>;
 
-  getCurrentJobs(): Promise<{ id: string; type: string }[]>;
+export interface ProverAgentApi {
+  getStatus(): Promise<unknown>;
 }
 
 export const ProverAgentApiSchema: ApiSchemaFor<ProverAgentApi> = {
-  setMaxConcurrency: z.function().args(z.number().min(1).int()).returns(z.void()),
-  isRunning: z.function().args().returns(z.boolean()),
-  getCurrentJobs: z
-    .function()
-    .args()
-    .returns(z.array(z.object({ id: z.string(), type: z.string() }))),
+  getStatus: z.function().args().returns(ProverAgentStatusSchema),
 };

package/src/interfaces/prover-client.ts

@@ -1,9 +1,9 @@
 import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
+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';
@@ -17,6 +17,12 @@ export type ActualProverConfig = {
   proverTestDelayMs: number;
   /** If using realistic delays, what percentage of realistic times to apply. */
   proverTestDelayFactor: number;
+  /**
+   * Whether to abort pending proving jobs when the orchestrator is cancelled.
+   * When false (default), jobs remain in the broker queue and can be reused on restart/reorg.
+   * When true, jobs are explicitly cancelled with the broker, which prevents reuse.
+   */
+  cancelJobsOnStop: boolean;
 };
 
 /**
@@ -26,22 +32,26 @@ export type ProverConfig = ActualProverConfig & {
   /** The URL to the Aztec node to take proving jobs from */
   nodeUrl?: string;
   /** Identifier of the prover */
-  proverId: Fr;
+  proverId?: EthAddress;
   /** Number of proving agents to start within the prover. */
   proverAgentCount: number;
   /** Store for failed proof inputs. */
   failedProofStore?: string;
 };
 
-export const ProverConfigSchema = z.object({
-  nodeUrl: z.string().optional(),
-  realProofs: z.boolean(),
-  proverId: schemas.Fr,
-  proverTestDelayType: z.enum(['fixed', 'realistic']),
-  proverTestDelayMs: z.number(),
-  proverTestDelayFactor: z.number(),
-  proverAgentCount: z.number(),
-}) satisfies ZodFor<ProverConfig>;
+export const ProverConfigSchema = zodFor<ProverConfig>()(
+  z.object({
+    nodeUrl: z.string().optional(),
+    realProofs: z.boolean(),
+    proverId: schemas.EthAddress.optional(),
+    proverTestDelayType: z.enum(['fixed', 'realistic']),
+    proverTestDelayMs: z.number(),
+    proverTestDelayFactor: z.number(),
+    proverAgentCount: z.number(),
+    failedProofStore: z.string().optional(),
+    cancelJobsOnStop: z.boolean(),
+  }),
+);
 
 export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   nodeUrl: {
@@ -51,13 +61,12 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   realProofs: {
     env: 'PROVER_REAL_PROOFS',
     description: 'Whether to construct real proofs',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(true),
   },
   proverId: {
     env: 'PROVER_ID',
-    parseEnv: (val: string) => parseProverId(val),
-    description: 'Identifier of the prover',
-    defaultValue: Fr.ZERO,
+    parseEnv: (val?: string) => parseProverId(val),
+    description: 'Hex value that identifies the prover. Defaults to the address used for submitting proofs if not set.',
   },
   proverTestDelayType: {
     env: 'PROVER_TEST_DELAY_TYPE',
@@ -83,10 +92,21 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
     description:
       'Store for failed proof inputs. Google cloud storage is only supported at the moment. Set this value as gs://bucket-name/path/to/store.',
   },
+  cancelJobsOnStop: {
+    env: 'PROVER_CANCEL_JOBS_ON_STOP',
+    description:
+      'Whether to abort pending proving jobs when the orchestrator is cancelled. ' +
+      'When false (default), jobs remain in the broker queue and can be reused on restart/reorg. ' +
+      'When true, jobs are explicitly cancelled with the broker, which prevents reuse.',
+    ...booleanConfigHelper(false),
+  },
 };
 
-function parseProverId(str: string) {
-  return Fr.fromHexString(str.startsWith('0x') ? str : Buffer.from(str, 'utf8').toString('hex'));
+function parseProverId(str?: string) {
+  if (!str) {
+    return undefined;
+  }
+  return EthAddress.fromString(str);
 }
 
 /**
@@ -102,7 +122,7 @@ export interface EpochProverManager {
 
   getProvingJobSource(): ProvingJobConsumer;
 
-  getProverId(): Fr;
+  getProverId(): EthAddress;
 
   updateProverConfig(config: Partial<ProverConfig>): Promise<void>;
 }
@@ -111,7 +131,10 @@ export class BlockProofError extends Error {
   static #name = 'BlockProofError';
   override name = BlockProofError.#name;
 
-  constructor(message: string, public readonly txHashes: TxHash[]) {
+  constructor(
+    message: string,
+    public readonly txHashes: TxHash[],
+  ) {
     super(message);
   }
 

package/src/interfaces/prover-coordination.ts

@@ -1,27 +1,17 @@
-import { z } from 'zod';
-
-import type { ApiSchemaFor } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
 import { TxHash } from '../tx/tx_hash.js';
+import type { P2PClient } from './p2p.js';
 
 /** Provides basic operations for ProverNodes to interact with other nodes in the network. */
 export interface ProverCoordination {
-  /**
-   * Returns a transaction given its hash if available.
-   * @param txHash - The hash of the transaction, used as an ID.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
   /**
    * Returns a set of transactions given their hashes if available.
    * @param txHashes - The hashes of the transactions, used as an ID.
-   * @returns The transactions, if found, 'undefined' otherwise.
+   * @returns The transactions found, no necessarily in the same order as the hashes.
    */
   getTxsByHash(txHashes: TxHash[]): Promise<Tx[]>;
-}
 
-export const ProverCoordinationApiSchema: ApiSchemaFor<ProverCoordination> = {
-  getTxByHash: z.function().args(TxHash.schema).returns(Tx.schema.optional()),
-  getTxsByHash: z.function().args(z.array(TxHash.schema)).returns(z.array(Tx.schema)),
-};
+  gatherTxs(txHashes: TxHash[]): Promise<void>;
+
+  getP2PClient(): P2PClient | undefined;
+}

package/src/interfaces/prover-node.ts

@@ -1,6 +1,8 @@
 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';
 
 const EpochProvingJobState = [
   'initialized',
@@ -11,6 +13,7 @@ const EpochProvingJobState = [
   'failed',
   'stopped',
   'timed-out',
+  'reorg',
 ] as const;
 
 export type EpochProvingJobState = (typeof EpochProvingJobState)[number];
@@ -20,6 +23,7 @@ export const EpochProvingJobTerminalState: EpochProvingJobState[] = [
   'failed',
   'stopped',
   'timed-out',
+  'reorg',
 ] as const;
 
 export type EpochProvingJobTerminalState = (typeof EpochProvingJobTerminalState)[number];
@@ -30,7 +34,9 @@ export interface ProverNodeApi {
 
   startProof(epochNumber: number): Promise<void>;
 
-  prove(epochNumber: number): Promise<void>;
+  getL2Tips(): Promise<L2Tips>;
+
+  getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
 }
 
 /** Schemas for prover node API functions. */
@@ -42,5 +48,7 @@ export const ProverNodeApiSchema: ApiSchemaFor<ProverNodeApi> = {
 
   startProof: z.function().args(schemas.Integer).returns(z.void()),
 
-  prove: z.function().args(schemas.Integer).returns(z.void()),
+  getL2Tips: z.function().args().returns(L2TipsSchema),
+
+  getWorldStateSyncStatus: z.function().args().returns(WorldStateSyncStatusSchema),
 };