@aztec/bb-prover 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -1,78 +1,124 @@
-import { PublicTxSimulationTester, type TestEnqueuedCall } from '@aztec/simulator/public/fixtures';
-import { SimpleContractDataSource, WorldStateDB } from '@aztec/simulator/server';
-import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import type { AvmStat } from '@aztec/bb.js';
+import { Timer } from '@aztec/foundation/timer';
+import {
+  PublicTxSimulationTester,
+  SimpleContractDataSource,
+  type TestEnqueuedCall,
+  type TestExecutorMetrics,
+  type TestPrivateInsertions,
+} from '@aztec/simulator/public/fixtures';
+import type { PublicTxResult } from '@aztec/simulator/server';
+import { AvmCircuitInputs, AvmCircuitPublicInputs, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { makeAvmCircuitInputs } from '@aztec/stdlib/testing';
-import { VerificationKeyData } from '@aztec/stdlib/vks';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import fs from 'node:fs/promises';
-import { tmpdir } from 'node:os';
 import path from 'path';
 
-import {
-  type BBResult,
-  type BBSuccess,
-  BB_RESULT,
-  generateAvmProof,
-  generateAvmProofV2,
-  verifyAvmProof,
-  verifyAvmProofV2,
-} from '../bb/execute.js';
-import { extractAvmVkData } from '../verification_key/verification_key_data.js';
-
-const BB_PATH = path.resolve('../../barretenberg/cpp/build/bin/bb');
+import { BBJsFactory } from '../bb/bb_js_backend.js';
+
+const BB_PATH = path.resolve('../../barretenberg/cpp/build/bin/bb-avm');
+
+// Config with collectHints enabled for proving tests
+const provingConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectCallMetadata: true, // For results.
+  collectDebugLogs: false,
+  collectHints: true, // Required for proving!
+  collectPublicInputs: true, // Required for proving!
+  collectStatistics: false,
+});
 
 export class AvmProvingTester extends PublicTxSimulationTester {
+  private readonly bbJsFactory = new BBJsFactory(BB_PATH);
+
   constructor(
-    private bbWorkingDirectory: string,
     private checkCircuitOnly: boolean,
-    worldStateDB: WorldStateDB,
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
+    globals?: GlobalVariables,
+    metrics?: TestExecutorMetrics,
   ) {
-    super(worldStateDB, contractDataSource, merkleTrees);
+    // simulator factory is undefined because for proving, we use the default C++ simulator
+    super(merkleTrees, contractDataSource, globals, metrics, /*simulatorFactory=*/ undefined, provingConfig);
   }
 
-  static override async create(checkCircuitOnly: boolean = false) {
-    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
-
+  static async new(
+    worldStateService: NativeWorldStateService, // make sure to close this later
+    checkCircuitOnly: boolean = false,
+    globals?: GlobalVariables,
+    metrics?: TestExecutorMetrics,
+  ) {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new AvmProvingTester(bbWorkingDirectory, checkCircuitOnly, worldStateDB, contractDataSource, merkleTrees);
+    const merkleTrees = await worldStateService.fork();
+    return new AvmProvingTester(checkCircuitOnly, contractDataSource, merkleTrees, globals, metrics);
   }
 
-  async prove(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
-    // Then we prove.
-    const proofRes = await generateAvmProof(
-      BB_PATH,
-      this.bbWorkingDirectory,
-      avmCircuitInputs,
-      this.logger,
-      this.checkCircuitOnly,
-    );
-    if (proofRes.status === BB_RESULT.FAILURE) {
-      this.logger.error(`Proof generation failed: ${proofRes.reason}`);
+  /**
+   * Generate an AVM proof (or run check-circuit if configured). Records per-stage timings in the test metrics.
+   * Returns the in-memory proof fields on success; throws via jest expect() on failure.
+   */
+  async prove(avmCircuitInputs: AvmCircuitInputs, txLabel: string = 'unlabeledTx'): Promise<Uint8Array[]> {
+    const inputsBuffer = avmCircuitInputs.serializeWithMessagePack();
+
+    if (this.checkCircuitOnly) {
+      await using instance = await this.bbJsFactory.getInstance();
+      const { passed, stats } = await instance.checkAvmCircuit(inputsBuffer);
+      this.recordProverMetrics(stats, txLabel);
+      expect(passed).toBe(true);
+      return [];
     }
-    return proofRes;
+
+    await using instance = await this.bbJsFactory.getInstance();
+    const { proof, stats } = await instance.generateAvmProof(inputsBuffer);
+    this.recordProverMetrics(stats, txLabel);
+    return proof;
   }
 
-  async verify(proofRes: BBSuccess): Promise<BBResult> {
+  async verify(proof: Uint8Array[], publicInputs: AvmCircuitPublicInputs): Promise<void> {
     if (this.checkCircuitOnly) {
-      // Skip verification if we're only checking the circuit.
-      // Check-circuit doesn't generate a proof to verify.
-      return proofRes;
+      // Check-circuit did not generate a proof; nothing to verify.
+      return;
     }
-    // Then we test VK extraction and serialization.
-    const succeededRes = proofRes as BBSuccess;
-    const vkData = await extractAvmVkData(succeededRes.vkPath!);
-    VerificationKeyData.fromBuffer(vkData.toBuffer());
-
-    // Then we verify.
-    const rawVkPath = path.join(succeededRes.vkPath!, 'vk');
-    return await verifyAvmProof(BB_PATH, succeededRes.proofPath!, rawVkPath, this.logger);
+    const piBuffer = publicInputs.serializeWithMessagePack();
+    await using instance = await this.bbJsFactory.getInstance();
+    const { verified } = await instance.verifyAvmProof(proof, piBuffer);
+    expect(verified).toBe(true);
+  }
+
+  public async proveVerify(avmCircuitInputs: AvmCircuitInputs, txLabel: string = 'unlabeledTx') {
+    const proof = await this.prove(avmCircuitInputs, txLabel);
+    await this.verify(proof, avmCircuitInputs.publicInputs);
+  }
+
+  private recordProverMetrics(stats: AvmStat[], txLabel: string) {
+    // Build a lookup keyed on the stage name with the `_ms` suffix stripped, matching the legacy
+    // stdout-scraped shape. bb::avm2::Stats::time() stores keys with `_ms` appended.
+    const times: { [key: string]: number } = {};
+    for (const { name, valueMs } of stats) {
+      const key = name.endsWith('_ms') ? name.slice(0, -'_ms'.length) : name;
+      times[key] = valueMs;
+    }
+    if (Object.keys(times).length === 0) {
+      throw new Error('AVM response did not contain any proving-stage timings!');
+    }
+    // Hack to make labels match.
+    const txLabelWithCount = `${txLabel}/${this.txCount - 1}`;
+    // Cast because TS doesn't realize `metrics` is protected, not private on the parent class.
+    (this as any).metrics?.recordProverMetrics(txLabelWithCount, {
+      proverSimulationStepMs: times['simulation/all'],
+      proverProvingStepMs: times['proving/all'],
+      proverTraceGenerationStepMs: times['tracegen/all'],
+      traceGenerationInteractionsMs: times['tracegen/interactions'],
+      traceGenerationTracesMs: times['tracegen/traces'],
+      provingSumcheckMs: times['prove/sumcheck'],
+      provingPcsMs: times['prove/pcs_rounds'],
+      provingLogDerivativeInverseMs: times['prove/log_derivative_inverse_round'],
+      provingLogDerivativeInverseCommitmentsMs: times['prove/log_derivative_inverse_commitments_round'],
+      provingWireCommitmentsMs: times['prove/wire_commitments_round'],
+    });
   }
 
   public async simProveVerify(
@@ -82,89 +128,80 @@ export class AvmProvingTester extends PublicTxSimulationTester {
     teardownCall: TestEnqueuedCall | undefined,
     expectRevert: boolean | undefined,
     feePayer = sender,
-  ) {
-    const simRes = await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer);
-    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
-    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
-    const provingRes = await this.prove(avmCircuitInputs);
-    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
-    const verificationRes = await this.verify(provingRes as BBSuccess);
-    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
-  }
-
-  public async simProveVerifyAppLogic(appCall: TestEnqueuedCall, expectRevert?: boolean) {
-    const simRes = await this.simulateTx(/*sender=*/ AztecAddress.fromNumber(42), /*setupCalls=*/ [], [appCall]);
-    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
-
-    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
-    const provingRes = await this.prove(avmCircuitInputs);
-    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
-
-    const verificationRes = await this.verify(provingRes as BBSuccess);
-    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
-  }
-}
+    privateInsertions?: TestPrivateInsertions,
+    txLabel: string = 'unlabeledTx',
+    disableRevertCheck: boolean = false,
+    gasLimits?: Gas,
+  ): Promise<PublicTxResult> {
+    const simTimer = new Timer();
+    const simRes = await this.simulateTx(
+      sender,
+      setupCalls,
+      appCalls,
+      teardownCall,
+      feePayer,
+      privateInsertions,
+      txLabel,
+      gasLimits,
+    );
+    const simDuration = simTimer.ms();
+    this.logger.info(`Simulation took ${simDuration} ms for tx ${txLabel}`);
 
-export class AvmProvingTesterV2 extends PublicTxSimulationTester {
-  constructor(
-    private bbWorkingDirectory: string,
-    worldStateDB: WorldStateDB,
-    contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
-  ) {
-    super(worldStateDB, contractDataSource, merkleTrees);
-  }
+    if (!disableRevertCheck) {
+      expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+    }
 
-  static override async create() {
-    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+    const opString = this.checkCircuitOnly ? 'Check circuit' : 'Proving and verification';
 
-    const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new AvmProvingTesterV2(bbWorkingDirectory, worldStateDB, contractDataSource, merkleTrees);
-  }
+    const avmCircuitInputs = new AvmCircuitInputs(simRes.hints!, simRes.publicInputs!);
+    const timer = new Timer();
+    await this.proveVerify(avmCircuitInputs, txLabel);
+    this.logger.info(`${opString} took ${timer.ms()} ms for tx ${txLabel}`);
 
-  async proveV2(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
-    // Then we prove.
-    const proofRes = await generateAvmProofV2(BB_PATH, this.bbWorkingDirectory, avmCircuitInputs, this.logger);
-    if (proofRes.status === BB_RESULT.FAILURE) {
-      this.logger.error(`Proof generation failed: ${proofRes.reason}`);
-    }
-    expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
-    return proofRes as BBSuccess;
+    return simRes;
   }
 
-  async verifyV2(proofRes: BBSuccess): Promise<BBResult> {
-    // TODO: Placeholder for now. They get ignored in C++.
-    const inputs = await makeAvmCircuitInputs();
-
-    const rawVkPath = path.join(proofRes.vkPath!, 'vk');
-    return await verifyAvmProofV2(
-      BB_PATH,
-      this.bbWorkingDirectory,
-      proofRes.proofPath!,
-      inputs.publicInputs,
-      rawVkPath,
-      this.logger,
+  public override async executeTxWithLabel(
+    txLabel: string,
+    sender: AztecAddress,
+    setupCalls?: TestEnqueuedCall[],
+    appCalls?: TestEnqueuedCall[],
+    teardownCall?: TestEnqueuedCall,
+    feePayer?: AztecAddress,
+    privateInsertions?: TestPrivateInsertions,
+    gasLimits?: Gas,
+  ) {
+    return await this.simProveVerify(
+      sender,
+      setupCalls ?? [],
+      appCalls ?? [],
+      teardownCall,
+      undefined,
+      feePayer,
+      privateInsertions,
+      txLabel,
+      true,
+      gasLimits,
     );
   }
 
-  public async simProveVerifyV2(
-    sender: AztecAddress,
-    setupCalls: TestEnqueuedCall[],
-    appCalls: TestEnqueuedCall[],
-    teardownCall: TestEnqueuedCall | undefined,
-    expectRevert: boolean | undefined,
-    feePayer = sender,
+  public async simProveVerifyAppLogic(
+    appCall: TestEnqueuedCall,
+    expectRevert?: boolean,
+    txLabel: string = 'unlabeledTx',
+    gasLimits?: Gas,
   ) {
-    const simRes = await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer);
-    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
-
-    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
-    const provingRes = await this.proveV2(avmCircuitInputs);
-    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
-
-    const verificationRes = await this.verifyV2(provingRes as BBSuccess);
-    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+    await this.simProveVerify(
+      /*sender=*/ AztecAddress.fromNumber(42),
+      /*setupCalls=*/ [],
+      [appCall],
+      undefined,
+      expectRevert,
+      /*feePayer=*/ undefined,
+      /*privateInsertions=*/ undefined,
+      txLabel,
+      /*disableRevertCheck=*/ false,
+      gasLimits,
+    );
   }
 }