@aztec-labs/stdlib 6.0.0-nightly.20260829

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+import type { ApiSchemaFor } from '../schemas/index.js';
+import { ProvingJob, ProvingJobId, ProvingJobResult } from './proving-job.js';
+
+export interface ProvingJobSource {
+  /**
+   * Gets the next proving job. `heartbeat` must be called periodically to keep the job alive.
+   * @returns The proving job, or undefined if there are no jobs available.
+   */
+  getProvingJob(): Promise<ProvingJob | undefined>;
+
+  /**
+   * Keeps the job alive. If this isn't called regularly then the job will be
+   * considered abandoned and re-queued for another consumer to pick up
+   * @param jobId The ID of the job to heartbeat.
+   */
+  heartbeat(jobId: string): Promise<void>;
+
+  /**
+   * Resolves a proving job.
+   * @param jobId - The ID of the job to resolve.
+   * @param result - The result of the proving job.
+   */
+  resolveProvingJob(jobId: string, result: ProvingJobResult): Promise<void>;
+
+  /**
+   * Rejects a proving job.
+   * @param jobId - The ID of the job to reject.
+   * @param reason - The reason for rejecting the job.
+   */
+  rejectProvingJob(jobId: string, reason: string): Promise<void>;
+}
+
+export const ProvingJobSourceSchema: ApiSchemaFor<ProvingJobSource> = {
+  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() }),
+};

package/src/interfaces/proving-job.ts

@@ -0,0 +1,417 @@
+import {
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  RECURSIVE_PROOF_LENGTH,
+} from '@aztec-labs/constants';
+import { EpochNumber, EpochNumberSchema } from '@aztec-labs/foundation/branded-types';
+import type { ZodFor } from '@aztec-labs/foundation/schemas';
+import { z } from 'zod';
+
+import { AvmCircuitInputs } from '../avm/avm.js';
+import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
+import { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js';
+import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
+import {
+  BlockRootNoTxsRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+} from '../rollup/block_root_rollup_private_inputs.js';
+import { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
+import { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
+import {
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
+import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
+import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
+import { VerificationKeyData } from '../vks/verification_key.js';
+
+export type ProofAndVerificationKey<N extends number> = {
+  proof: RecursiveProof<N>;
+  verificationKey: VerificationKeyData;
+};
+
+export function makeProofAndVerificationKey<N extends number>(
+  proof: RecursiveProof<N>,
+  verificationKey: VerificationKeyData,
+): ProofAndVerificationKey<N> {
+  return { proof, verificationKey };
+}
+
+export type PublicInputsAndRecursiveProof<T, N extends number = typeof NESTED_RECURSIVE_PROOF_LENGTH> = {
+  inputs: T;
+  proof: RecursiveProof<N>;
+  verificationKey: VerificationKeyData;
+};
+
+function schemaForPublicInputsAndRecursiveProof<T extends object, N extends number>(
+  inputs: ZodFor<T>,
+  proofSize: N,
+): ZodFor<PublicInputsAndRecursiveProof<T, typeof proofSize>> {
+  return z.object({
+    inputs,
+    proof: RecursiveProof.schemaFor(proofSize),
+    verificationKey: VerificationKeyData.schema,
+  }) as ZodFor<PublicInputsAndRecursiveProof<T, N>>;
+}
+
+export function makePublicInputsAndRecursiveProof<T, N extends number = typeof NESTED_RECURSIVE_PROOF_LENGTH>(
+  inputs: T,
+  proof: RecursiveProof<N>,
+  verificationKey: VerificationKeyData,
+): PublicInputsAndRecursiveProof<T, N> {
+  return { inputs, proof, verificationKey };
+}
+
+export const ProvingJobInputs = z.discriminatedUnion('type', [
+  AvmProvingRequestSchema,
+  z.object({ type: z.literal(ProvingRequestType.INBOX_PARITY), inputs: InboxParityPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
+    inputs: PublicChonkVerifierPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+    inputs: PrivateTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+    inputs: PublicTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP), inputs: TxMergeRollupPrivateInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP), inputs: BlockRootRollupPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+    inputs: BlockRootSingleTxRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP),
+    inputs: BlockRootNoTxsRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP), inputs: BlockMergeRollupPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+    inputs: CheckpointRootRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+    inputs: CheckpointRootSingleBlockRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+    inputs: CheckpointPaddingRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+    inputs: CheckpointMergeRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.ROOT_ROLLUP), inputs: RootRollupPrivateInputs.schema }),
+]);
+
+export function getProvingJobInputClassFor(type: ProvingRequestType) {
+  switch (type) {
+    case ProvingRequestType.PUBLIC_VM:
+      return AvmCircuitInputs;
+    case ProvingRequestType.PUBLIC_CHONK_VERIFIER:
+      return PublicChonkVerifierPrivateInputs;
+    case ProvingRequestType.PRIVATE_TX_BASE_ROLLUP:
+      return PrivateTxBaseRollupPrivateInputs;
+    case ProvingRequestType.PUBLIC_TX_BASE_ROLLUP:
+      return PublicTxBaseRollupPrivateInputs;
+    case ProvingRequestType.TX_MERGE_ROLLUP:
+      return TxMergeRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_ROLLUP:
+      return BlockRootRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP:
+      return BlockRootSingleTxRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP:
+      return BlockRootNoTxsRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_MERGE_ROLLUP:
+      return BlockMergeRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP:
+      return CheckpointRootRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP:
+      return CheckpointRootSingleBlockRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_PADDING_ROLLUP:
+      return CheckpointPaddingRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_MERGE_ROLLUP:
+      return CheckpointMergeRollupPrivateInputs;
+    case ProvingRequestType.ROOT_ROLLUP:
+      return RootRollupPrivateInputs;
+    case ProvingRequestType.INBOX_PARITY:
+      return InboxParityPrivateInputs;
+    default: {
+      const _exhaustive: never = type;
+      throw new Error(`Cannot find circuit inputs class for proving type ${type}`);
+    }
+  }
+}
+
+export type ProvingJobInputs = z.infer<typeof ProvingJobInputs>;
+
+export type ProvingJobInputsMap = {
+  [ProvingRequestType.PUBLIC_VM]: AvmCircuitInputs;
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicChonkVerifierPrivateInputs;
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PrivateTxBaseRollupPrivateInputs;
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicTxBaseRollupPrivateInputs;
+  [ProvingRequestType.TX_MERGE_ROLLUP]: TxMergeRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: BlockRootSingleTxRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP]: BlockRootNoTxsRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: CheckpointRootRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: CheckpointRootSingleBlockRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: CheckpointPaddingRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: CheckpointMergeRollupPrivateInputs;
+  [ProvingRequestType.ROOT_ROLLUP]: RootRollupPrivateInputs;
+  [ProvingRequestType.INBOX_PARITY]: InboxParityPrivateInputs;
+};
+
+export const ProvingJobResult = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_VM),
+    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
+    result: schemaForPublicInputsAndRecursiveProof(
+      PublicChonkVerifierPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      TxRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      TxRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      TxRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.ROOT_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(RootRollupPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.INBOX_PARITY),
+    result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, RECURSIVE_PROOF_LENGTH),
+  }),
+]);
+export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
+export type ProvingJobResultsMap = {
+  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
+    PublicChonkVerifierPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.TX_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof<RootRollupPublicInputs>;
+  [ProvingRequestType.INBOX_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
+};
+
+export type ProvingRequestResultFor<T extends ProvingRequestType> = { type: T; result: ProvingJobResultsMap[T] };
+
+export const ProvingJobId = z.string();
+
+export type ProofUri = string & z.$brand<'ProvingJobUri'>;
+export const ProofUri: ZodFor<ProofUri> = z.string().transform(value => value as ProofUri);
+
+export type ProvingJobId = z.infer<typeof ProvingJobId>;
+
+type ProvingJobShape = {
+  id: ProvingJobId;
+  type: ProvingRequestType;
+  epochNumber: EpochNumber;
+  inputsUri: ProofUri;
+};
+
+export const ProvingJob: z.ZodType<ProvingJobShape, any> = z.object({
+  id: ProvingJobId,
+  type: z.nativeEnum(ProvingRequestType),
+  epochNumber: EpochNumberSchema,
+  inputsUri: ProofUri,
+});
+
+export const makeProvingJobId = (epochNumber: EpochNumber, type: ProvingRequestType, inputsHash: string) => {
+  return `${epochNumber}:${ProvingRequestType[type]}:${inputsHash}`;
+};
+
+export const getEpochFromProvingJobId = (id: ProvingJobId): EpochNumber => {
+  const components = id.split(':');
+  const epochNumber = components.length < 1 ? Number.NaN : parseInt(components[0], 10);
+  if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
+    throw new Error(`Proving Job ID ${id} does not contain valid epoch`);
+  }
+  return EpochNumber(epochNumber);
+};
+
+export type ProvingJob = z.infer<typeof ProvingJob>;
+
+export function makeProvingRequestResult(
+  type: ProvingRequestType,
+  result: ProvingJobResult['result'],
+): ProvingJobResult {
+  return { type, result } as ProvingJobResult;
+}
+
+export const ProvingJobFulfilledResult = z.object({
+  status: z.literal('fulfilled'),
+  value: ProofUri,
+});
+export type ProvingJobFulfilledResult = z.infer<typeof ProvingJobFulfilledResult>;
+
+export const ProvingJobRejectedResult = z.object({
+  status: z.literal('rejected'),
+  reason: z.string(),
+});
+export type ProvingJobRejectedResult = z.infer<typeof ProvingJobRejectedResult>;
+
+/**
+ * The result of a job that was cancelled by its producer. Unlike a fulfilled or rejected result it
+ * is not truly terminal: re-enqueuing the same job id revives it, so an abort never permanently
+ * blocks a proof from being produced.
+ */
+export const ProvingJobAbortedResult = z.object({
+  status: z.literal('aborted'),
+});
+export type ProvingJobAbortedResult = z.infer<typeof ProvingJobAbortedResult>;
+
+export const ProvingJobSettledResult = z.discriminatedUnion('status', [
+  ProvingJobFulfilledResult,
+  ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
+]);
+export type ProvingJobSettledResult = z.infer<typeof ProvingJobSettledResult>;
+
+export const ProvingJobStatus = z.discriminatedUnion('status', [
+  z.object({ status: z.literal('in-queue') }),
+  z.object({ status: z.literal('in-progress') }),
+  z.object({ status: z.literal('not-found') }),
+  ProvingJobFulfilledResult,
+  ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
+]);
+export type ProvingJobStatus = z.infer<typeof ProvingJobStatus>;

package/src/interfaces/public_state_source.ts

@@ -0,0 +1,9 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  /** Returns the value for a given slot at a given contract. */
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}

package/src/interfaces/public_storage_override.ts

@@ -0,0 +1,25 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { z } from 'zod';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/schemas.js';
+
+/**
+ * A single public-storage override to inject before simulation. Identifies a slot in
+ * (contract, raw slot) space, not by leafSlot — the simulator computes the leafSlot internally
+ * via `computePublicDataTreeLeafSlot`.
+ */
+export type PublicStorageOverride = {
+  /** Contract that owns the storage slot. */
+  contract: AztecAddress;
+  /** Raw storage slot within the contract (not yet hashed into a tree key). */
+  slot: Fr;
+  /** Value to place at that slot for the duration of the simulation. */
+  value: Fr;
+};
+
+export const PublicStorageOverrideSchema = z.object({
+  contract: schemas.AztecAddress,
+  slot: schemas.Fr,
+  value: schemas.Fr,
+});

package/src/interfaces/server.ts

@@ -0,0 +1,28 @@
+export * from './allowed_element.js';
+export * from './api_limit.js';
+export * from './archiver.js';
+export * from './aztec-node.js';
+export * from './block_response.js';
+export * from './chain_tips.js';
+export * from './checkpoint_parameter.js';
+export * from './checkpoint_response.js';
+export * from './l1_publish_info.js';
+export * from './block-builder.js';
+export * from './configs.js';
+export * from './l2_logs_source.js';
+export * from './merkle_tree_operations.js';
+export * from './p2p-bootstrap.js';
+export * from './p2p.js';
+export * from './processed-tx-handler.js';
+export * from './prover-agent.js';
+export * from './prover-broker.js';
+export * from './prover-client.js';
+export * from './prover-node.js';
+export * from './proving-job-source.js';
+export * from './proving-job.js';
+export * from './server_circuit_prover.js';
+export * from './service.js';
+export * from './slasher.js';
+export * from './tx_provider.js';
+export * from './validator.js';
+export * from './world_state.js';