@aztec/simulator 3.0.0-nightly.20251205 → 3.0.0-nightly.20251206

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -20,7 +20,7 @@ import {
 } from '../avm/fixtures/utils.js';
 import { PublicContractsDB } from '../public_db_sources.js';
 import { MeasuredCppPublicTxSimulator } from '../public_tx_simulator/cpp_public_tx_simulator.js';
-import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
+import { MeasuredCppVsTsPublicTxSimulator } from '../public_tx_simulator/cpp_vs_ts_public_tx_simulator.js';
 import type { MeasuredPublicTxSimulatorInterface } from '../public_tx_simulator/public_tx_simulator_interface.js';
 import { TestExecutorMetrics } from '../test_executor_metrics.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
@@ -45,6 +45,17 @@ const defaultConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
   collectStatistics: false,
 });
 
+/**
+ * Factory type for creating a MeasuredPublicTxSimulatorInterface.
+ */
+export type MeasuredSimulatorFactory = (
+  merkleTree: MerkleTreeWriteOperations,
+  contractsDB: PublicContractsDB,
+  globals: GlobalVariables,
+  metrics: TestExecutorMetrics,
+  config: PublicSimulatorConfig,
+) => MeasuredPublicTxSimulatorInterface;
+
 /**
  * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the PublicTxSimulator.
  * It provides an interface for simulating one transaction at a time and maintains state between subsequent
@@ -60,15 +71,17 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     contractDataSource: SimpleContractDataSource,
     globals: GlobalVariables = defaultGlobals(),
     private metrics: TestExecutorMetrics = new TestExecutorMetrics(),
-    useCppSimulator: boolean = false,
+    simulatorFactory?: MeasuredSimulatorFactory,
     config: PublicSimulatorConfig = defaultConfig,
   ) {
     super(contractDataSource, merkleTree);
 
     const contractsDB = new PublicContractsDB(contractDataSource);
-    this.simulator = useCppSimulator
-      ? new MeasuredCppPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config)
-      : new MeasuredPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
+    if (simulatorFactory) {
+      this.simulator = simulatorFactory(merkleTree, contractsDB, globals, this.metrics, config);
+    } else {
+      this.simulator = new MeasuredCppPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
+    }
   }
 
   public static async create(
@@ -80,7 +93,10 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTree = await worldStateService.fork();
-    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, useCppSimulator, config);
+    const simulatorFactory: MeasuredSimulatorFactory = useCppSimulator
+      ? (mt, cdb, g, m, c) => new MeasuredCppPublicTxSimulator(mt, cdb, g, m, c)
+      : (mt, cdb, g, m, c) => new MeasuredCppVsTsPublicTxSimulator(mt, cdb, g, m, c);
+    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, simulatorFactory, config);
   }
 
   public setMetricsPrefix(prefix: string) {
@@ -137,6 +153,11 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     const txLabelWithCount = `${txLabel}/${this.txCount - 1}`;
     const fullTxLabel = this.metricsPrefix ? `${this.metricsPrefix}/${txLabelWithCount}` : txLabelWithCount;
 
+    if (!this.simulator) {
+      throw new Error(
+        'No simulator configured. Pass a simulatorFactory to the constructor or use PublicTxSimulationTester.create()',
+      );
+    }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
     // Something like this is often useful for debugging:

package/src/public/fixtures/simple_contract_data_source.ts

@@ -91,19 +91,17 @@ export class SimpleContractDataSource implements ContractDataSource {
     return this.contractArtifacts.get(contractInstance!.currentContractClassId.toString());
   }
 
-  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string> {
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
     const contractInstance = await this.getContract(address);
     if (!contractInstance) {
-      this.logger.warn(
-        `Couldn't get fn name for debugging. Contract not in tester's ContractDataSource. Using selector:${selector} instead...`,
-      );
-      return `selector:${selector.toString()}`;
+      this.logger.warn(`Couldn't get fn name for debugging. Contract not in tester's ContractDataSource.`);
+      return undefined;
     }
     const key = `${contractInstance.currentContractClassId.toString()}:${selector.toString()}`;
     const fnName = this.debugFunctionName.get(key);
     if (!fnName) {
-      this.logger.warn(`Couldn't get fn name for debugging. Using selector:${selector} instead...`);
-      return selector.toString();
+      this.logger.warn(`Couldn't get fn name for debugging...`);
+      return undefined;
     }
     return fnName;
   }

package/src/public/fixtures/token_test.ts

@@ -7,11 +7,17 @@ import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
 
+export type TokenTestOptions = {
+  /** Skip return value assertions in balance checks (useful for benchmarking with collectCallMetadata=false) */
+  skipReturnValueAssertions?: boolean;
+};
+
 export async function tokenTest(
   tester: PublicTxSimulationTester,
   logger: Logger,
   tokenArtifact: ContractArtifact,
   expectToBeTrue: (x: boolean) => void,
+  options: TokenTestOptions = {},
 ) {
   const timer = new Timer();
 
@@ -36,7 +42,7 @@ export async function tokenTest(
     ],
   );
   expectToBeTrue(mintResult.revertCode.isOK());
-  await checkBalance(tester, token, sender, sender, mintAmount, expectToBeTrue);
+  await checkBalance(tester, token, sender, sender, mintAmount, expectToBeTrue, options);
 
   const authwitNonce = new Fr(0);
   const transferAmount = 50n;
@@ -54,8 +60,8 @@ export async function tokenTest(
     ],
   );
   expectToBeTrue(transferResult.revertCode.isOK());
-  await checkBalance(tester, token, sender, receiver, mintAmount - transferAmount, expectToBeTrue);
-  await checkBalance(tester, token, sender, receiver, transferAmount, expectToBeTrue);
+  await checkBalance(tester, token, sender, sender, mintAmount - transferAmount, expectToBeTrue, options);
+  await checkBalance(tester, token, sender, receiver, transferAmount, expectToBeTrue, options);
 
   // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
   const burnResult = await tester.executeTxWithLabel(
@@ -71,7 +77,7 @@ export async function tokenTest(
     ],
   );
   expectToBeTrue(burnResult.revertCode.isOK());
-  await checkBalance(tester, token, sender, receiver, 0n, expectToBeTrue);
+  await checkBalance(tester, token, sender, receiver, 0n, expectToBeTrue, options);
 
   logger.info(`TokenContract test took ${timer.ms()}ms\n`);
 }
@@ -116,6 +122,7 @@ async function checkBalance(
   account: AztecAddress,
   expectedBalance: bigint,
   expectToBeTrue: (x: boolean) => void,
+  options: TokenTestOptions = {},
 ) {
   // Strictly simulate this! No need to "execute" (aka prove if using AvmProvingTester subclass).
   const balResult = await tester.simulateTxWithLabel(
@@ -132,8 +139,10 @@ async function checkBalance(
     ],
   );
   expectToBeTrue(balResult.revertCode.isOK());
-  // should be 1 call with 1 return value that is expectedBalance
-  expectToBeTrue(balResult.appLogicReturnValues.length == 1);
-  expectToBeTrue(balResult.appLogicReturnValues[0].values!.length == 1);
-  expectToBeTrue(balResult.appLogicReturnValues[0].values![0].toBigInt() == expectedBalance);
+  if (!options.skipReturnValueAssertions) {
+    // should be 1 call with 1 return value that is expectedBalance
+    const appLogicReturnValues = balResult.getAppLogicReturnValues();
+    expectToBeTrue(appLogicReturnValues.length === 1);
+    expectToBeTrue(appLogicReturnValues[0].values?.[0]?.toBigInt() === expectedBalance);
+  }
 }

package/src/public/index.ts

@@ -1,6 +1,10 @@
 export { PublicContractsDB } from './public_db_sources.js';
 export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator/index.js';
+export {
+  CppPublicTxSimulator,
+  type PublicTxSimulatorInterface,
+  TelemetryCppPublicTxSimulator,
+} from './public_tx_simulator/index.js';
 export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';
 export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/src/public/public_processor/public_processor.ts

@@ -51,9 +51,9 @@ import { AssertionError } from 'assert';
 
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import {
-  type PublicTxSimulator,
   type PublicTxSimulatorConfig,
-  TelemetryPublicTxSimulator,
+  type PublicTxSimulatorInterface,
+  TelemetryCppPublicTxSimulator,
 } from '../public_tx_simulator/index.js';
 import { GuardedMerkleTreeOperations } from './guarded_merkle_tree.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
@@ -99,8 +99,8 @@ export class PublicProcessorFactory {
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     config?: Partial<PublicTxSimulatorConfig>,
-  ): PublicTxSimulator {
-    return new TelemetryPublicTxSimulator(merkleTree, contractsDB, globalVariables, this.telemetryClient, config);
+  ): PublicTxSimulatorInterface {
+    return new TelemetryCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, this.telemetryClient, config);
   }
 }
 
@@ -122,7 +122,7 @@ export class PublicProcessor implements Traceable {
     protected globalVariables: GlobalVariables,
     private guardedMerkleTree: GuardedMerkleTreeOperations,
     protected contractsDB: PublicContractsDB,
-    protected publicTxSimulator: PublicTxSimulator,
+    protected publicTxSimulator: PublicTxSimulatorInterface,
     private dateProvider: DateProvider,
     telemetryClient: TelemetryClient = getTelemetryClient(),
     private log = createLogger('simulator:public-processor'),
@@ -521,13 +521,9 @@ export class PublicProcessor implements Traceable {
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
 
-    const { hints, publicInputs, gasUsed, revertCode, revertReason, appLogicReturnValues } =
-      await this.publicTxSimulator.simulate(tx);
-
-    if (!hints) {
-      this.metrics.recordFailedTx();
-      throw new Error('Avm proving result was not generated.');
-    }
+    const result = await this.publicTxSimulator.simulate(tx);
+    // TODO: use the callStackMetadata here to extract more data about public execution
+    const { hints, publicInputs, gasUsed, revertCode /*callStackMetadata*/ } = result;
 
     const contractClassLogs = revertCode.isOK()
       ? tx.getContractClassLogs()
@@ -539,9 +535,13 @@ export class PublicProcessor implements Traceable {
     );
 
     // TODO(fcarreiro): remove phase count metric.
-    const phaseCount = 1;
     const durationMs = timer.ms();
-    this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
+    this.metrics.recordTx(/*phaseCount=*/ 1, durationMs, gasUsed.publicGas);
+
+    // Extract the return values from the call stack metadata.
+    const appLogicReturnValues: NestedProcessReturnValues[] = result.getAppLogicReturnValues();
+    // Extract the revert reason from the call stack metadata.
+    const revertReason = result.findRevertReason();
 
     const processedTx = makeProcessedTxFromTxWithPublicCalls(
       tx,
@@ -551,7 +551,7 @@ export class PublicProcessor implements Traceable {
       revertReason,
     );
 
-    return [processedTx, appLogicReturnValues ?? []];
+    return [processedTx, appLogicReturnValues];
   }
 
   /**
@@ -559,7 +559,7 @@ export class PublicProcessor implements Traceable {
    */
   private static generateProvingRequest(
     publicInputs: AvmCircuitPublicInputs,
-    hints: AvmExecutionHints,
+    hints: AvmExecutionHints = AvmExecutionHints.empty(),
   ): AvmProvingRequest {
     return {
       type: ProvingRequestType.PUBLIC_VM,

package/src/public/public_tx_simulator/cpp_public_tx_simulator.ts

@@ -1,9 +1,7 @@
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { writeTestData } from '@aztec/foundation/testing/files';
-import { avmSimulate, avmSimulateWithHintedDbs } from '@aztec/native';
+import { type Logger, createLogger, logLevel } from '@aztec/foundation/log';
+import { avmSimulate } from '@aztec/native';
 import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import {
-  AvmCircuitInputs,
   AvmFastSimulationInputs,
   AvmTxHint,
   type PublicSimulatorConfig,
@@ -12,11 +10,13 @@ import {
 } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import type { GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
 import { WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
+import { ExecutorMetrics } from '../executor_metrics.js';
 import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
 import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
@@ -30,9 +30,6 @@ import type {
  * C++ implementation of PublicTxSimulator using the C++ simulator.
  * The C++ simulator accesses the world state directly/natively within C++.
  * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
- *
- * TODO(dbanks12): for now this still simulates first in TS to generate hints and public inputs,
- * since the C++ simulator doesn't have hinting & PI generation logic yet.
  */
 export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
   protected override log: Logger;
@@ -59,33 +56,6 @@ export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxS
       txHash,
     });
 
-    // TODO(dbanks12): remove the first run with TS that hints!
-    // Run TS simulation to generate hints and public inputs
-    this.log.debug(`Running TS simulation for tx ${txHash}`);
-
-    // create checkpoint for ws
-    let tsResult: PublicTxResult | undefined;
-    let tsStateRef: StateReference | undefined;
-    await this.merkleTree.createCheckpoint();
-    this.contractsDB.createCheckpoint();
-    try {
-      // Run the full TypeScript simulation using the parent class
-      // This will modify the merkle tree with the transaction's state changes
-      tsResult = await super.simulate(tx);
-      this.log.debug(`TS simulation completed for tx ${txHash}`);
-
-      tsStateRef = await this.merkleTree.getStateReference(); // capture tree roots for later comparsion
-    } catch (error: any) {
-      this.log.warn(`TS simulation failed, but still continuing with C++ simulation: ${error.message} ${error.stack}`);
-    } finally {
-      // revert checkpoint for ws and clear contract db changes
-      // (cpp should reapply exactly the same changes if there are no bugs)
-      await this.merkleTree.revertCheckpoint();
-      this.contractsDB.revertCheckpoint();
-    }
-
-    this.log.debug(`Running C++ simulation for tx ${txHash}`);
-
     // Using the "as WorldStateRevisionWithHandle" is a bit of a "trust me bro", hence the assert.
     let wsRevision = this.merkleTree.getRevision();
     assert(
@@ -95,7 +65,7 @@ export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxS
     const wsCppHandle = (wsRevision as WorldStateRevisionWithHandle).handle;
     wsRevision = wsRevision.toWorldStateRevision(); // for msgpack serialization, we don't include the handle in the type
 
-    this.log.debug(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
+    this.log.trace(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
 
     // Create the fast simulation inputs
     const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
@@ -112,62 +82,32 @@ export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxS
     const contractProvider = new ContractProviderForCpp(this.contractsDB, this.globalVariables);
 
     // Serialize to msgpack and call the C++ simulator
-    this.log.verbose(`Serializing fast simulation inputs to msgpack...`);
+    this.log.trace(`Serializing fast simulation inputs to msgpack...`);
     const inputBuffer = fastSimInputs.serializeWithMessagePack();
 
     let resultBuffer: Buffer;
     try {
-      this.log.verbose(`Calling C++ simulator for tx ${txHash}`);
-      resultBuffer = await avmSimulate(inputBuffer, contractProvider, wsCppHandle);
+      this.log.debug(`Calling C++ simulator for tx ${txHash}`);
+      resultBuffer = await avmSimulate(inputBuffer, contractProvider, wsCppHandle, logLevel);
     } catch (error: any) {
       throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
     }
 
     // If we've reached this point, C++ succeeded during simulation,
-    // so we assert that TS also succeeded.
-    assert(tsResult !== undefined, 'TS simulation should have succeeded if C++ succeeded');
-    assert(tsStateRef !== undefined, 'TS state reference should have been captured if C++ succeeded');
 
     // Deserialize the msgpack result
-    this.log.verbose(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
+    this.log.trace(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
     const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
-    // Write testdata if AZTEC_WRITE_TESTDATA=1.
-    writeTestData(
-      `barretenberg/cpp/src/barretenberg/vm2/testing/tx_result_${txHash}.testdata.bin`,
-      resultBuffer,
-      /*raw=*/ true,
-    );
-    this.log.verbose(`Deserializing C++ result to PublicTxResult...`);
+    this.log.trace(`Deserializing C++ result to PublicTxResult...`);
     const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
-    this.log.verbose(`Done.`);
-    // TODO(fcarreiro): complete this.
-    assert(cppResult.revertCode.equals(tsResult.revertCode));
-    assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
-    assert(cppResult.gasUsed.publicGas.equals(tsResult.gasUsed.publicGas));
-    assert(cppResult.gasUsed.teardownGas.equals(tsResult.gasUsed.teardownGas));
-    assert(cppResult.gasUsed.billedGas.equals(tsResult.gasUsed.billedGas));
-    assert(cppResult.publicInputs.toBuffer().equals(tsResult.publicInputs.toBuffer()));
-    if (this.config?.collectCallMetadata) {
-      assert(cppResult.appLogicReturnValues.length == tsResult.appLogicReturnValues.length);
-      assert(cppResult.appLogicReturnValues.every((v, i) => v.equals(tsResult.appLogicReturnValues[i])));
-    }
 
-    // Confirm that tree roots match
-    const cppStateRef = await this.merkleTree.getStateReference();
-    assert(
-      cppStateRef.equals(tsStateRef),
-      `Tree roots mismatch between TS and C++ public simulations for tx ${txHash}`,
-    );
-
-    this.log.debug(`C++ simulation completed for tx ${txHash}`, {
+    this.log.trace(`C++ simulation completed for tx ${txHash}`, {
       txHash,
-      reverted: !tsResult.revertCode.isOK(),
-      tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
-      cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+      reverted: !cppResult.revertCode.isOK(),
+      cppGasUsed: cppResult.gasUsed.totalGas.l2Gas,
     });
 
-    // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
-    return tsResult;
+    return cppResult;
   }
 }
 
@@ -195,112 +135,21 @@ export class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator implement
 }
 
 /**
- * C++ implementation of PublicTxSimulator using pre-collected hints.
- * This implementation runs TS simulation first to collect all hints,
- * then passes the complete AvmCircuitInputs (hints + public inputs)
- * to C++ to run hinted simulation.
+ * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
  */
-export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
-  protected override log: Logger;
+export class TelemetryCppPublicTxSimulator extends MeasuredCppPublicTxSimulator {
+  /* tracer needed by trackSpans */
+  public readonly tracer: Tracer;
 
   constructor(
     merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
     config?: Partial<PublicSimulatorConfig>,
   ) {
-    super(merkleTree, contractsDB, globalVariables, config);
-    this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
-  }
-
-  /**
-   * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
-   *
-   * This implementation:
-   * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
-   * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
-   *
-   * @param tx - The transaction to simulate.
-   * @returns The result of the transaction's public execution.
-   */
-  public override async simulate(tx: Tx): Promise<PublicTxResult> {
-    const txHash = this.computeTxHash(tx);
-    this.log.debug(`C++ hinted DB simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
-      txHash,
-    });
-
-    // First, run TS simulation to generate hints and public inputs
-    this.log.debug(`Running TS simulation for tx ${txHash}`);
-
-    // Run the full TypeScript simulation using the parent class
-    // This will modify the merkle tree with the transaction's state changes
-    const tsResult = await super.simulate(tx);
-    this.log.debug(`TS simulation succeeded for tx ${txHash}`);
-
-    // Extract the full AvmCircuitInputs from the TS result
-    const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints!, tsResult.publicInputs);
-
-    // Second, run C++ simulation with hinted DBs
-    this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);
-
-    // Serialize to msgpack and call the C++ simulator
-    const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
-
-    let resultBuffer: Buffer;
-    try {
-      resultBuffer = await avmSimulateWithHintedDbs(inputBuffer);
-    } catch (error: any) {
-      throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
-    }
-
-    // Deserialize the msgpack result
-    const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
-    const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
-
-    assert(cppResult.revertCode.equals(tsResult.revertCode));
-    assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
-
-    this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
-      txHash,
-      reverted: !tsResult.revertCode.isOK(),
-      tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
-      cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
-    });
-
-    // TODO(fcarreiro): complete this.
-    return tsResult;
-  }
-}
-
-/**
- * Class to record metrics for simulation.
- *
- * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
- * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
- * to TS for tracking.
- */
-export class MeasuredCppPublicTxSimulatorHintedDbs
-  extends CppPublicTxSimulatorHintedDbs
-  implements MeasuredPublicTxSimulatorInterface
-{
-  constructor(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
-    globalVariables: GlobalVariables,
-    protected readonly metrics: ExecutorMetricsInterface,
-    config?: Partial<PublicSimulatorConfig>,
-  ) {
-    super(merkleTree, contractsDB, globalVariables, config);
-  }
-
-  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
-    this.metrics.startRecordingTxSimulation(txLabel);
-    let result: PublicTxResult | undefined;
-    try {
-      result = await super.simulate(tx);
-    } finally {
-      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
-    }
-    return result;
+    const metrics = new ExecutorMetrics(telemetryClient, 'CppPublicTxSimulator');
+    super(merkleTree, contractsDB, globalVariables, metrics, config);
+    this.tracer = metrics.tracer;
   }
 }

package/src/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.ts

@@ -0,0 +1,132 @@
+import { type Logger, createLogger, logLevel } from '@aztec/foundation/log';
+import { avmSimulateWithHintedDbs } from '@aztec/native';
+import {
+  AvmCircuitInputs,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  deserializeFromMessagePack,
+} from '@aztec/stdlib/avm';
+import { SimulationError } from '@aztec/stdlib/errors';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+
+import { strict as assert } from 'assert';
+
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+import type {
+  MeasuredPublicTxSimulatorInterface,
+  PublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
+
+/**
+ * C++ implementation of PublicTxSimulator using pre-collected hints.
+ * This implementation runs TS simulation first to collect all hints,
+ * then passes the complete AvmCircuitInputs (hints + public inputs)
+ * to C++ to run hinted simulation.
+ */
+export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
+  protected override log: Logger;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+    this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
+  }
+
+  /**
+   * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
+   *
+   * This implementation:
+   * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
+   * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
+   *
+   * @param tx - The transaction to simulate.
+   * @returns The result of the transaction's public execution.
+   */
+  public override async simulate(tx: Tx): Promise<PublicTxResult> {
+    const txHash = this.computeTxHash(tx);
+    this.log.debug(`C++ hinted DB simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+      txHash,
+    });
+
+    // First, run TS simulation to generate hints and public inputs
+    this.log.debug(`Running TS simulation for tx ${txHash}`);
+
+    // Run the full TypeScript simulation using the parent class
+    // This will modify the merkle tree with the transaction's state changes
+    const tsResult = await super.simulate(tx);
+    this.log.debug(`TS simulation succeeded for tx ${txHash}`);
+
+    // Extract the full AvmCircuitInputs from the TS result
+    const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints!, tsResult.publicInputs);
+
+    // Second, run C++ simulation with hinted DBs
+    this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);
+
+    // Serialize to msgpack and call the C++ simulator
+    const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
+
+    let resultBuffer: Buffer;
+    try {
+      resultBuffer = await avmSimulateWithHintedDbs(inputBuffer, logLevel);
+    } catch (error: any) {
+      throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
+    }
+
+    // Deserialize the msgpack result
+    const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
+    const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
+
+    assert(cppResult.revertCode.equals(tsResult.revertCode));
+    assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
+
+    this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
+      txHash,
+      reverted: !tsResult.revertCode.isOK(),
+      tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+      cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+    });
+
+    // TODO(fcarreiro): complete this.
+    return tsResult;
+  }
+}
+
+/**
+ * Class to record metrics for simulation.
+ *
+ * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
+ * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
+ * to TS for tracking.
+ */
+export class MeasuredCppPublicTxSimulatorHintedDbs
+  extends CppPublicTxSimulatorHintedDbs
+  implements MeasuredPublicTxSimulatorInterface
+{
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    protected readonly metrics: ExecutorMetricsInterface,
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let result: PublicTxResult | undefined;
+    try {
+      result = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
+    }
+    return result;
+  }
+}