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

@@ -163,24 +163,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 {};
         }
     };

barretenberg/cpp/src/barretenberg/vm2/testing/minimal_tx.testdata.bin

@@ -8,7 +8,7 @@ import {
   type TestPrivateInsertions,
 } from '@aztec/simulator/public/fixtures';
 import type { PublicTxResult } from '@aztec/simulator/server';
-import { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { AvmCircuitInputs, AvmCircuitPublicInputs, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
@@ -88,6 +88,15 @@ class InterceptingLogger implements Logger {
   }
 }
 
+// Config with collectHints enabled for proving tests
+const provingConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectCallMetadata: true,
+  collectDebugLogs: false,
+  collectHints: true, // Required for proving!
+  collectStatistics: false,
+});
+
 export class AvmProvingTester extends PublicTxSimulationTester {
   private bbWorkingDirectory: string = '';
 
@@ -98,7 +107,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
     globals?: GlobalVariables,
     metrics?: TestExecutorMetrics,
   ) {
-    super(merkleTrees, contractDataSource, globals, metrics);
+    super(merkleTrees, contractDataSource, globals, metrics, undefined, provingConfig);
   }
 
   static async new(

yarn-project/bb-prover/src/avm_proving_tests/avm_proving_tester.ts

@@ -197,7 +197,7 @@ describe('e2e_avm_simulator', () => {
         // The nested call reverts and by default caller rethrows
         await expect(
           avmContract.methods.nested_call_to_nothing().simulate({ from: defaultAccountAddress }),
-        ).rejects.toThrow(/No bytecode/);
+        ).rejects.toThrow(/not deployed/);
       });
 
       it('Nested CALL instruction to non-existent contract returns failure, but caller can recover', async () => {

yarn-project/end-to-end/src/e2e_avm_simulator.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,31 @@ 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 });
+          }
+          const result = await originalSimulate(tx);
+          if (simulateCount === 2) {
+            throw new Error('Simulated failure in public tx simulation');
+          }
+          return result;
+        },
+      );
 
       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 +692,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_block_building.test.ts

@@ -311,7 +311,7 @@ describe('e2e_deploy_contract contract class registration', () => {
       // Confirm that the tx reverts with the expected message
       await expect(
         instance.methods.increment_public_value_no_init_check(whom, 10).simulate({ from: defaultAccountAddress }),
-      ).rejects.toThrow(/No bytecode/);
+      ).rejects.toThrow(/not deployed/);
       // This time, don't throw on revert and confirm that the tx is included
       // despite reverting in app logic because of the call to a non-existent contract
       const tx = await instance.methods

yarn-project/end-to-end/src/e2e_deploy_contract/contract_class_registration.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/end-to-end/src/e2e_p2p/reex.test.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,