@aztec/prover-client 0.0.0-test.0

package/README.md

@@ -0,0 +1 @@
+# Prover Client

package/dest/bin/get-proof-inputs.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-proof-inputs.d.ts.map

package/dest/bin/get-proof-inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-proof-inputs.d.ts","sourceRoot":"","sources":["../../src/bin/get-proof-inputs.ts"],"names":[],"mappings":""}

package/dest/bin/get-proof-inputs.js

@@ -0,0 +1,51 @@
+/* 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 { 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);
+    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, outDir) {
+    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/dest/block_builder/index.d.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;
+}
+//# sourceMappingURL=index.d.ts.map

package/dest/block_builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/block_builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAE9F,cAAc,YAAY,CAAC;AAC3B,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,EAAE,wBAAwB,GAAG,YAAY,CAAC;CACpD"}

package/dest/block_builder/index.js

@@ -0,0 +1 @@
+export * from './light.js';

package/dest/block_builder/light.d.ts

@@ -0,0 +1,33 @@
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import type { BlockBuilder, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { type GlobalVariables, type ProcessedTx } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+/**
+ * Builds a block and its header from a set of processed tx without running any circuits.
+ */
+export declare class LightweightBlockBuilder implements BlockBuilder {
+    private db;
+    private telemetry;
+    private spongeBlobState?;
+    private globalVariables?;
+    private l1ToL2Messages?;
+    private txs;
+    private readonly logger;
+    constructor(db: MerkleTreeWriteOperations, telemetry?: TelemetryClient);
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void>;
+    addTxs(txs: ProcessedTx[]): Promise<void>;
+    setBlockCompleted(): Promise<L2Block>;
+    private buildBlock;
+}
+export declare class LightweightBlockBuilderFactory {
+    private telemetry;
+    constructor(telemetry?: TelemetryClient);
+    create(db: MerkleTreeWriteOperations): BlockBuilder;
+}
+/**
+ * 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 declare function buildBlock(txs: ProcessedTx[], globalVariables: GlobalVariables, l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations, telemetry?: TelemetryClient): Promise<L2Block>;
+//# sourceMappingURL=light.d.ts.map

package/dest/block_builder/light.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"light.d.ts","sourceRoot":"","sources":["../../src/block_builder/light.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAE/F,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAmB,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAQnF;;GAEG;AACH,qBAAa,uBAAwB,YAAW,YAAY;IAS9C,OAAO,CAAC,EAAE;IAA6B,OAAO,CAAC,SAAS;IARpE,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,cAAc,CAAC,CAAO;IAE9B,OAAO,CAAC,GAAG,CAAqB;IAEhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+C;gBAElD,EAAE,EAAE,yBAAyB,EAAU,SAAS,GAAE,eAAsC;IAEtG,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWpF,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/C,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;YAIvB,UAAU;CAoBzB;AAED,qBAAa,8BAA8B;IAC7B,OAAO,CAAC,SAAS;gBAAT,SAAS,GAAE,eAAsC;IAErE,MAAM,CAAC,EAAE,EAAE,yBAAyB,GAAG,YAAY;CAGpD;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,WAAW,EAAE,EAClB,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,EACpB,EAAE,EAAE,yBAAyB,EAC7B,SAAS,GAAE,eAAsC,oBAMlD"}

package/dest/block_builder/light.js

@@ -0,0 +1,82 @@
+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 { MerkleTreeId } from '@aztec/stdlib/trees';
+import { toNumBlobFields } from '@aztec/stdlib/tx';
+import { 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 {
+    db;
+    telemetry;
+    spongeBlobState;
+    globalVariables;
+    l1ToL2Messages;
+    txs;
+    logger;
+    constructor(db, telemetry = getTelemetryClient()){
+        this.db = db;
+        this.telemetry = telemetry;
+        this.txs = [];
+        this.logger = createLogger('prover-client:block_builder');
+    }
+    async startNewBlock(globalVariables, l1ToL2Messages) {
+        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) {
+        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() {
+        return this.buildBlock();
+    }
+    async buildBlock() {
+        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 {
+    telemetry;
+    constructor(telemetry = getTelemetryClient()){
+        this.telemetry = telemetry;
+    }
+    create(db) {
+        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, globalVariables, l1ToL2Messages, db, telemetry = getTelemetryClient()) {
+    const builder = new LightweightBlockBuilder(db, telemetry);
+    await builder.startNewBlock(globalVariables, l1ToL2Messages);
+    await builder.addTxs(txs);
+    return await builder.setBlockCompleted();
+}

package/dest/config.d.ts

@@ -0,0 +1,17 @@
+import type { ACVMConfig, BBConfig } from '@aztec/bb-prover';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type ProverConfig } from '@aztec/stdlib/interfaces/server';
+import { type ProverAgentConfig, type ProverBrokerConfig } from './proving_broker/config.js';
+/**
+ * The prover configuration.
+ */
+export type ProverClientConfig = ProverConfig & ProverAgentConfig & ProverBrokerConfig & BBConfig & ACVMConfig;
+export declare const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig>;
+export declare const proverClientConfigMappings: ConfigMappingsType<ProverClientConfig>;
+/**
+ * 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 declare function getProverEnvVars(): ProverClientConfig;
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,KAAK,kBAAkB,EAA8C,MAAM,0BAA0B,CAAC;AAC/G,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,iCAAiC,CAAC;AAE1F,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAGxB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE/G,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,QAAQ,GAAG,UAAU,CAsBtE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CAK7E,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAErD"}

package/dest/config.js

@@ -0,0 +1,39 @@
+import { booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
+import { proverConfigMappings } from '@aztec/stdlib/interfaces/server';
+import { proverAgentConfigMappings, proverBrokerConfigMappings } from './proving_broker/config.js';
+export const bbConfigMappings = {
+    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 = {
+    ...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() {
+    return getConfigFromMappings(proverClientConfigMappings);
+}

package/dest/index.d.ts

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

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC"}

package/dest/index.js

@@ -0,0 +1,2 @@
+export * from './prover-client/index.js';
+export * from './config.js';

package/dest/mocks/fixtures.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '@aztec/foundation/log';
+import { type SimulationProvider } from '@aztec/simulator/server';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { ProcessedTx } from '@aztec/stdlib/tx';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+export declare const getEnvironmentConfig: (logger: Logger) => Promise<{
+    acvmWorkingDirectory: string;
+    bbWorkingDirectory: string;
+    expectedAcvmPath: string;
+    expectedBBPath: string;
+    directoryToCleanup: string | undefined;
+    bbSkipCleanup: boolean;
+} | undefined>;
+export declare function getSimulationProvider(config: {
+    acvmWorkingDirectory: string | undefined;
+    acvmBinaryPath: string | undefined;
+}, logger?: Logger): Promise<SimulationProvider>;
+export declare const updateExpectedTreesFromTxs: (db: MerkleTreeWriteOperations, txs: ProcessedTx[]) => Promise<void>;
+export declare const makeGlobals: (blockNumber: number) => GlobalVariables;
+//# sourceMappingURL=fixtures.d.ts.map

package/dest/mocks/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/mocks/fixtures.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAuB,KAAK,kBAAkB,EAA0B,MAAM,yBAAyB,CAAC;AAG/G,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAiBnD,eAAO,MAAM,oBAAoB,WAAkB,MAAM;;;;;;;cAkCxD,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EACxF,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,kBAAkB,CAAC,CAe7B;AAGD,eAAO,MAAM,0BAA0B,OAAc,yBAAyB,OAAO,WAAW,EAAE,kBAgBjG,CAAC;AAEF,eAAO,MAAM,WAAW,gBAAiB,MAAM,oBAW9C,CAAC"}

package/dest/mocks/fixtures.js

@@ -0,0 +1,77 @@
+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 { fileURLToPath } from '@aztec/foundation/url';
+import { NativeACVMSimulator, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+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)=>{
+    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, logger) {
+    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, txs)=>{
+    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)=>{
+    return new GlobalVariables(Fr.ZERO, Fr.ZERO, new Fr(blockNumber), new Fr(blockNumber), new Fr(blockNumber), EthAddress.ZERO, AztecAddress.ZERO, GasFees.empty());
+};

package/dest/mocks/test_context.d.ts

@@ -0,0 +1,55 @@
+import type { BBProverConfig } from '@aztec/bb-prover';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { PublicProcessor, PublicTxSimulationTester, PublicTxSimulator } from '@aztec/simulator/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
+import { type AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx } from '@aztec/stdlib/tx';
+import type { MerkleTreeAdminDatabase } from '@aztec/world-state';
+import { ProvingOrchestrator } from '../orchestrator/index.js';
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+import { TestBroker } from '../test/mock_prover.js';
+export declare class TestContext {
+    publicTxSimulator: PublicTxSimulator;
+    worldState: MerkleTreeAdminDatabase;
+    publicProcessor: PublicProcessor;
+    globalVariables: GlobalVariables;
+    prover: ServerCircuitProver;
+    broker: TestBroker;
+    brokerProverFacade: BrokerCircuitProverFacade;
+    orchestrator: TestProvingOrchestrator;
+    blockNumber: number;
+    feePayer: AztecAddress;
+    directoriesToCleanup: string[];
+    tester: PublicTxSimulationTester;
+    logger: Logger;
+    private headers;
+    private feePayerBalance;
+    constructor(publicTxSimulator: PublicTxSimulator, worldState: MerkleTreeAdminDatabase, publicProcessor: PublicProcessor, globalVariables: GlobalVariables, prover: ServerCircuitProver, broker: TestBroker, brokerProverFacade: BrokerCircuitProverFacade, orchestrator: TestProvingOrchestrator, blockNumber: number, feePayer: AztecAddress, initialFeePayerBalance: Fr, directoriesToCleanup: string[], tester: PublicTxSimulationTester, logger: Logger);
+    get epochProver(): TestProvingOrchestrator;
+    static new(logger: Logger, proverCount?: number, createProver?: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver>, blockNumber?: number): Promise<TestContext>;
+    getFork(): Promise<import("@aztec/stdlib/trees").MerkleTreeWriteOperations>;
+    getBlockHeader(blockNumber: 0): BlockHeader;
+    getBlockHeader(blockNumber: number): BlockHeader | undefined;
+    getPreviousBlockHeader(currentBlockNumber?: number): BlockHeader;
+    cleanup(): Promise<void>;
+    makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx>;
+    makeProcessedTx(seed?: number): Promise<ProcessedTx>;
+    /** Creates a block with the given number of txs and adds it to world-state */
+    makePendingBlock(numTxs: number, numMsgs?: number, blockNumOrGlobals?: GlobalVariables | number, makeProcessedTxOpts?: (index: number) => Partial<Parameters<typeof makeBloatedProcessedTx>[0]>): Promise<{
+        block: L2Block;
+        txs: ProcessedTx[];
+        msgs: Fr[];
+    }>;
+    processPublicFunctions(txs: Tx[], maxTransactions: number): Promise<[ProcessedTx[], import("@aztec/stdlib/tx").FailedTx[], import("@aztec/stdlib/tx").NestedProcessReturnValues[]]>;
+    setTreeRoots(txs: ProcessedTx[]): Promise<void>;
+}
+declare class TestProvingOrchestrator extends ProvingOrchestrator {
+    isVerifyBuiltBlockAgainstSyncedStateEnabled: boolean;
+    protected verifyBuiltBlockAgainstSyncedState(l2Block: L2Block, newArchive: AppendOnlyTreeSnapshot): Promise<void>;
+}
+export {};
+//# sourceMappingURL=test_context.d.ts.map

package/dest/mocks/test_context.d.ts.map

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

package/dest/mocks/test_context.js

@@ -0,0 +1,193 @@
+import { times, timesParallel } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { TestDateProvider } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
+import { PublicProcessor, PublicTxSimulationTester, PublicTxSimulator, SimpleContractDataSource, WorldStateDB } from '@aztec/simulator/server';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
+import { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
+import { NativeWorldStateService } from '@aztec/world-state/native';
+import { promises as fs } from 'fs';
+import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
+import { buildBlock } from '../block_builder/light.js';
+import { ProvingOrchestrator } from '../orchestrator/index.js';
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+import { TestBroker } from '../test/mock_prover.js';
+import { getEnvironmentConfig, getSimulationProvider, makeGlobals, updateExpectedTreesFromTxs } from './fixtures.js';
+export class TestContext {
+    publicTxSimulator;
+    worldState;
+    publicProcessor;
+    globalVariables;
+    prover;
+    broker;
+    brokerProverFacade;
+    orchestrator;
+    blockNumber;
+    feePayer;
+    directoriesToCleanup;
+    tester;
+    logger;
+    headers;
+    feePayerBalance;
+    constructor(publicTxSimulator, worldState, publicProcessor, globalVariables, prover, broker, brokerProverFacade, orchestrator, blockNumber, feePayer, initialFeePayerBalance, directoriesToCleanup, tester, logger){
+        this.publicTxSimulator = publicTxSimulator;
+        this.worldState = worldState;
+        this.publicProcessor = publicProcessor;
+        this.globalVariables = globalVariables;
+        this.prover = prover;
+        this.broker = broker;
+        this.brokerProverFacade = brokerProverFacade;
+        this.orchestrator = orchestrator;
+        this.blockNumber = blockNumber;
+        this.feePayer = feePayer;
+        this.directoriesToCleanup = directoriesToCleanup;
+        this.tester = tester;
+        this.logger = logger;
+        this.headers = new Map();
+        this.feePayerBalance = initialFeePayerBalance;
+    }
+    get epochProver() {
+        return this.orchestrator;
+    }
+    static async new(logger, proverCount = 4, createProver = async (bbConfig)=>new TestCircuitProver(await getSimulationProvider(bbConfig, logger)), blockNumber = 1) {
+        const directoriesToCleanup = [];
+        const globalVariables = makeGlobals(blockNumber);
+        const feePayer = AztecAddress.fromNumber(42222);
+        const initialFeePayerBalance = new Fr(10n ** 20n);
+        const feePayerSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+        const prefilledPublicData = [
+            new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)
+        ];
+        // Separated dbs for public processor and prover - see public_processor for context
+        const ws = await NativeWorldStateService.tmp(undefined /* rollupAddress */ , true, prefilledPublicData);
+        const publicDb = await ws.fork();
+        const contractDataSource = new SimpleContractDataSource();
+        const worldStateDB = new WorldStateDB(publicDb, contractDataSource);
+        const tester = new PublicTxSimulationTester(worldStateDB, contractDataSource, publicDb);
+        const publicTxSimulator = new PublicTxSimulator(publicDb, worldStateDB, globalVariables, true);
+        const processor = new PublicProcessor(publicDb, globalVariables, worldStateDB, publicTxSimulator, new TestDateProvider());
+        let localProver;
+        const config = await getEnvironmentConfig(logger);
+        if (!config) {
+            localProver = new TestCircuitProver();
+        } else {
+            const bbConfig = {
+                acvmBinaryPath: config.expectedAcvmPath,
+                acvmWorkingDirectory: config.acvmWorkingDirectory,
+                bbBinaryPath: config.expectedBBPath,
+                bbWorkingDirectory: config.bbWorkingDirectory,
+                bbSkipCleanup: config.bbSkipCleanup
+            };
+            localProver = await createProver(bbConfig);
+        }
+        if (config?.directoryToCleanup && !config.bbSkipCleanup) {
+            directoriesToCleanup.push(config.directoryToCleanup);
+        }
+        const broker = new TestBroker(proverCount, localProver);
+        const facade = new BrokerCircuitProverFacade(broker);
+        const orchestrator = new TestProvingOrchestrator(ws, facade, Fr.ZERO);
+        await broker.start();
+        facade.start();
+        return new this(publicTxSimulator, ws, processor, globalVariables, localProver, broker, facade, orchestrator, blockNumber, feePayer, initialFeePayerBalance, directoriesToCleanup, tester, logger);
+    }
+    getFork() {
+        return this.worldState.fork();
+    }
+    getBlockHeader(blockNumber = 0) {
+        return blockNumber === 0 ? this.worldState.getCommitted().getInitialHeader() : this.headers.get(blockNumber);
+    }
+    getPreviousBlockHeader(currentBlockNumber = this.blockNumber) {
+        return this.getBlockHeader(currentBlockNumber - 1);
+    }
+    async cleanup() {
+        await this.brokerProverFacade.stop();
+        await this.broker.stop();
+        for (const dir of this.directoriesToCleanup.filter((x)=>x !== '')){
+            try {
+                await fs.rm(dir, {
+                    recursive: true,
+                    force: true,
+                    maxRetries: 3
+                });
+            } catch (err) {
+                this.logger.warn(`Failed to delete tmp directory $dir}: ${err}`);
+            }
+        }
+    }
+    async makeProcessedTx(seedOrOpts) {
+        const opts = typeof seedOrOpts === 'number' ? {
+            seed: seedOrOpts
+        } : seedOrOpts;
+        const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber.toNumber();
+        const header = this.getBlockHeader(blockNum - 1);
+        const tx = await makeBloatedProcessedTx({
+            header,
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractTreeRoot,
+            globalVariables: this.globalVariables,
+            feePayer: this.feePayer,
+            ...opts
+        });
+        this.feePayerBalance = new Fr(this.feePayerBalance.toBigInt() - tx.txEffect.transactionFee.toBigInt());
+        if (opts?.privateOnly) {
+            const feePayerSlot = await computeFeePayerBalanceLeafSlot(this.feePayer);
+            tx.txEffect.publicDataWrites[0] = new PublicDataWrite(feePayerSlot, this.feePayerBalance);
+        }
+        return tx;
+    }
+    /** Creates a block with the given number of txs and adds it to world-state */ async makePendingBlock(numTxs, numMsgs = 0, blockNumOrGlobals = this.globalVariables, makeProcessedTxOpts = ()=>({})) {
+        const globalVariables = typeof blockNumOrGlobals === 'number' ? makeGlobals(blockNumOrGlobals) : blockNumOrGlobals;
+        const blockNum = globalVariables.blockNumber.toNumber();
+        const db = await this.worldState.fork();
+        const msgs = times(numMsgs, (i)=>new Fr(blockNum * 100 + i));
+        const txs = await timesParallel(numTxs, (i)=>this.makeProcessedTx({
+                seed: i + blockNum * 1000,
+                globalVariables,
+                ...makeProcessedTxOpts(i)
+            }));
+        await this.setTreeRoots(txs);
+        const block = await buildBlock(txs, globalVariables, msgs, db);
+        this.headers.set(blockNum, block.header);
+        await this.worldState.handleL2BlockAndMessages(block, msgs);
+        return {
+            block,
+            txs,
+            msgs
+        };
+    }
+    async processPublicFunctions(txs, maxTransactions) {
+        return await this.publicProcessor.process(txs, {
+            maxTransactions
+        });
+    }
+    async setTreeRoots(txs) {
+        const db = await this.worldState.fork();
+        for (const tx of txs){
+            const startStateReference = await db.getStateReference();
+            await updateExpectedTreesFromTxs(db, [
+                tx
+            ]);
+            const endStateReference = await db.getStateReference();
+            if (tx.avmProvingRequest) {
+                tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots = new TreeSnapshots(startStateReference.l1ToL2MessageTree, startStateReference.partial.noteHashTree, startStateReference.partial.nullifierTree, startStateReference.partial.publicDataTree);
+                tx.avmProvingRequest.inputs.publicInputs.endTreeSnapshots = new TreeSnapshots(endStateReference.l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
+            }
+        }
+    }
+}
+class TestProvingOrchestrator extends ProvingOrchestrator {
+    isVerifyBuiltBlockAgainstSyncedStateEnabled = false;
+    // Disable this check by default, since it requires seeding world state with the block being built
+    // This is only enabled in some tests with multiple blocks that populate the pending chain via makePendingBlock
+    verifyBuiltBlockAgainstSyncedState(l2Block, newArchive) {
+        if (this.isVerifyBuiltBlockAgainstSyncedStateEnabled) {
+            return super.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+        }
+        return Promise.resolve();
+    }
+}