@aztec-labs/bb-prover 6.0.0-nightly.20260829

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verifier/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC"}

package/dest/verifier/index.js

@@ -0,0 +1,3 @@
+export * from './batch_chonk_verifier.js';
+export * from './bb_verifier.js';
+export * from './queued_chonk_verifier.js';

package/dest/verifier/queued_chonk_verifier.d.ts

@@ -0,0 +1,26 @@
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec-labs/stdlib/interfaces/server';
+import type { Tx } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+/** Records verification timing and failure metrics for an IVC (chonk) proof verifier. */
+export declare class IVCVerifierMetrics {
+    private ivcVerificationHistogram;
+    private ivcTotalVerificationHistogram;
+    private ivcFailureCount;
+    private localHistogramOk;
+    private localHistogramFails;
+    private aggDurationMetrics;
+    constructor(client: TelemetryClient, name?: string);
+    recordIVCVerification(result: IVCProofVerificationResult): void;
+    private aggregate;
+}
+export declare class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
+    private verifier;
+    private telemetry;
+    private logger;
+    private queue;
+    private metrics;
+    constructor(verifier: ClientProtocolCircuitVerifier, concurrency: number, telemetry?: TelemetryClient, logger?: import("@aztec-labs/foundation/log").Logger);
+    verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVldWVkX2Nob25rX3ZlcmlmaWVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpZXIvcXVldWVkX2Nob25rX3ZlcmlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdEgsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDaEQsT0FBTyxFQU1MLEtBQUssZUFBZSxFQUlyQixNQUFNLDhCQUE4QixDQUFDO0FBR3RDLHlGQUF5RjtBQUN6RixxQkFBYSxrQkFBa0I7SUFDN0IsT0FBTyxDQUFDLHdCQUF3QixDQUFZO0lBQzVDLE9BQU8sQ0FBQyw2QkFBNkIsQ0FBWTtJQUNqRCxPQUFPLENBQUMsZUFBZSxDQUFnQjtJQUN2QyxPQUFPLENBQUMsZ0JBQWdCLENBR3JCO0lBQ0gsT0FBTyxDQUFDLG1CQUFtQixDQUd4QjtJQUVILE9BQU8sQ0FBQyxrQkFBa0IsQ0FBaUU7SUFFM0YsWUFBWSxNQUFNLEVBQUUsZUFBZSxFQUFFLElBQUksU0FBc0IsRUFrQjlEO0lBRUQscUJBQXFCLENBQUMsTUFBTSxFQUFFLDBCQUEwQixRQVN2RDtJQUVELE9BQU8sQ0FBQyxTQUFTLENBY2Y7Q0FDSDtBQUVELHFCQUFhLGlCQUFrQixZQUFXLDZCQUE2QjtJQUtuRSxPQUFPLENBQUMsUUFBUTtJQUVoQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsTUFBTTtJQVBoQixPQUFPLENBQUMsS0FBSyxDQUFjO0lBQzNCLE9BQU8sQ0FBQyxPQUFPLENBQXFCO0lBRXBDLFlBQ1UsUUFBUSxFQUFFLDZCQUE2QixFQUMvQyxXQUFXLEVBQUUsTUFBTSxFQUNYLFNBQVMsR0FBRSxlQUFzQyxFQUNqRCxNQUFNLDhDQUFrRCxFQU1qRTtJQUVZLFdBQVcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQUlwRTtJQUVLLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRzFCO0NBQ0YifQ==

package/dest/verifier/queued_chonk_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queued_chonk_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/queued_chonk_verifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACtH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,8BAA8B,CAAC;AAGtC,yFAAyF;AACzF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,6BAA6B,CAAY;IACjD,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAGrB;IACH,OAAO,CAAC,mBAAmB,CAGxB;IAEH,OAAO,CAAC,kBAAkB,CAAiE;IAE3F,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAsB,EAkB9D;IAED,qBAAqB,CAAC,MAAM,EAAE,0BAA0B,QASvD;IAED,OAAO,CAAC,SAAS,CAcf;CACH;AAED,qBAAa,iBAAkB,YAAW,6BAA6B;IAKnE,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAqB;IAEpC,YACU,QAAQ,EAAE,6BAA6B,EAC/C,WAAW,EAAE,MAAM,EACX,SAAS,GAAE,eAAsC,EACjD,MAAM,8CAAkD,EAMjE;IAEY,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAIpE;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1B;CACF"}

package/dest/verifier/queued_chonk_verifier.js

@@ -0,0 +1,102 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import { Attributes, Metrics, createUpDownCounterWithDefault, getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { createHistogram } from 'node:perf_hooks';
+/** Records verification timing and failure metrics for an IVC (chonk) proof verifier. */ export 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);
+        this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME);
+        this.ivcFailureCount = createUpDownCounterWithDefault(meter, Metrics.IVC_VERIFIER_FAILURE_COUNT);
+        this.aggDurationMetrics = {
+            avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG),
+            max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX),
+            min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN),
+            p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50),
+            p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90)
+        };
+        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(verifier, concurrency, 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 ${concurrency} concurrent verifiers`);
+        this.queue.start(concurrency);
+    }
+    async verifyProof(tx) {
+        const result = await this.queue.put(()=>this.verifier.verifyProof(tx));
+        this.metrics.recordIVCVerification(result);
+        return result;
+    }
+    async stop() {
+        await this.queue.end();
+        await this.verifier.stop();
+    }
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@aztec-labs/bb-prover",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/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",
+    "./debug": "./dest/bb/bb_js_debug.js"
+  },
+  "bin": {
+    "bb-cli": "./dest/bb/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "BB Prover",
+    "tsconfig": "./tsconfig.json"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "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}"
+  },
+  "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"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/noir-protocol-circuits-types": "6.0.0-nightly.20260829",
+    "@aztec-labs/simulator": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "@aztec/bb.js": "6.0.0-nightly.20260826",
+    "@aztec/noir-noirc_abi": "6.0.0-nightly.20260826",
+    "@aztec/noir-types": "6.0.0-nightly.20260826",
+    "commander": "^12.1.0",
+    "msgpackr": "^1.11.2",
+    "pako": "^2.1.0",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@aztec-labs/noir-contracts.js": "6.0.0-nightly.20260829",
+    "@aztec-labs/noir-test-contracts.js": "6.0.0-nightly.20260829",
+    "@aztec-labs/protocol-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/world-state": "6.0.0-nightly.20260829",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@types/source-map-support": "^0.5.10",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3",
+    "viem": "npm:@aztec/viem@2.38.2"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -0,0 +1,235 @@
+import type { AvmStat } from '@aztec/bb.js';
+
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import {
+  type MeasuredSimulatorFactory,
+  PublicTxSimulationTester,
+  SimpleContractDataSource,
+  type TestEnqueuedCall,
+  type TestExecutorMetrics,
+  type TestPrivateInsertions,
+} from '@aztec-labs/simulator/public/fixtures';
+import { AvmSimulatorPool, MeasuredPublicTxSimulator } from '@aztec-labs/simulator/server';
+import type { PublicTxResult } from '@aztec-labs/simulator/server';
+import { AvmCircuitInputs, AvmCircuitPublicInputs, PublicSimulatorConfig } from '@aztec-labs/stdlib/avm';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Gas } from '@aztec-labs/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec-labs/stdlib/interfaces/server';
+import type { GlobalVariables } from '@aztec-labs/stdlib/tx';
+import { NativeWorldStateService } from '@aztec-labs/world-state';
+import path from 'path';
+
+import { BBJsFactory } from '../bb/bb_js_backend.js';
+
+const BB_PATH = path.resolve('../../labs-aztec-toolchain/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, {
+    debugDir: process.env.BB_DEBUG_OUTPUT_DIR,
+    logger: createLogger('bb-prover:avm-proving-tester'),
+  });
+
+  constructor(
+    private checkCircuitOnly: boolean,
+    contractDataSource: SimpleContractDataSource,
+    merkleTrees: MerkleTreeWriteOperations,
+    globals?: GlobalVariables,
+    metrics?: TestExecutorMetrics,
+    simulatorFactory?: MeasuredSimulatorFactory,
+  ) {
+    super(merkleTrees, contractDataSource, globals, metrics, simulatorFactory, provingConfig);
+  }
+
+  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 worldStateService.fork();
+
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+    const simulatorFactory: MeasuredSimulatorFactory = (mt, cdb, g, m, c) =>
+      new MeasuredPublicTxSimulator(avmSimulator, g, cdb, mt.getRevision().forkId, m, c, undefined);
+
+    const tester = new AvmProvingTester(
+      checkCircuitOnly,
+      contractDataSource,
+      merkleTrees,
+      globals,
+      metrics,
+      simulatorFactory,
+    );
+    tester.avmSimulator = avmSimulator;
+    return tester;
+  }
+
+  public override async close(): Promise<void> {
+    const results = await Promise.allSettled([super.close(), this.bbJsFactory.destroy()]);
+    const errors = results.flatMap(result => (result.status === 'rejected' ? [result.reason] : []));
+    if (errors.length > 0) {
+      throw new AggregateError(errors, `Failed to close AVM proving tester`);
+    }
+  }
+
+  /**
+   * 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 [];
+    }
+
+    await using instance = await this.bbJsFactory.getInstance();
+    const { proof, stats } = await instance.generateAvmProof(inputsBuffer);
+    this.recordProverMetrics(stats, txLabel);
+    return proof;
+  }
+
+  async verify(proof: Uint8Array[], publicInputs: AvmCircuitPublicInputs): Promise<void> {
+    if (this.checkCircuitOnly) {
+      // Check-circuit did not generate a proof; nothing to verify.
+      return;
+    }
+    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(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[],
+    appCalls: TestEnqueuedCall[],
+    teardownCall: TestEnqueuedCall | undefined,
+    expectRevert: boolean | undefined,
+    feePayer = sender,
+    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}`);
+
+    if (!disableRevertCheck) {
+      expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+    }
+
+    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,
+    gasLimits?: Gas,
+  ) {
+    return await this.simProveVerify(
+      sender,
+      setupCalls ?? [],
+      appCalls ?? [],
+      teardownCall,
+      undefined,
+      feePayer,
+      privateInsertions,
+      txLabel,
+      true,
+      gasLimits,
+    );
+  }
+
+  public async simProveVerifyAppLogic(
+    appCall: TestEnqueuedCall,
+    expectRevert?: boolean,
+    txLabel: string = 'unlabeledTx',
+    gasLimits?: Gas,
+  ) {
+    await this.simProveVerify(
+      /*sender=*/ AztecAddress.fromNumberUnsafe(42),
+      /*setupCalls=*/ [],
+      [appCall],
+      undefined,
+      expectRevert,
+      /*feePayer=*/ undefined,
+      /*privateInsertions=*/ undefined,
+      txLabel,
+      /*disableRevertCheck=*/ false,
+      gasLimits,
+    );
+  }
+}