feat: migrate to the C++ AVM simulator

Author: dbanks12

barretenberg/cpp/src/barretenberg/vm2/avm_api.cpp

@@ -13,38 +13,38 @@ using namespace bb::avm2::simulation;
 std::pair<AvmAPI::AvmProof, AvmAPI::AvmVerificationKey> AvmAPI::prove(const AvmAPI::ProvingInputs& inputs)
 {
     // Simulate.
-    info("Simulating...");
+    vinfo("Simulating...");
     AvmSimulationHelper simulation_helper;
 
     auto events = AVM_TRACK_TIME_V("simulation/all", simulation_helper.simulate_for_witgen(inputs.hints));
 
     // Generate trace.
-    info("Generating trace...");
+    vinfo("Generating trace...");
     AvmTraceGenHelper tracegen_helper;
     auto trace =
         AVM_TRACK_TIME_V("tracegen/all", tracegen_helper.generate_trace(std::move(events), inputs.public_inputs));
 
     // Prove.
-    info("Proving...");
+    vinfo("Proving...");
     AvmProvingHelper proving_helper;
     auto [proof, vk] = AVM_TRACK_TIME_V("proving/all", proving_helper.prove(std::move(trace)));
 
-    info("Done!");
+    vinfo("Done!");
     return { std::move(proof), std::move(vk) };
 }
 
 bool AvmAPI::check_circuit(const AvmAPI::ProvingInputs& inputs)
 {
     // Simulate.
-    info("Simulating...");
+    vinfo("Simulating...");
     AvmSimulationHelper simulation_helper;
 
     auto events = AVM_TRACK_TIME_V("simulation/all", simulation_helper.simulate_for_witgen(inputs.hints));
 
     // Generate trace.
     // In contrast to proving, we do this step by step since it's usually more useful to debug
     // before trying to run the interaction builders.
-    info("Generating trace...");
+    vinfo("Generating trace...");
     AvmTraceGenHelper tracegen_helper;
     tracegen::TraceContainer trace;
     AVM_TRACK_TIME("tracegen/all", tracegen_helper.fill_trace_columns(trace, std::move(events), inputs.public_inputs));
@@ -58,25 +58,25 @@ bool AvmAPI::check_circuit(const AvmAPI::ProvingInputs& inputs)
     AVM_TRACK_TIME("tracegen/all", tracegen_helper.fill_trace_interactions(trace));
 
     // Check circuit.
-    info("Checking circuit...");
+    vinfo("Checking circuit...");
     AvmProvingHelper proving_helper;
     return proving_helper.check_circuit(std::move(trace));
 }
 
 bool AvmAPI::verify(const AvmProof& proof, const PublicInputs& pi, const AvmVerificationKey& vk_data)
 {
-    info("Verifying...");
+    vinfo("Verifying...");
     AvmProvingHelper proving_helper;
     return AVM_TRACK_TIME_V("verifing/all", proving_helper.verify(proof, pi, vk_data));
 }
 
 AvmAPI::AvmVerificationKey AvmAPI::get_verification_key()
 {
-    info("Generating trace...");
+    vinfo("Generating trace...");
     AvmTraceGenHelper tracegen_helper;
     auto trace = tracegen_helper.generate_precomputed_columns();
 
-    info("Computing verification key...");
+    vinfo("Computing verification key...");
     AvmProvingHelper proving_helper;
     return proving_helper.compute_verification_key(trace);
 }

barretenberg/cpp/src/barretenberg/vm2/avm_sim_api.cpp

@@ -12,7 +12,7 @@ TxSimulationResult AvmSimAPI::simulate(const FastSimulationInputs& inputs,
                                        simulation::ContractDBInterface& contract_db,
                                        world_state::WorldState& ws)
 {
-    info("Simulating...");
+    vinfo("Simulating...");
     AvmSimulationHelper simulation_helper;
     // TODO(MW): Add hint checks here
     return AVM_TRACK_TIME_V("simulation/all",
@@ -27,7 +27,7 @@ TxSimulationResult AvmSimAPI::simulate(const FastSimulationInputs& inputs,
 
 TxSimulationResult AvmSimAPI::simulate_with_hinted_dbs(const ProvingInputs& inputs)
 {
-    info("Simulating...");
+    vinfo("Simulating...");
     AvmSimulationHelper simulation_helper;
     auto result = AVM_TRACK_TIME_V("simulation/all", simulation_helper.simulate_fast_with_hinted_dbs(inputs.hints));
 

barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.cpp

@@ -112,24 +112,23 @@ ReturnDataProvider make_return_data_provider(const ContextInterface& context, ui
         try {
             const auto& memory = context.get_memory();
             std::vector<FF> data;
-            info("Collecting returndata rd_offset:", rd_offset, " rd_size:", rd_size, " max_size:", max_size, ")");
             data.reserve(std::min(max_size, rd_size));
             for (uint32_t i = 0; i < std::min(max_size, rd_size); i++) {
                 data.push_back(memory.get(rd_offset + i).as_ff());
             }
             return data;
         } catch (...) {
-            info("Failed to collect returndata (to:",
-                 context.get_address(),
-                 " pc:",
-                 context.get_pc(),
-                 " rd_offset:",
-                 rd_offset,
-                 " rd_size:",
-                 rd_size,
-                 " max_size:",
-                 max_size,
-                 ")");
+            vinfo("Failed to collect returndata (to:",
+                  context.get_address(),
+                  " pc:",
+                  context.get_pc(),
+                  " rd_offset:",
+                  rd_offset,
+                  " rd_size:",
+                  rd_size,
+                  " max_size:",
+                  max_size,
+                  ")");
             return {};
         }
     };

yarn-project/end-to-end/src/e2e_block_building.test.ts

@@ -16,8 +16,7 @@ import { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest
 import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import type { BlockBuilder, SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import { Set } from '@aztec/simulator/public/avm/opcodes';
-import { type PublicTxResult, PublicTxSimulator } from '@aztec/simulator/server';
+import type { PublicTxResult, PublicTxSimulatorInterface } from '@aztec/simulator/server';
 import { getProofSubmissionDeadlineEpoch } from '@aztec/stdlib/epoch-helpers';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { TX_ERROR_EXISTING_NULLIFIER, type Tx } from '@aztec/stdlib/tx';
@@ -558,30 +557,30 @@ describe('e2e_block_building', () => {
         ]);
       const batches = times(2, makeBatch);
 
-      // This is embarrassingly brittle. What we want to do here is: we want the sequencer to wait until both
-      // txs have arrived (so minTxsPerBlock=2), but agree to build a block with 1 tx only, so we change the config
-      // to minTxsPerBlock=1 as soon as we start processing. We also want to simulate an AVM failure in tx processing
-      // for only one of the txs, and near the end so all nullifiers have been emitted. So we throw on one of the last
-      // calls to SET. Note that this will break on brillig or AVM changes that change how many SET operations we use.
-      let setCount = 0;
-      const origExecute = Set.prototype.execute;
-      const spy = jest.spyOn(Set.prototype, 'execute').mockImplementation(async function (...args: any[]) {
-        setCount++;
-        if (setCount === 1) {
-          context.sequencer?.updateConfig({ minTxsPerBlock: 1 });
-        } else if (setCount === 48) {
-          throw new Error('Simulated failure in AVM opcode SET');
-        }
-        // @ts-expect-error: eslint-be-happy
-        await origExecute.call(this, ...args);
-      });
+      // We want the sequencer to wait until both txs have arrived (so minTxsPerBlock=2), but agree to build
+      // a block with 1 tx only, so we change the config to minTxsPerBlock=1 as soon as we start processing.
+      // We also want to simulate an AVM failure in tx processing for only one of the txs.
+      let simulateCount = 0;
+      interceptTxProcessorSimulate(
+        aztecNode as AztecNodeService,
+        async (tx: Tx, originalSimulate: (tx: Tx) => Promise<PublicTxResult>) => {
+          simulateCount++;
+          if (simulateCount === 1) {
+            context.sequencer?.updateConfig({ minTxsPerBlock: 1 });
+          }
+          if (simulateCount === 2) {
+            throw new Error('Simulated failure in public tx simulation');
+          }
+          return await originalSimulate(tx);
+        },
+      );
 
       const txs = await Promise.all(batches.map(batch => batch.send({ from: ownerAddress })));
       logger.warn(`Sent two txs to test contract`, { txs: await Promise.all(txs.map(tx => tx.getTxHash())) });
       await Promise.race(txs.map(tx => tx.wait({ timeout: 60 })));
 
-      logger.warn(`At least one tx has been mined (after ${spy.mock.calls.length} AVM SET invocations)`);
-      expect(setCount).toBeGreaterThanOrEqual(48);
+      logger.warn(`At least one tx has been mined (after ${simulateCount} public tx simulations)`);
+      expect(simulateCount).toBeGreaterThanOrEqual(2);
       const lastBlock = await context.aztecNode.getBlockHeader();
       expect(lastBlock).toBeDefined();
 
@@ -692,7 +691,7 @@ describe('e2e_block_building', () => {
       .mockImplementation(async (...args: Parameters<BlockBuilder['makeBlockBuilderDeps']>) => {
         logger.warn('Creating mocked public tx simulator');
         const deps = await originalCreateDeps(...args);
-        const simulator: PublicTxSimulator = (deps.processor as any).publicTxSimulator;
+        const simulator: PublicTxSimulatorInterface = (deps.processor as any).publicTxSimulator;
         const originalSimulate = simulator.simulate.bind(simulator);
         jest.spyOn(simulator, 'simulate').mockImplementation((tx: Tx) => stub(tx, originalSimulate));
         return deps;

yarn-project/end-to-end/src/e2e_p2p/reex.test.ts

@@ -7,7 +7,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import { unfreeze } from '@aztec/foundation/types';
 import type { LibP2PService, P2PClient } from '@aztec/p2p';
 import type { BlockBuilder } from '@aztec/sequencer-client';
-import type { PublicTxResult, PublicTxSimulator } from '@aztec/simulator/server';
+import type { CppPublicTxSimulator, PublicTxResult } from '@aztec/simulator/server';
 import { BlockProposal, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
 import { ReExFailedTxsError, ReExStateMismatchError, ReExTimeoutError } from '@aztec/stdlib/validators';
 import type { ValidatorClient, ValidatorKeyStore } from '@aztec/validator-client';
@@ -167,7 +167,7 @@ describe('e2e_p2p_reex', () => {
         .mockImplementation(async (...args: Parameters<BlockBuilder['makeBlockBuilderDeps']>) => {
           const deps = await originalCreateDeps(...args);
           t.logger.warn('Creating mocked processor factory');
-          const simulator: PublicTxSimulator = (deps.processor as any).publicTxSimulator;
+          const simulator: CppPublicTxSimulator = (deps.processor as any).publicTxSimulator;
           const originalSimulate = simulator.simulate.bind(simulator);
           // We only stub the simulate method if it's NOT the first time we see the tx
           // so the proposer works fine, but we cause the failure in the validators.

yarn-project/sequencer-client/src/sequencer/block_builder.ts

@@ -11,7 +11,7 @@ import {
   GuardedMerkleTreeOperations,
   PublicContractsDB,
   PublicProcessor,
-  TelemetryPublicTxSimulator,
+  TelemetryCppPublicTxSimulator,
 } from '@aztec/simulator/server';
 import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
@@ -121,7 +121,7 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
     const contractsDB = new PublicContractsDB(this.contractDataSource);
     const guardedFork = new GuardedMerkleTreeOperations(fork);
 
-    const publicTxSimulator = new TelemetryPublicTxSimulator(
+    const publicTxSimulator = new TelemetryCppPublicTxSimulator(
       guardedFork,
       contractsDB,
       globalVariables,

yarn-project/simulator/src/public/fixtures/public_tx_simulation_tester.ts

@@ -19,7 +19,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';
@@ -44,30 +44,43 @@ 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
  * transactions.
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   protected txCount: number = 0;
-  private simulator: MeasuredPublicTxSimulatorInterface;
+  private simulator?: MeasuredPublicTxSimulatorInterface;
   private metricsPrefix?: string;
 
   constructor(
     merkleTree: MerkleTreeWriteOperations,
     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(
@@ -79,7 +92,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) {
@@ -136,6 +152,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:

yarn-project/simulator/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
-  const appLogicReturnValues = balResult.getAppLogicReturnValues();
-  expectToBeTrue(appLogicReturnValues.length === 1);
-  expectToBeTrue(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);
+  }
 }

yarn-project/simulator/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';