@aztec/bb-prover 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/dest/verifier/queued_chonk_verifier.js

@@ -0,0 +1,132 @@
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { Attributes, Metrics, ValueType, getTelemetryClient } from '@aztec/telemetry-client';
+import { createHistogram } from 'node:perf_hooks';
+class IVCVerifierMetrics {
+    ivcVerificationHistogram;
+    ivcTotalVerificationHistogram;
+    ivcFailureCount;
+    localHistogramOk = createHistogram({
+        min: 1,
+        max: 5 * 60 * 1000
+    });
+    localHistogramFails = createHistogram({
+        min: 1,
+        max: 5 * 60 * 1000
+    });
+    aggDurationMetrics;
+    constructor(client, name = 'QueuedIVCVerifier'){
+        const meter = client.getMeter(name);
+        this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME, {
+            unit: 'ms',
+            description: 'Duration to verify chonk proofs',
+            valueType: ValueType.INT
+        });
+        this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME, {
+            unit: 'ms',
+            description: 'Total duration to verify chonk proofs, including serde',
+            valueType: ValueType.INT
+        });
+        this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT, {
+            description: 'Count of failed IVC proof verifications',
+            valueType: ValueType.INT
+        });
+        this.aggDurationMetrics = {
+            avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG, {
+                valueType: ValueType.DOUBLE,
+                description: 'AVG ivc verification',
+                unit: 'ms'
+            }),
+            max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX, {
+                valueType: ValueType.DOUBLE,
+                description: 'MAX ivc verification',
+                unit: 'ms'
+            }),
+            min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN, {
+                valueType: ValueType.DOUBLE,
+                description: 'MIN ivc verification',
+                unit: 'ms'
+            }),
+            p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50, {
+                valueType: ValueType.DOUBLE,
+                description: 'P50 ivc verification',
+                unit: 'ms'
+            }),
+            p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90, {
+                valueType: ValueType.DOUBLE,
+                description: 'P90 ivc verification',
+                unit: 'ms'
+            })
+        };
+        meter.addBatchObservableCallback(this.aggregate, Object.values(this.aggDurationMetrics));
+    }
+    recordIVCVerification(result) {
+        this.ivcVerificationHistogram.record(Math.ceil(result.durationMs), {
+            [Attributes.OK]: result.valid
+        });
+        this.ivcTotalVerificationHistogram.record(Math.ceil(result.totalDurationMs), {
+            [Attributes.OK]: result.valid
+        });
+        if (!result.valid) {
+            this.ivcFailureCount.add(1);
+            this.localHistogramFails.record(Math.max(Math.ceil(result.durationMs), 1));
+        } else {
+            this.localHistogramOk.record(Math.max(Math.ceil(result.durationMs), 1));
+        }
+    }
+    aggregate = (res)=>{
+        for (const [histogram, ok] of [
+            [
+                this.localHistogramOk,
+                true
+            ],
+            [
+                this.localHistogramFails,
+                false
+            ]
+        ]){
+            if (histogram.count === 0) {
+                continue;
+            }
+            res.observe(this.aggDurationMetrics.avg, histogram.mean, {
+                [Attributes.OK]: ok
+            });
+            res.observe(this.aggDurationMetrics.max, histogram.max, {
+                [Attributes.OK]: ok
+            });
+            res.observe(this.aggDurationMetrics.min, histogram.min, {
+                [Attributes.OK]: ok
+            });
+            res.observe(this.aggDurationMetrics.p50, histogram.percentile(50), {
+                [Attributes.OK]: ok
+            });
+            res.observe(this.aggDurationMetrics.p90, histogram.percentile(90), {
+                [Attributes.OK]: ok
+            });
+        }
+    };
+}
+export class QueuedIVCVerifier {
+    verifier;
+    telemetry;
+    logger;
+    queue;
+    metrics;
+    constructor(config, verifier, telemetry = getTelemetryClient(), logger = createLogger('bb-prover:queued_chonk_verifier')){
+        this.verifier = verifier;
+        this.telemetry = telemetry;
+        this.logger = logger;
+        this.metrics = new IVCVerifierMetrics(this.telemetry, 'QueuedIVCVerifier');
+        this.queue = new SerialQueue();
+        this.logger.info(`Starting QueuedIVCVerifier with ${config.numConcurrentIVCVerifiers} concurrent verifiers`);
+        this.queue.start(config.numConcurrentIVCVerifiers);
+    }
+    async verifyProof(tx) {
+        const result = await this.queue.put(()=>this.verifier.verifyProof(tx));
+        this.metrics.recordIVCVerification(result);
+        return result;
+    }
+    stop() {
+        return this.queue.end();
+    }
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.03f7ef2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./wasm/bundle": "./dest/wasm/bundle.js",
-    "./wasm/lazy": "./dest/wasm/lazy.js",
-    "./prover": "./dest/prover/index.js",
+    "./client/bundle": "./dest/prover/client/bundle.js",
+    "./client/lazy": "./dest/prover/client/lazy.js",
+    "./client": "./dest/prover/client/bb_private_kernel_prover.js",
     "./verifier": "./dest/verifier/index.js",
     "./test": "./dest/test/index.js",
     "./config": "./dest/config.js"
@@ -25,11 +25,9 @@
     "../package.common.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --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 --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -64,40 +62,44 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/noir-protocol-circuits-types": "0.0.0-test.1",
-    "@aztec/simulator": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/telemetry-client": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
-    "@msgpack/msgpack": "^3.0.0-beta2",
+    "@aztec/bb.js": "0.0.1-commit.03f7ef2",
+    "@aztec/constants": "0.0.1-commit.03f7ef2",
+    "@aztec/foundation": "0.0.1-commit.03f7ef2",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.03f7ef2",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.03f7ef2",
+    "@aztec/noir-types": "0.0.1-commit.03f7ef2",
+    "@aztec/simulator": "0.0.1-commit.03f7ef2",
+    "@aztec/stdlib": "0.0.1-commit.03f7ef2",
+    "@aztec/telemetry-client": "0.0.1-commit.03f7ef2",
+    "@aztec/world-state": "0.0.1-commit.03f7ef2",
     "commander": "^12.1.0",
     "pako": "^2.1.0",
     "source-map-support": "^0.5.21",
-    "tslib": "^2.4.0",
-    "@aztec/noir-noirc_abi": "0.0.0-test.1",
-    "@aztec/noir-types": "0.0.0-test.1"
+    "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/ethereum": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/noir-contracts.js": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/memdown": "^3.0.0",
-    "@types/node": "^18.7.23",
+    "@aztec/ethereum": "0.0.1-commit.03f7ef2",
+    "@aztec/kv-store": "0.0.1-commit.03f7ef2",
+    "@aztec/noir-contracts.js": "0.0.1-commit.03f7ef2",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.03f7ef2",
+    "@aztec/protocol-contracts": "0.0.1-commit.03f7ef2",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
-    "viem": "2.22.8"
+    "typescript": "^5.3.3",
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "files": [
     "dest",
@@ -106,6 +108,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -1,10 +1,17 @@
-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 { LogFn, LogLevel, Logger } from '@aztec/foundation/log';
+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 { 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';
@@ -15,156 +22,269 @@ import {
   type BBResult,
   type BBSuccess,
   BB_RESULT,
+  VK_FILENAME,
   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');
+const BB_PATH = path.resolve('../../barretenberg/cpp/build/bin/bb-avm');
 
-export class AvmProvingTester extends PublicTxSimulationTester {
-  constructor(
-    private bbWorkingDirectory: string,
-    private checkCircuitOnly: boolean,
-    worldStateDB: WorldStateDB,
-    contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
-  ) {
-    super(worldStateDB, contractDataSource, merkleTrees);
-  }
+// An InterceptingLogger that records all log messages and forwards them to a wrapped logger.
+class InterceptingLogger implements Logger {
+  public readonly logs: string[] = [];
+  public level: LogLevel;
+  public module: string;
 
-  static override async create(checkCircuitOnly: boolean = false) {
-    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+  private logger: Logger;
 
-    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);
+  constructor(logger: Logger) {
+    this.logger = logger;
+    this.level = logger.level;
+    this.module = logger.module;
   }
 
-  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}`);
-    }
-    return proofRes;
+  isLevelEnabled(level: LogLevel): boolean {
+    return this.logger.isLevelEnabled(level);
   }
 
-  async verify(proofRes: BBSuccess): Promise<BBResult> {
-    if (this.checkCircuitOnly) {
-      // Skip verification if we're only checking the circuit.
-      // Check-circuit doesn't generate a proof to verify.
-      return proofRes;
-    }
-    // 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);
+  createChild(_childModule: string): Logger {
+    throw new Error('Not implemented');
   }
 
-  public async simProveVerify(
-    sender: AztecAddress,
-    setupCalls: TestEnqueuedCall[],
-    appCalls: TestEnqueuedCall[],
-    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);
+  private intercept(level: LogLevel, msg: string, ...args: any[]) {
+    this.logs.push(...msg.split('\n'));
+    // Forward to the wrapped logger
+    (this.logger[level] as LogFn)(msg, ...args);
   }
 
-  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);
+  // Log methods for each level
+  silent(msg: string, ...args: any[]) {
+    this.intercept('silent', msg, ...args);
+  }
+  fatal(msg: string, ...args: any[]) {
+    this.intercept('fatal', msg, ...args);
+  }
+  warn(msg: string, ...args: any[]) {
+    this.intercept('warn', msg, ...args);
+  }
+  info(msg: string, ...args: any[]) {
+    this.intercept('info', msg, ...args);
+  }
+  verbose(msg: string, ...args: any[]) {
+    this.intercept('verbose', msg, ...args);
+  }
+  debug(msg: string, ...args: any[]) {
+    this.intercept('debug', msg, ...args);
+  }
+  trace(msg: string, ...args: any[]) {
+    this.intercept('trace', msg, ...args);
+  }
 
-    const verificationRes = await this.verify(provingRes as BBSuccess);
-    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  // Error log function can be string or Error
+  error(err: Error | string, ...args: any[]) {
+    const msg = typeof err === 'string' ? err : err.message;
+    this.logs.push(msg);
+    this.logger.error(msg, err, ...args);
   }
 }
 
-export class AvmProvingTesterV2 extends PublicTxSimulationTester {
+// 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 bbWorkingDirectory: string = '';
+
   constructor(
-    private bbWorkingDirectory: string,
-    worldStateDB: WorldStateDB,
+    private checkCircuitOnly: boolean,
     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() {
-    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 AvmProvingTesterV2(bbWorkingDirectory, worldStateDB, contractDataSource, merkleTrees);
+    const merkleTrees = await worldStateService.fork();
+    return new AvmProvingTester(checkCircuitOnly, contractDataSource, merkleTrees, globals, metrics);
   }
 
-  async proveV2(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
+  async prove(avmCircuitInputs: AvmCircuitInputs, txLabel: string = 'unlabeledTx'): Promise<BBResult> {
+    // We use a new working directory for each proof.
+    this.bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+
+    const interceptingLogger = new InterceptingLogger(this.logger);
+
     // Then we prove.
-    const proofRes = await generateAvmProofV2(BB_PATH, this.bbWorkingDirectory, avmCircuitInputs, this.logger);
+    const proofRes = await generateAvmProof(
+      BB_PATH,
+      this.bbWorkingDirectory,
+      avmCircuitInputs,
+      interceptingLogger,
+      this.checkCircuitOnly,
+    );
     if (proofRes.status === BB_RESULT.FAILURE) {
       this.logger.error(`Proof generation failed: ${proofRes.reason}`);
     }
     expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
+
+    // Parse the logs into a structured format.
+    const logs = interceptingLogger.logs;
+    // const traceSizes: { name: string; size: number }[] = [];
+    // logs.forEach(log => {
+    //   const match = log.match(/\b(\w+): (\d+) \(~2/);
+    //   if (match) {
+    //     traceSizes.push({
+    //       name: match[1],
+    //       size: parseInt(match[2]),
+    //     });
+    //   }
+    // });
+    const times: { [key: string]: number } = {};
+    logs.forEach(log => {
+      const match = log.match(/\b([\w/]+)_ms: (\d+)/);
+      if (match) {
+        times[match[1]] = parseInt(match[2]);
+      }
+    });
+
+    // Throw if logs did not contain any times.
+    if (Object.keys(times).length === 0) {
+      throw new Error('AVM stdout did not contain any proving times in the stats!');
+    }
+
+    // Hack to make labels match.
+    const txLabelWithCount = `${txLabel}/${this.txCount - 1}`;
+    // I need to cast because TS doesnt realize metrics is protected not private.
+    (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'],
+    });
+
     return proofRes as BBSuccess;
   }
 
-  async verifyV2(proofRes: BBSuccess): Promise<BBResult> {
-    // TODO: Placeholder for now. They get ignored in C++.
-    const inputs = await makeAvmCircuitInputs();
+  async verify(proofRes: BBSuccess, publicInputs: AvmCircuitPublicInputs): Promise<BBResult> {
+    if (this.checkCircuitOnly) {
+      // Skip verification if we are only checking the circuit.
+      // Check-circuit does not generate a proof to verify.
+      return proofRes;
+    }
 
-    const rawVkPath = path.join(proofRes.vkPath!, 'vk');
-    return await verifyAvmProofV2(
+    return await verifyAvmProof(
       BB_PATH,
       this.bbWorkingDirectory,
       proofRes.proofPath!,
-      inputs.publicInputs,
-      rawVkPath,
+      publicInputs,
+      path.join(proofRes.vkDirectoryPath!, VK_FILENAME),
       this.logger,
     );
   }
 
-  public async simProveVerifyV2(
+  public async proveVerify(avmCircuitInputs: AvmCircuitInputs, txLabel: string = 'unlabeledTx') {
+    const provingRes = await this.prove(avmCircuitInputs, txLabel);
+    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
+
+    const verificationRes = await this.verify(provingRes as BBSuccess, avmCircuitInputs.publicInputs);
+    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  }
+
+  public async simProveVerify(
     sender: AztecAddress,
     setupCalls: TestEnqueuedCall[],
     appCalls: TestEnqueuedCall[],
     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);
+    privateInsertions?: TestPrivateInsertions,
+    txLabel: string = 'unlabeledTx',
+    disableRevertCheck: boolean = false,
+  ): Promise<PublicTxResult> {
+    const simTimer = new Timer();
+    const simRes = await this.simulateTx(
+      sender,
+      setupCalls,
+      appCalls,
+      teardownCall,
+      feePayer,
+      privateInsertions,
+      txLabel,
+    );
+    const simDuration = simTimer.ms();
+    this.logger.info(`Simulation took ${simDuration} ms for tx ${txLabel}`);
 
-    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
-    const provingRes = await this.proveV2(avmCircuitInputs);
-    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
+    if (!disableRevertCheck) {
+      expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+    }
 
-    const verificationRes = await this.verifyV2(provingRes as BBSuccess);
-    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+    const opString = this.checkCircuitOnly ? 'Check circuit' : 'Proving and verification';
+
+    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}`);
+
+    return simRes;
+  }
+
+  public override async executeTxWithLabel(
+    txLabel: string,
+    sender: AztecAddress,
+    setupCalls?: TestEnqueuedCall[],
+    appCalls?: TestEnqueuedCall[],
+    teardownCall?: TestEnqueuedCall,
+    feePayer?: AztecAddress,
+    privateInsertions?: TestPrivateInsertions,
+  ) {
+    return await this.simProveVerify(
+      sender,
+      setupCalls ?? [],
+      appCalls ?? [],
+      teardownCall,
+      undefined,
+      feePayer,
+      privateInsertions,
+      txLabel,
+      true,
+    );
+  }
+
+  public async simProveVerifyAppLogic(
+    appCall: TestEnqueuedCall,
+    expectRevert?: boolean,
+    txLabel: string = 'unlabeledTx',
+  ) {
+    await this.simProveVerify(
+      /*sender=*/ AztecAddress.fromNumber(42),
+      /*setupCalls=*/ [],
+      [appCall],
+      undefined,
+      expectRevert,
+      /*feePayer=*/ undefined,
+      /*privateInsertions=*/ undefined,
+      txLabel,
+    );
   }
 }