feat: migrate to the C++ AVM simulator

Author: dbanks12

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

@@ -18,7 +18,7 @@ import {
   getFunctionSelector,
 } from '../avm/fixtures/utils.js';
 import { PublicContractsDB } from '../public_db_sources.js';
-import { MeasuredCppPublicTxSimulator } from '../public_tx_simulator/cpp_public_tx_simulator.js';
+import { MeasuredCppVsTsPublicTxSimulator } from '../public_tx_simulator/cpp_vs_ts_public_tx_simulator.js';
 import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
 import type { MeasuredPublicTxSimulatorInterface } from '../public_tx_simulator/public_tx_simulator_interface.js';
 import { TestExecutorMetrics } from '../test_executor_metrics.js';
@@ -66,7 +66,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     const contractsDB = new PublicContractsDB(contractDataSource);
     this.simulator = useCppSimulator
-      ? new MeasuredCppPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config)
+      ? new MeasuredCppVsTsPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config)
       : new MeasuredPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
   }
 

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';

yarn-project/simulator/src/public/public_processor/apps_tests/token.test.ts

@@ -12,7 +12,7 @@ import { NativeWorldStateService } from '@aztec/world-state';
 
 import { PublicTxSimulationTester, SimpleContractDataSource } from '../../fixtures/index.js';
 import { PublicContractsDB } from '../../public_db_sources.js';
-import { CppPublicTxSimulator } from '../../public_tx_simulator/cpp_public_tx_simulator.js';
+import { CppVsTsPublicTxSimulator } from '../../public_tx_simulator/cpp_vs_ts_public_tx_simulator.js';
 import { PublicTxSimulator } from '../../public_tx_simulator/public_tx_simulator.js';
 import { GuardedMerkleTreeOperations } from '../guarded_merkle_tree.js';
 import { PublicProcessor } from '../public_processor.js';
@@ -51,7 +51,7 @@ describe.each([
       collectCallMetadata: true,
     });
     const simulator = useCppSimulator
-      ? new CppPublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config)
+      ? new CppVsTsPublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config)
       : new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config);
 
     processor = new PublicProcessor(

yarn-project/simulator/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'),
@@ -522,13 +522,9 @@ export class PublicProcessor implements Traceable {
     const timer = new Timer();
 
     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;
 
-    if (!hints) {
-      this.metrics.recordFailedTx();
-      throw new Error('Avm proving result was not generated.');
-    }
-
     const contractClassLogs = revertCode.isOK()
       ? tx.getContractClassLogs()
       : tx.getSplitContractClassLogs(false /* revertible */);
@@ -563,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,