@aztec/prover-client 0.0.0-test.0

package/dest/proving_broker/rpc.js

@@ -0,0 +1,66 @@
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { ProofUri, ProvingJob, ProvingJobId, ProvingJobStatus } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { optional } from '@aztec/stdlib/schemas';
+import { getVersioningResponseHandler } from '@aztec/stdlib/versioning';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
+import { z } from 'zod';
+const ProvingJobFilterSchema = z.object({
+    allowList: z.array(z.nativeEnum(ProvingRequestType))
+});
+const GetProvingJobResponse = z.object({
+    job: ProvingJob,
+    time: z.number()
+});
+export const ProvingJobProducerSchema = {
+    enqueueProvingJob: z.function().args(ProvingJob).returns(ProvingJobStatus),
+    getProvingJobStatus: z.function().args(ProvingJobId).returns(ProvingJobStatus),
+    cancelProvingJob: z.function().args(ProvingJobId).returns(z.void()),
+    getCompletedJobs: z.function().args(z.array(ProvingJobId)).returns(z.array(ProvingJobId))
+};
+export const ProvingJobConsumerSchema = {
+    getProvingJob: z.function().args(optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
+    reportProvingJobError: z.function().args(ProvingJobId, z.string(), optional(z.boolean()), optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
+    reportProvingJobProgress: z.function().args(ProvingJobId, z.number(), optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
+    reportProvingJobSuccess: z.function().args(ProvingJobId, ProofUri, optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional())
+};
+export const ProvingJobBrokerSchema = {
+    ...ProvingJobConsumerSchema,
+    ...ProvingJobProducerSchema
+};
+export function createProvingBrokerServer(broker) {
+    return createTracedJsonRpcServer(broker, ProvingJobBrokerSchema);
+}
+export function createProvingJobBrokerClient(url, versions, fetch = makeTracedFetch([
+    1,
+    2,
+    3
+], false)) {
+    return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
+        namespaceMethods: 'proverBroker',
+        fetch,
+        onResponse: getVersioningResponseHandler(versions)
+    });
+}
+export function createProvingJobProducerClient(url, versions, fetch = makeTracedFetch([
+    1,
+    2,
+    3
+], false)) {
+    return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
+        namespaceMethods: 'provingJobProducer',
+        fetch,
+        onResponse: getVersioningResponseHandler(versions)
+    });
+}
+export function createProvingJobConsumerClient(url, versions, fetch = makeTracedFetch([
+    1,
+    2,
+    3
+], false)) {
+    return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
+        namespaceMethods: 'provingJobConsumer',
+        fetch,
+        onResponse: getVersioningResponseHandler(versions)
+    });
+}

package/dest/test/mock_prover.d.ts

@@ -0,0 +1,35 @@
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import { type ProofAndVerificationKey, type ProvingJob, type ProvingJobId, type ProvingJobProducer, type ProvingJobStatus, type PublicInputsAndRecursiveProof, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { BaseParityInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { BaseOrMergeRollupPublicInputs, BlockMergeRollupInputs, BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PrivateBaseRollupInputs, PublicBaseRollupInputs, RootRollupInputs, RootRollupPublicInputs, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
+import { type ProofStore } from '../proving_broker/proof_store/index.js';
+export declare class TestBroker implements ProvingJobProducer {
+    private proofStore;
+    private broker;
+    private agents;
+    constructor(agentCount: number, prover: ServerCircuitProver, proofStore?: ProofStore, agentPollInterval?: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getProofStore(): ProofStore;
+    enqueueProvingJob(job: ProvingJob): Promise<ProvingJobStatus>;
+    getProvingJobStatus(id: ProvingJobId): Promise<ProvingJobStatus>;
+    cancelProvingJob(id: string): Promise<void>;
+    getCompletedJobs(ids: ProvingJobId[]): Promise<ProvingJobId[]>;
+}
+export declare class MockProver implements ServerCircuitProver {
+    constructor();
+    getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<ProofAndVerificationKey<4154>>;
+    getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 459>>;
+    getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 459>>;
+    getPrivateBaseRollupProof(_baseRollupInput: PrivateBaseRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getPublicBaseRollupProof(_inputs: PublicBaseRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getMergeRollupProof(_input: MergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>>;
+    getEmptyBlockRootRollupProof(_input: EmptyBlockRootRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootRollupProof(_input: BlockRootRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getSingleTxBlockRootRollupProof(_input: SingleTxBlockRootRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getRootRollupProof(_input: RootRollupInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>>;
+    getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
+}
+//# sourceMappingURL=mock_prover.d.ts.map

package/dest/test/mock_prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_prover.d.ts","sourceRoot":"","sources":["../../src/test/mock_prover.ts"],"names":[],"mappings":"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"}

package/dest/test/mock_prover.js

@@ -0,0 +1,82 @@
+import { AVM_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
+import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import { makeBaseOrMergeRollupPublicInputs, makeBlockRootOrBlockMergeRollupPublicInputs, makeParityPublicInputs, makeRootRollupPublicInputs } from '@aztec/stdlib/testing';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+import { InlineProofStore } from '../proving_broker/proof_store/index.js';
+import { ProvingAgent } from '../proving_broker/proving_agent.js';
+import { ProvingBroker } from '../proving_broker/proving_broker.js';
+import { InMemoryBrokerDatabase } from '../proving_broker/proving_broker_database/memory.js';
+export class TestBroker {
+    proofStore;
+    broker;
+    agents;
+    constructor(agentCount, prover, proofStore = new InlineProofStore(), agentPollInterval = 100){
+        this.proofStore = proofStore;
+        this.broker = new ProvingBroker(new InMemoryBrokerDatabase());
+        this.agents = times(agentCount, ()=>new ProvingAgent(this.broker, proofStore, prover, undefined, agentPollInterval));
+    }
+    async start() {
+        await this.broker.start();
+        this.agents.forEach((agent)=>agent.start());
+    }
+    async stop() {
+        await Promise.all(this.agents.map((agent)=>agent.stop()));
+        await this.broker.stop();
+    }
+    getProofStore() {
+        return this.proofStore;
+    }
+    enqueueProvingJob(job) {
+        return this.broker.enqueueProvingJob(job);
+    }
+    getProvingJobStatus(id) {
+        return this.broker.getProvingJobStatus(id);
+    }
+    cancelProvingJob(id) {
+        return this.broker.cancelProvingJob(id);
+    }
+    getCompletedJobs(ids) {
+        return this.broker.getCompletedJobs(ids);
+    }
+}
+export class MockProver {
+    constructor(){}
+    getAvmProof(_inputs, _signal, _epochNumber) {
+        return Promise.resolve(makeProofAndVerificationKey(makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS), VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS)));
+    }
+    getBaseParityProof(_inputs, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeParityPublicInputs(), makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
+    }
+    getRootParityProof(_inputs, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeParityPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
+    }
+    getPrivateBaseRollupProof(_baseRollupInput, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBaseOrMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getPublicBaseRollupProof(_inputs, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBaseOrMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getMergeRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBaseOrMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getBlockMergeRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBlockRootOrBlockMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getEmptyBlockRootRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBlockRootOrBlockMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getBlockRootRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBlockRootOrBlockMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getSingleTxBlockRootRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeBlockRootOrBlockMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
+    }
+    getRootRollupProof(_input, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makeRootRollupPublicInputs(), makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
+    }
+    getTubeProof() {
+        return Promise.resolve(makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+}

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@aztec/prover-client",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./block-builder": "./dest/block_builder/index.js",
+    "./broker": "./dest/proving_broker/index.js",
+    "./orchestrator": "./dest/orchestrator/index.js",
+    "./helpers": "./dest/orchestrator/block-building-helpers.js",
+    "./config": "./dest/config.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Prover Client",
+    "tsconfig": "./tsconfig.json"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "bb": "node --no-warnings ./dest/bb/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=3500000 --forceExit",
+    "test:debug": "LOG_LEVEL=debug NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=1500000 --forceExit --testNamePattern prover/bb_prover/parity",
+    "get-proof-inputs": "node --no-warnings ./dest/bin/get-proof-inputs.js"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/bb-prover": "0.0.0-test.0",
+    "@aztec/blob-lib": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/simulator": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/telemetry-client": "0.0.0-test.0",
+    "@aztec/world-state": "0.0.0-test.0",
+    "@google-cloud/storage": "^7.15.0",
+    "@iarna/toml": "^2.2.5",
+    "commander": "^12.1.0",
+    "lodash.chunk": "^4.2.0",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0",
+    "zod": "^3.23.8",
+    "@aztec/noir-types": "0.0.0-test.0"
+  },
+  "devDependencies": {
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/memdown": "^3.0.0",
+    "@types/node": "^18.7.23",
+    "@types/source-map-support": "^0.5.10",
+    "get-port": "^7.1.0",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bin/get-proof-inputs.ts

@@ -0,0 +1,59 @@
+/* eslint-disable no-console */
+import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { type ProofUri, ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+import { mkdirSync, writeFileSync } from 'fs';
+
+import { createProofStoreForUri } from '../proving_broker/index.js';
+
+const logger = createLogger('prover-client:get-proof-inputs');
+
+function printUsage() {
+  console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
+}
+
+async function main() {
+  if (process.argv[2] === '--help') {
+    printUsage();
+    return;
+  }
+
+  const uri = process.argv[2];
+  const outDir = process.argv[3] || '.';
+  if (!uri) {
+    printUsage();
+    throw new Error('Missing proof URI');
+  }
+
+  mkdirSync(outDir, { recursive: true });
+
+  const proofStore = createProofStoreForUri(uri);
+  logger.info(`Processing uri ${uri}`);
+  const input = await proofStore.getProofInput(uri as ProofUri);
+  logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
+  writeProofInputs(input, outDir);
+
+  console.log((await jsonParseWithSchema(jsonStringify(input), ProvingJobInputs)).inputs);
+}
+
+// This mimics the behavior of bb-prover/src/bb/execute.ts
+function writeProofInputs(input: ProvingJobInputs, outDir: string) {
+  switch (input.type) {
+    case ProvingRequestType.PUBLIC_VM: {
+      writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
+      logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
+      break;
+    }
+    default: {
+      throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/block_builder/index.ts

@@ -0,0 +1,6 @@
+import type { BlockBuilder, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+
+export * from './light.js';
+export interface BlockBuilderFactory {
+  create(db: MerkleTreeReadOperations): BlockBuilder;
+}

package/src/block_builder/light.ts

@@ -0,0 +1,101 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { L2Block } from '@aztec/stdlib/block';
+import type { BlockBuilder, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { type GlobalVariables, type ProcessedTx, toNumBlobFields } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import {
+  buildBaseRollupHints,
+  buildHeaderAndBodyFromTxs,
+  getTreeSnapshot,
+} from '../orchestrator/block-building-helpers.js';
+
+/**
+ * Builds a block and its header from a set of processed tx without running any circuits.
+ */
+export class LightweightBlockBuilder implements BlockBuilder {
+  private spongeBlobState?: SpongeBlob;
+  private globalVariables?: GlobalVariables;
+  private l1ToL2Messages?: Fr[];
+
+  private txs: ProcessedTx[] = [];
+
+  private readonly logger = createLogger('prover-client:block_builder');
+
+  constructor(private db: MerkleTreeWriteOperations, private telemetry: TelemetryClient = getTelemetryClient()) {}
+
+  async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
+    this.logger.debug('Starting new block', { globalVariables: globalVariables.toInspect(), l1ToL2Messages });
+    this.globalVariables = globalVariables;
+    this.l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    this.txs = [];
+    this.spongeBlobState = undefined;
+
+    // Update L1 to L2 tree
+    await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.l1ToL2Messages!);
+  }
+
+  async addTxs(txs: ProcessedTx[]): Promise<void> {
+    this.spongeBlobState = SpongeBlob.init(toNumBlobFields(txs));
+    for (const tx of txs) {
+      this.logger.debug('Adding new tx to block', { txHash: tx.hash.toString() });
+      this.txs.push(tx);
+      await buildBaseRollupHints(tx, this.globalVariables!, this.db, this.spongeBlobState!);
+    }
+  }
+
+  setBlockCompleted(): Promise<L2Block> {
+    return this.buildBlock();
+  }
+
+  private async buildBlock(): Promise<L2Block> {
+    const { header, body } = await buildHeaderAndBodyFromTxs(
+      this.txs,
+      this.globalVariables!,
+      this.l1ToL2Messages!,
+      this.db,
+    );
+
+    await this.db.updateArchive(header);
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+
+    const block = new L2Block(newArchive, header, body);
+    this.logger.debug(`Built block ${block.number}`, {
+      globalVariables: this.globalVariables?.toInspect(),
+      archiveRoot: newArchive.root.toString(),
+      blockHash: block.hash.toString(),
+    });
+
+    return block;
+  }
+}
+
+export class LightweightBlockBuilderFactory {
+  constructor(private telemetry: TelemetryClient = getTelemetryClient()) {}
+
+  create(db: MerkleTreeWriteOperations): BlockBuilder {
+    return new LightweightBlockBuilder(db, this.telemetry);
+  }
+}
+
+/**
+ * Creates a block builder under the hood with the given txs and messages and creates a block.
+ * @param db - A db fork to use for block building.
+ */
+export async function buildBlock(
+  txs: ProcessedTx[],
+  globalVariables: GlobalVariables,
+  l1ToL2Messages: Fr[],
+  db: MerkleTreeWriteOperations,
+  telemetry: TelemetryClient = getTelemetryClient(),
+) {
+  const builder = new LightweightBlockBuilder(db, telemetry);
+  await builder.startNewBlock(globalVariables, l1ToL2Messages);
+  await builder.addTxs(txs);
+  return await builder.setBlockCompleted();
+}

package/src/config.ts

@@ -0,0 +1,55 @@
+import type { ACVMConfig, BBConfig } from '@aztec/bb-prover';
+import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
+import { type ProverConfig, proverConfigMappings } from '@aztec/stdlib/interfaces/server';
+
+import {
+  type ProverAgentConfig,
+  type ProverBrokerConfig,
+  proverAgentConfigMappings,
+  proverBrokerConfigMappings,
+} from './proving_broker/config.js';
+
+/**
+ * The prover configuration.
+ */
+export type ProverClientConfig = ProverConfig & ProverAgentConfig & ProverBrokerConfig & BBConfig & ACVMConfig;
+
+export const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig> = {
+  acvmWorkingDirectory: {
+    env: 'ACVM_WORKING_DIRECTORY',
+    description: 'The working directory to use for simulation/proving',
+  },
+  acvmBinaryPath: {
+    env: 'ACVM_BINARY_PATH',
+    description: 'The path to the ACVM binary',
+  },
+  bbWorkingDirectory: {
+    env: 'BB_WORKING_DIRECTORY',
+    description: 'The working directory to use for proving',
+  },
+  bbBinaryPath: {
+    env: 'BB_BINARY_PATH',
+    description: 'The path to the bb binary',
+  },
+  bbSkipCleanup: {
+    env: 'BB_SKIP_CLEANUP',
+    description: 'Whether to skip cleanup of bb temporary files',
+    ...booleanConfigHelper(false),
+  },
+};
+
+export const proverClientConfigMappings: ConfigMappingsType<ProverClientConfig> = {
+  ...bbConfigMappings,
+  ...proverConfigMappings,
+  ...proverAgentConfigMappings,
+  ...proverBrokerConfigMappings,
+};
+
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The prover configuration.
+ */
+export function getProverEnvVars(): ProverClientConfig {
+  return getConfigFromMappings<ProverClientConfig>(proverClientConfigMappings);
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export type { EpochProverManager } from '@aztec/stdlib/interfaces/server';
+
+export * from './prover-client/index.js';
+export * from './config.js';

package/src/mocks/fixtures.ts

@@ -0,0 +1,117 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { fileURLToPath } from '@aztec/foundation/url';
+import { NativeACVMSimulator, type SimulationProvider, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { ProcessedTx } from '@aztec/stdlib/tx';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const {
+  BB_RELEASE_DIR = 'cpp/build/bin',
+  TEMP_DIR = '/tmp',
+  BB_BINARY_PATH = '',
+  BB_WORKING_DIRECTORY = '',
+  BB_SKIP_CLEANUP = '',
+  NOIR_RELEASE_DIR = 'noir-repo/target/release',
+  ACVM_BINARY_PATH = '',
+  ACVM_WORKING_DIRECTORY = '',
+} = process.env;
+
+// Determines if we have access to the bb binary and a tmp folder for temp files
+export const getEnvironmentConfig = async (logger: Logger) => {
+  try {
+    const expectedBBPath = BB_BINARY_PATH
+      ? BB_BINARY_PATH
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb`;
+    await fs.access(expectedBBPath, fs.constants.R_OK);
+    const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
+    const bbWorkingDirectory = BB_WORKING_DIRECTORY ? BB_WORKING_DIRECTORY : `${tempWorkingDirectory}/bb`;
+    await fs.mkdir(bbWorkingDirectory, { recursive: true });
+    logger.info(`Found native BB binary at ${expectedBBPath} with working directory ${bbWorkingDirectory}`);
+
+    const expectedAcvmPath = ACVM_BINARY_PATH
+      ? ACVM_BINARY_PATH
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../noir/', NOIR_RELEASE_DIR)}/acvm`;
+    await fs.access(expectedAcvmPath, fs.constants.R_OK);
+    const acvmWorkingDirectory = ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : `${tempWorkingDirectory}/acvm`;
+    await fs.mkdir(acvmWorkingDirectory, { recursive: true });
+    logger.info(`Found native ACVM binary at ${expectedAcvmPath} with working directory ${acvmWorkingDirectory}`);
+
+    const bbSkipCleanup = ['1', 'true'].includes(BB_SKIP_CLEANUP);
+    bbSkipCleanup && logger.verbose(`Not going to clean up BB working directory ${bbWorkingDirectory} after run`);
+
+    return {
+      acvmWorkingDirectory,
+      bbWorkingDirectory,
+      expectedAcvmPath,
+      expectedBBPath,
+      directoryToCleanup: ACVM_WORKING_DIRECTORY && BB_WORKING_DIRECTORY ? undefined : tempWorkingDirectory,
+      bbSkipCleanup,
+    };
+  } catch (err) {
+    logger.info(`Native BB not available: ${err}`);
+    return undefined;
+  }
+};
+
+export async function getSimulationProvider(
+  config: { acvmWorkingDirectory: string | undefined; acvmBinaryPath: string | undefined },
+  logger?: Logger,
+): Promise<SimulationProvider> {
+  if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
+    try {
+      await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+      await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
+      logger?.info(
+        `Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`,
+      );
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+    } catch {
+      logger?.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+    }
+  }
+  logger?.info('Using WASM ACVM simulation');
+  return new WASMSimulatorWithBlobs();
+}
+
+// Updates the expectedDb trees based on the new note hashes, contracts, and nullifiers from these txs
+export const updateExpectedTreesFromTxs = async (db: MerkleTreeWriteOperations, txs: ProcessedTx[]) => {
+  await db.appendLeaves(
+    MerkleTreeId.NOTE_HASH_TREE,
+    txs.flatMap(tx => padArrayEnd(tx.txEffect.noteHashes, Fr.zero(), MAX_NOTE_HASHES_PER_TX)),
+  );
+  await db.batchInsert(
+    MerkleTreeId.NULLIFIER_TREE,
+    txs.flatMap(tx => padArrayEnd(tx.txEffect.nullifiers, Fr.zero(), MAX_NULLIFIERS_PER_TX).map(x => x.toBuffer())),
+    NULLIFIER_TREE_HEIGHT,
+  );
+  for (const tx of txs) {
+    await db.sequentialInsert(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      tx.txEffect.publicDataWrites.map(write => write.toBuffer()),
+    );
+  }
+};
+
+export const makeGlobals = (blockNumber: number) => {
+  return new GlobalVariables(
+    Fr.ZERO,
+    Fr.ZERO,
+    new Fr(blockNumber) /** block number */,
+    new Fr(blockNumber) /** slot number */,
+    new Fr(blockNumber) /** timestamp */,
+    EthAddress.ZERO,
+    AztecAddress.ZERO,
+    GasFees.empty(),
+  );
+};