@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.fce3e4f

package/src/public/public_processor/public_processor.ts

@@ -7,7 +7,14 @@ import { DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type AvmProvingRequest,
+  PublicDataWrite,
+  PublicSimulatorConfig,
+} from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { computeTransactionFee } from '@aztec/stdlib/fees';
@@ -18,6 +25,7 @@ import type {
   PublicProcessorValidator,
   SequencerConfig,
 } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type FailedTx,
@@ -26,7 +34,6 @@ import {
   type ProcessedTx,
   StateReference,
   Tx,
-  TxExecutionPhase,
   makeProcessedTxFromPrivateOnlyTx,
   makeProcessedTxFromTxWithPublicCalls,
 } from '@aztec/stdlib/tx';
@@ -70,23 +77,12 @@ export class PublicProcessorFactory {
   public create(
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
-    config: {
-      skipFeeEnforcement: boolean;
-      clientInitiatedSimulation: boolean;
-      proverId?: Fr;
-      maxDebugLogMemoryReads?: number;
-    },
+    config: PublicSimulatorConfig,
   ): PublicProcessor {
     const contractsDB = new PublicContractsDB(this.contractDataSource);
 
     const guardedFork = new GuardedMerkleTreeOperations(merkleTree);
-    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, {
-      proverId: config.proverId,
-      doMerkleOperations: true,
-      skipFeeEnforcement: config.skipFeeEnforcement,
-      clientInitiatedSimulation: config.clientInitiatedSimulation,
-      maxDebugLogMemoryReads: config.maxDebugLogMemoryReads,
-    });
+    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, config);
 
     return new PublicProcessor(
       globalVariables,
@@ -232,12 +228,15 @@ export class PublicProcessor implements Traceable {
       // Note: We use the underlying fork here not the guarded one, this ensures that it's not impacted by stopping the guarded version
       const checkpoint = await ForkCheckpoint.new(this.guardedMerkleTree.getUnderlyingFork());
       const startStateReference = await this.guardedMerkleTree.getUnderlyingFork().getStateReference();
+      this.contractsDB.createCheckpoint();
 
       try {
         const [processedTx, returnValues] = await this.processTx(tx, deadline);
 
+        const txBlobFields = processedTx.txEffect.getNumBlobFields();
+
         // If the actual size of this tx would exceed block size, skip it
-        const txSize = processedTx.txEffect.getDASize();
+        const txSize = txBlobFields * Fr.SIZE_IN_BYTES;
         if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
           this.log.debug(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
             txHash,
@@ -247,11 +246,11 @@ export class PublicProcessor implements Traceable {
           });
           // Need to revert the checkpoint here and don't go any further
           await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
           continue;
         }
 
         // If the actual blob fields of this tx would exceed the limit, skip it
-        const txBlobFields = processedTx.txEffect.toBlobFields().length;
         if (maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
           this.log.debug(
             `Skipping processed tx ${txHash} with ${txBlobFields} blob fields due to max blob fields limit.`,
@@ -264,6 +263,7 @@ export class PublicProcessor implements Traceable {
           );
           // Need to revert the checkpoint here and don't go any further
           await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
           continue;
         }
 
@@ -298,6 +298,9 @@ export class PublicProcessor implements Traceable {
           // This needs to be done directly on the underlying fork as the guarded fork has been stopped.
           await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
 
+          // Revert any contracts added to the DB for the tx.
+          this.contractsDB.revertCheckpoint();
+
           // Ensure we're at the same state as when we started processing this tx.
           await this.checkWorldStateUnchanged(startStateReference, txHash, err);
 
@@ -308,6 +311,7 @@ export class PublicProcessor implements Traceable {
         // Roll back state to start of TX before proceeding to next TX
         await checkpoint.revert();
         await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
+        this.contractsDB.revertCheckpoint();
         const errorMessage = err instanceof Error || err instanceof AssertionError ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
         failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
@@ -318,8 +322,7 @@ export class PublicProcessor implements Traceable {
       } finally {
         // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was previously reverted
         await checkpoint.commit();
-        // The tx-level contracts cache should not live on to the next tx
-        this.contractsDB.clearContractsForTx();
+        this.contractsDB.commitCheckpointOkIfNone();
       }
     }
 
@@ -507,10 +510,7 @@ export class PublicProcessor implements Traceable {
     // Fee payment insertion has already been done. Do the rest.
     await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
 
-    // Add any contracts registered/deployed in this private-only tx to the block-level cache
-    // (add to tx-level cache and then commit to block-level cache)
     await this.contractsDB.addNewContracts(tx);
-    this.contractsDB.commitContractsForTx();
 
     return [processedTx, undefined];
   }
@@ -521,22 +521,14 @@ export class PublicProcessor implements Traceable {
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
 
-    const { avmProvingRequest, gasUsed, revertCode, revertReason, processedPhases } =
+    const { hints, publicInputs, gasUsed, revertCode, revertReason, appLogicReturnValues } =
       await this.publicTxSimulator.simulate(tx);
 
-    if (!avmProvingRequest) {
+    if (!hints) {
       this.metrics.recordFailedTx();
       throw new Error('Avm proving result was not generated.');
     }
 
-    processedPhases.forEach(phase => {
-      if (phase.reverted) {
-        this.metrics.recordRevertedPhase(phase.phase);
-      } else {
-        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs ?? 0);
-      }
-    });
-
     const contractClassLogs = revertCode.isOK()
       ? tx.getContractClassLogs()
       : tx.getSplitContractClassLogs(false /* revertible */);
@@ -546,14 +538,32 @@ export class PublicProcessor implements Traceable {
         .map(log => ContractClassPublishedEvent.fromLog(log)),
     );
 
-    const phaseCount = processedPhases.length;
+    // TODO(fcarreiro): remove phase count metric.
+    const phaseCount = 1;
     const durationMs = timer.ms();
     this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
 
-    const processedTx = makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
+    const processedTx = makeProcessedTxFromTxWithPublicCalls(
+      tx,
+      PublicProcessor.generateProvingRequest(publicInputs, hints),
+      gasUsed,
+      revertCode,
+      revertReason,
+    );
 
-    const returnValues = processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+    return [processedTx, appLogicReturnValues ?? []];
+  }
 
-    return [processedTx, returnValues];
+  /**
+   * Generate the proving request for the AVM circuit.
+   */
+  private static generateProvingRequest(
+    publicInputs: AvmCircuitPublicInputs,
+    hints: AvmExecutionHints,
+  ): AvmProvingRequest {
+    return {
+      type: ProvingRequestType.PUBLIC_VM,
+      inputs: new AvmCircuitInputs(hints, publicInputs),
+    };
   }
 }

package/src/public/public_tx_simulator/contract_provider_for_cpp.ts

@@ -0,0 +1,162 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { ContractProvider } from '@aztec/native';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractDeploymentData } from '@aztec/stdlib/contract';
+import { ContractClassLog, ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+
+export class ContractProviderForCpp implements ContractProvider {
+  private log: Logger = createLogger('simulator:contract_provider_for_cpp');
+
+  constructor(
+    private contractsDB: PublicContractsDB,
+    private globalVariables: GlobalVariables,
+  ) {}
+
+  public getContractInstance = async (address: string): Promise<Buffer | undefined> => {
+    this.log.debug(`Contract provider callback: getContractInstance(${address})`);
+
+    const aztecAddr = AztecAddress.fromString(address);
+
+    const instance = await this.contractsDB.getContractInstance(aztecAddr, this.globalVariables.timestamp);
+
+    if (!instance) {
+      this.log.debug(`Contract instance not found: ${address}`);
+      return undefined;
+    }
+
+    return serializeWithMessagePack(instance);
+  };
+
+  public getContractClass = async (classId: string): Promise<Buffer | undefined> => {
+    this.log.debug(`Contract provider callback: getContractClass(${classId})`);
+
+    // Parse classId string to Fr
+    const classIdFr = Fr.fromString(classId);
+
+    // Fetch contract class from the contracts DB
+    const contractClass = await this.contractsDB.getContractClass(classIdFr);
+
+    if (!contractClass) {
+      this.log.debug(`Contract class not found: ${classId}`);
+      return undefined;
+    }
+
+    return serializeWithMessagePack(contractClass);
+  };
+
+  public addContracts = async (contractDeploymentDataBuffer: Buffer): Promise<void> => {
+    this.log.debug(`Contract provider callback: addContracts`);
+
+    const rawData: any = deserializeFromMessagePack(contractDeploymentDataBuffer);
+
+    // Construct class instances using the from method
+    const contractDeploymentData = this.reconstructContractDeploymentData(rawData);
+
+    // Add contracts to the contracts DB
+    this.log.debug(`Calling contractsDB.addContracts`);
+    await this.contractsDB.addContracts(contractDeploymentData);
+  };
+
+  public getBytecodeCommitment = async (classId: string): Promise<Buffer | undefined> => {
+    this.log.debug(`Contract provider callback: getBytecodeCommitment(${classId})`);
+
+    // Parse classId string to Fr
+    const classIdFr = Fr.fromString(classId);
+
+    // Fetch bytecode commitment from the contracts DB
+    const commitment = await this.contractsDB.getBytecodeCommitment(classIdFr);
+
+    if (!commitment) {
+      this.log.debug(`Bytecode commitment not found: ${classId}`);
+      return undefined;
+    }
+
+    // Serialize the Fr to buffer
+    return serializeWithMessagePack(commitment);
+  };
+
+  public getDebugFunctionName = async (address: string, selector: string): Promise<string | undefined> => {
+    this.log.debug(`Contract provider callback: getDebugFunctionName(${address}, ${selector})`);
+
+    // Parse address and selector strings
+    const aztecAddr = AztecAddress.fromString(address);
+    const selectorFr = Fr.fromString(selector);
+    const functionSelector = FunctionSelector.fromField(selectorFr);
+
+    // Fetch debug function name from the contracts DB
+    const name = await this.contractsDB.getDebugFunctionName(aztecAddr, functionSelector);
+
+    if (!name) {
+      this.log.debug(`Debug function name not found for ${address}:${selector}`);
+      return undefined;
+    }
+
+    return name;
+  };
+
+  public createCheckpoint = (): Promise<void> => {
+    this.log.debug(`Contract provider callback: createCheckpoint`);
+    return Promise.resolve(this.contractsDB.createCheckpoint());
+  };
+
+  public commitCheckpoint = (): Promise<void> => {
+    this.log.debug(`Contract provider callback: commitCheckpoint`);
+    return Promise.resolve(this.contractsDB.commitCheckpoint());
+  };
+
+  public revertCheckpoint = (): Promise<void> => {
+    this.log.debug(`Contract provider callback: revertCheckpoint`);
+    return Promise.resolve(this.contractsDB.revertCheckpoint());
+  };
+
+  /**
+   * Reconstruct ContractDeploymentData from plain msgpack-deserialized objects.
+   *
+   * msgpackr does not automatically apply extensions to nested fields, so we need to
+   * manually reconstruct ContractClassLog and PrivateLog instances with proper types.
+   *
+   * TODO(dbanks12): we really shouldn't have to do this.... We need to for now because
+   * msgpack deserialization doesn't give us actual typed objects, but rather just JSON.
+   * It would be easier if all types matched between languages (like AztecAddress which is just
+   * FF in C++).
+   */
+  private reconstructContractDeploymentData(rawData: any): ContractDeploymentData {
+    // Helper to ensure a value is an Fr instance
+    const toFr = (value: any): Fr => {
+      if (value instanceof Fr) {
+        return value;
+      }
+      if (Buffer.isBuffer(value)) {
+        return Fr.fromBuffer(value);
+      }
+      return new Fr(value);
+    };
+
+    // Reconstruct ContractClassLogs
+    const contractClassLogs = (rawData.contractClassLogs || []).map((log: any) => {
+      // Convert contractAddress to TS AztecAddress
+      const addressFr = toFr(log.contractAddress);
+      const address = AztecAddress.fromField(addressFr);
+
+      // Ensure all fields are Fr instances
+      const fields = (log.fields.fields || []).map((field: any) => toFr(field));
+
+      // Create proper ContractClassLog instance
+      return new ContractClassLog(address, new ContractClassLogFields(fields), log.emittedLength);
+    });
+
+    // Reconstruct PrivateLogs - ensure fields are Fr instances
+    const privateLogs = (rawData.privateLogs || []).map((log: any) => {
+      const fields = (log.fields || []).map((field: any) => toFr(field));
+      return new PrivateLog(fields as any, log.emittedLength);
+    });
+
+    return new ContractDeploymentData(contractClassLogs, privateLogs);
+  }
+}

package/src/public/public_tx_simulator/cpp_public_tx_simulator.ts

@@ -1,18 +1,199 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { avmSimulateWithHintedDbs } from '@aztec/native';
-import { deserializeFromMessagePack } from '@aztec/stdlib/avm';
+import { writeTestData } from '@aztec/foundation/testing/files';
+import { avmSimulate, avmSimulateWithHintedDbs } from '@aztec/native';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
+import {
+  AvmCircuitInputs,
+  AvmFastSimulationInputs,
+  AvmTxHint,
+  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 type { GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+
+import { strict as assert } from 'assert';
 
 import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
-import { type PublicTxResult, PublicTxSimulator, type PublicTxSimulatorConfig } from './public_tx_simulator.js';
+import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
 import type {
   MeasuredPublicTxSimulatorInterface,
   PublicTxSimulatorInterface,
 } from './public_tx_simulator_interface.js';
 
+/**
+ * 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;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+    this.log = createLogger(`simulator:cpp_public_tx_simulator`);
+  }
+
+  /**
+   * Simulate a transaction's public portion using the C++ avvm simulator.
+   *
+   * @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++ simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+      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(
+      wsRevision instanceof WorldStateRevisionWithHandle,
+      'CppPublicTxSimulator a real NativeWorldStateInstance with a handle to the C++ WorldState object',
+    );
+    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)}`);
+
+    // Create the fast simulation inputs
+    const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
+    const protocolContracts = ProtocolContractsList;
+    const fastSimInputs = new AvmFastSimulationInputs(
+      wsRevision,
+      this.config,
+      txHint,
+      this.globalVariables,
+      protocolContracts,
+    );
+
+    // Create contract provider for callbacks to TypeScript PublicContractsDB from C++
+    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...`);
+    const inputBuffer = fastSimInputs.serializeWithMessagePack();
+
+    let resultBuffer: Buffer;
+    try {
+      this.log.verbose(`Calling C++ simulator for tx ${txHash}`);
+      resultBuffer = await avmSimulate(inputBuffer, contractProvider, wsCppHandle);
+    } 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})...`);
+    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...`);
+    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}`, {
+      txHash,
+      reverted: !tsResult.revertCode.isOK(),
+      tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+      cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+    });
+
+    // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
+    return tsResult;
+  }
+}
+
+export class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator 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;
+  }
+}
+
 /**
  * C++ implementation of PublicTxSimulator using pre-collected hints.
  * This implementation runs TS simulation first to collect all hints,
@@ -26,7 +207,7 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
     merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    config?: Partial<PublicTxSimulatorConfig>,
+    config?: Partial<PublicSimulatorConfig>,
   ) {
     super(merkleTree, contractsDB, globalVariables, config);
     this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
@@ -51,20 +232,13 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
     // First, run TS simulation to generate hints and public inputs
     this.log.debug(`Running TS simulation for tx ${txHash}`);
 
-    let tsResult: PublicTxResult;
-    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 succeeded for tx ${txHash}`);
-    } catch (error: any) {
-      // If TS simulation fails, clear any partial contract additions and re-throw the error
-      this.contractsDB.clearContractsForTx();
-      throw error;
-    }
+    // 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 = tsResult.avmProvingRequest.inputs;
+    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}`);
@@ -80,7 +254,11 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
     }
 
     // Deserialize the msgpack result
-    const _success = deserializeFromMessagePack<boolean>(resultBuffer);
+    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,
@@ -89,7 +267,7 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
       cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
     });
 
-    // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
+    // TODO(fcarreiro): complete this.
     return tsResult;
   }
 }
@@ -110,7 +288,7 @@ export class MeasuredCppPublicTxSimulatorHintedDbs
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     protected readonly metrics: ExecutorMetricsInterface,
-    config?: Partial<PublicTxSimulatorConfig>,
+    config?: Partial<PublicSimulatorConfig>,
   ) {
     super(merkleTree, contractsDB, globalVariables, config);
   }
@@ -121,7 +299,7 @@ export class MeasuredCppPublicTxSimulatorHintedDbs
     try {
       result = await super.simulate(tx);
     } finally {
-      this.metrics.stopRecordingTxSimulation(txLabel, result?.revertCode);
+      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
     }
     return result;
   }

package/src/public/public_tx_simulator/index.ts

@@ -1,3 +1,4 @@
 export * from './public_tx_simulator.js';
 export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
+export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';