@aztec/simulator 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/src/public/fixtures/public_processor_test_env.ts

@@ -0,0 +1,88 @@
+import { createLogger } from '@aztec/foundation/log';
+import { TestDateProvider } from '@aztec/foundation/timer';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { NativeWorldStateService } from '@aztec/world-state';
+
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { GuardedMerkleTreeOperations } from '../public_processor/guarded_merkle_tree.js';
+import { PublicProcessor } from '../public_processor/public_processor.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+import { SimpleContractDataSource } from './simple_contract_data_source.js';
+
+/** Options for {@link PublicProcessorTestEnv.create}. */
+export interface PublicProcessorTestEnvOptions {
+  /** Global variables shared by the processor and the tester. Defaults to empty with nonzero gas fees. */
+  globals?: GlobalVariables;
+  /** Simulator config for the processor's PublicTxSimulator. */
+  config?: Partial<PublicSimulatorConfig>;
+}
+
+function defaultGlobals(): GlobalVariables {
+  const globals = GlobalVariables.empty();
+  globals.gasFees = new GasFees(2, 3);
+  return globals;
+}
+
+const defaultConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectDebugLogs: true,
+  collectHints: false,
+  collectStatistics: false,
+  collectCallMetadata: true,
+});
+
+/**
+ * Bundles the real-AVM wiring shared by public-processor app tests: a live WSDB world state, a CDB IPC
+ * server, a spawned AVM simulator, a {@link PublicProcessor} backed by all three, and a setup-only
+ * {@link PublicTxSimulationTester} sharing the same fork and contract data source for building txs and
+ * seeding balances. Own it with `await using`, or call {@link Symbol.asyncDispose} from `afterEach`.
+ */
+export class PublicProcessorTestEnv implements AsyncDisposable {
+  private constructor(
+    public readonly processor: PublicProcessor,
+    public readonly tester: PublicTxSimulationTester,
+    public readonly contractsDB: PublicContractsDB,
+    public readonly globals: GlobalVariables,
+    private readonly worldStateService: NativeWorldStateService,
+    private readonly avmSimulator: AvmSimulatorPool,
+  ) {}
+
+  static async create(opts: PublicProcessorTestEnvOptions = {}): Promise<PublicProcessorTestEnv> {
+    const globals = opts.globals ?? defaultGlobals();
+    const config = opts.config ? PublicSimulatorConfig.from({ ...defaultConfig, ...opts.config }) : defaultConfig;
+
+    const contractDataSource = new SimpleContractDataSource();
+    const worldStateService = await NativeWorldStateService.tmp();
+    const merkleTrees = await worldStateService.fork();
+    const contractsDB = new PublicContractsDB(contractDataSource);
+
+    const forkId = merkleTrees.getRevision().forkId;
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+
+    const simulator = new PublicTxSimulator(avmSimulator, globals, contractsDB, forkId, config, undefined);
+    const processor = new PublicProcessor(
+      globals,
+      new GuardedMerkleTreeOperations(merkleTrees),
+      contractsDB,
+      simulator,
+      new TestDateProvider(),
+      getTelemetryClient(),
+      createLogger('simulator:public-processor'),
+    );
+
+    const tester = new PublicTxSimulationTester(merkleTrees, contractDataSource, globals);
+
+    return new PublicProcessorTestEnv(processor, tester, contractsDB, globals, worldStateService, avmSimulator);
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.avmSimulator[Symbol.asyncDispose]();
+    await this.tester.close();
+    await this.worldStateService.close();
+  }
+}

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -11,16 +11,16 @@ import { PublicCallRequest } from '@aztec/stdlib/kernel';
 import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { BaseAvmSimulationTester } from '../avm/testing/base_avm_simulation_tester.js';
 import {
   DEFAULT_BLOCK_NUMBER,
   DEFAULT_TIMESTAMP,
   getContractFunctionAbi,
   getFunctionSelector,
-} from '../avm/fixtures/utils.js';
+} from '../avm/testing/utils.js';
+import { AvmSimulatorPool } from '../avm_simulator_pool.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/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';
@@ -66,8 +66,9 @@ export type MeasuredSimulatorFactory = (
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   protected txCount: number = 0;
-  private simulator: MeasuredPublicTxSimulatorInterface;
+  private simulator: MeasuredPublicTxSimulatorInterface | undefined;
   private metricsPrefix?: string;
+  protected avmSimulator?: AvmSimulatorPool;
 
   constructor(
     merkleTree: MerkleTreeWriteOperations,
@@ -83,7 +84,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     if (simulatorFactory) {
       this.simulator = simulatorFactory(merkleTree, contractsDB, globals, this.metrics, config);
     } else {
-      this.simulator = new MeasuredCppPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
+      // No simulator — this tester can only be used for setup (setFeePayerBalance, createTx, etc.)
+      // To simulate, use PublicTxSimulationTester.create() or pass a simulatorFactory.
+      this.simulator = undefined;
     }
   }
 
@@ -91,15 +94,25 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     worldStateService: NativeWorldStateService, // make sure to close this later
     globals: GlobalVariables = defaultGlobals(),
     metrics: TestExecutorMetrics = new TestExecutorMetrics(),
-    useCppSimulator = false,
     config: PublicSimulatorConfig = defaultConfig,
   ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTree = await worldStateService.fork();
-    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);
+
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+    const simulatorFactory: MeasuredSimulatorFactory = (mt, cdb, g, m, c) =>
+      new MeasuredPublicTxSimulator(avmSimulator, g, cdb, mt.getRevision().forkId, m, c, undefined);
+
+    const tester = new PublicTxSimulationTester(
+      merkleTree,
+      contractDataSource,
+      globals,
+      metrics,
+      simulatorFactory,
+      config,
+    );
+    tester.avmSimulator = avmSimulator;
+    return tester;
   }
 
   public setMetricsPrefix(prefix: string) {
@@ -166,8 +179,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
-    await this.#recordBytecodeSizes(fullTxLabel, [...setupCalls, ...appCalls, ...(teardownCall ? [teardownCall] : [])]);
-
     // Something like this is often useful for debugging:
     //if (avmResult.revertReason) {
     //  // resolve / enrich revert reason
@@ -197,18 +208,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
-    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
-    return await this.simulateTx(
-      sender,
-      setupCalls,
-      appCalls,
-      teardownCall,
-      feePayer,
-      privateInsertions,
-      txLabel,
-      gasLimits,
-    );
+    return await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, txLabel);
   }
 
   /**
@@ -226,7 +227,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
-    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
     return await this.simulateTxWithLabel(
       txLabel,
@@ -236,7 +236,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCall,
       feePayer,
       privateInsertions,
-      gasLimits,
     );
   }
 
@@ -244,22 +243,31 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     this.metrics.prettyPrint();
   }
 
+  /** Clean up IPC resources (AVM simulator pool and merkle tree fork) created by create(). */
+  public async close(): Promise<void> {
+    await this.avmSimulator?.[Symbol.asyncDispose]();
+    // Close the merkle tree fork to release IPC resources before the wsdb process is killed.
+    if (this.merkleTrees?.close) {
+      await this.merkleTrees.close().catch(() => {});
+    }
+  }
+
   /**
    * Cancel the current simulation if one is in progress.
-   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * This signals the underlying simulator to stop at the next safe point.
    * Safe to call even if no simulation is in progress.
    *
    * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
    */
   public async cancel(waitTimeoutMs?: number): Promise<void> {
-    await this.simulator.cancel?.(waitTimeoutMs);
+    await this.simulator?.cancel?.(waitTimeoutMs);
   }
 
   /**
    * Get the underlying simulator for advanced test scenarios.
    * Use this when you need direct control over simulation (e.g., for testing cancellation).
    */
-  public getSimulator(): MeasuredPublicTxSimulatorInterface {
+  public getSimulator(): MeasuredPublicTxSimulatorInterface | undefined {
     return this.simulator;
   }
 
@@ -296,27 +304,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     return new PublicCallRequestWithCalldata(request, calldata);
   }
-
-  // WARNING: Deduplicates by artifact name, so two different artifacts with the same name
-  // in a single tx would only record the first one's bytecode size.
-  async #recordBytecodeSizes(txLabel: string, calls: TestEnqueuedCall[]) {
-    const seenArtifactNames = new Set<string>();
-    for (const call of calls) {
-      const artifact = await this.contractDataSource.getContractArtifact(call.address);
-      if (!artifact || seenArtifactNames.has(artifact.name)) {
-        continue;
-      }
-      seenArtifactNames.add(artifact.name);
-      const instance = await this.contractDataSource.getContract(call.address);
-      if (!instance) {
-        continue;
-      }
-      const contractClass = await this.contractDataSource.getContractClass(instance.currentContractClassId);
-      if (contractClass) {
-        this.metrics.recordBytecodeSize(txLabel, artifact.name, contractClass.packedBytecode.length);
-      }
-    }
-  }
 }
 
 export function defaultGlobals() {

package/src/public/fixtures/simple_contract_data_source.ts

@@ -5,7 +5,7 @@ import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import { getFunctionSelector } from '../avm/fixtures/utils.js';
+import { getFunctionSelector } from '../avm/testing/utils.js';
 
 /**
  * This class is used during public/avm testing to function as a database of

package/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -33,7 +33,8 @@ import {
 } from '@aztec/stdlib/tx';
 import type { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { BaseAvmSimulationTester } from '../avm/testing/base_avm_simulation_tester.js';
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
 import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
 import { PublicContractsDB } from '../public_db_sources.js';
 import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
@@ -75,7 +76,7 @@ export class FuzzerSimulationRequest {
 
 /**
  * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
- * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ * This allows simulating fuzzer-generated transactions with the C++ public tx simulator.
  */
 async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
   // Create TxHash from the C++ tx hash string
@@ -189,6 +190,8 @@ async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
 /**
  * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
  * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ * The simulation itself runs on the production C++ AVM simulator, so the fuzzer compares brillig
+ * execution against the real AVM rather than a TS reference.
  */
 export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
   private simulator: PublicTxSimulator;
@@ -197,22 +200,27 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
     merkleTrees: MerkleTreeWriteOperations,
     contractDataSource: SimpleContractDataSource,
     globals: GlobalVariables,
-    protocolContracts: ProtocolContracts,
+    private avmSimulator: AvmSimulatorPool,
+    contractsDB: PublicContractsDB,
+    forkId: number,
   ) {
     super(contractDataSource, merkleTrees);
-    const contractsDb = new PublicContractsDB(contractDataSource);
+    // collectPublicInputs and collectCallMetadata are required so the C++ result carries the end
+    // tree snapshots and app-logic return values that the fuzzer bin reports back to the harness.
     this.simulator = new PublicTxSimulator(
-      merkleTrees,
-      contractsDb,
+      avmSimulator,
       globals,
+      contractsDB,
+      forkId,
       {
         skipFeeEnforcement: false,
         collectDebugLogs: false,
         collectHints: false,
+        collectPublicInputs: true,
         collectStatistics: false,
-        collectCallMetadata: false,
+        collectCallMetadata: true,
       },
-      protocolContracts,
+      undefined,
     );
   }
 
@@ -222,11 +230,18 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
   public static async create(
     worldStateService: NativeWorldStateService,
     globals: GlobalVariables,
-    protocolContracts: ProtocolContracts,
   ): Promise<AvmFuzzerSimulator> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await worldStateService.fork();
-    return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals, protocolContracts);
+    const forkId = merkleTrees.getRevision().forkId;
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+    const contractsDB = new PublicContractsDB(contractDataSource);
+    return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals, avmSimulator, contractsDB, forkId);
+  }
+
+  /** Tear down the AVM simulator pool (AVM processes and CDB server). */
+  public async close(): Promise<void> {
+    await this.avmSimulator[Symbol.asyncDispose]();
   }
 
   /**

package/src/public/fuzzing/avm_simulator_bin.ts

@@ -7,7 +7,7 @@ import {
   deserializeFromMessagePack,
   serializeWithMessagePack,
 } from '@aztec/stdlib/avm';
-import { GlobalVariables, ProtocolContracts, TreeSnapshots } from '@aztec/stdlib/tx';
+import { GlobalVariables, TreeSnapshots } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
 import { createInterface } from 'readline';
@@ -58,7 +58,6 @@ async function simulateWithFuzzer(
   rawContractInstances: [any, any][], // Replace these when we are moving contract instances to TS
   rawPublicDataWrites: any[], // Public data tree writes to apply before simulation
   rawNoteHashes: any[], // Note hashes to apply before simulation
-  protocolContracts: ProtocolContracts, // Protocol contracts mapping from C++
 ): Promise<{
   reverted: boolean;
   output: Fr[];
@@ -68,7 +67,7 @@ async function simulateWithFuzzer(
 }> {
   const worldStateService = await openExistingWorldState(dataDir, mapSizeKb);
 
-  const simulator = await AvmFuzzerSimulator.create(worldStateService, globals, protocolContracts);
+  const simulator = await AvmFuzzerSimulator.create(worldStateService, globals);
 
   await simulator.applyNoteHashes(rawNoteHashes);
 
@@ -108,7 +107,7 @@ async function execute(base64Line: string): Promise<void> {
     const rawRequest = deserializeFromMessagePack(buffer);
     const request = FuzzerSimulationRequest.fromPlainObject(rawRequest);
 
-    // Run the TS simulation
+    // Run the simulation on the C++ AVM simulator
     const result = await simulateWithFuzzer(
       request.wsDataDir,
       request.wsMapSizeKb,
@@ -118,7 +117,6 @@ async function execute(base64Line: string): Promise<void> {
       request.contractInstances,
       request.publicDataWrites,
       request.noteHashes,
-      request.protocolContracts,
     );
 
     // Serialize the result to msgpack and encode it in base64 for output

package/src/public/index.ts

@@ -1,12 +1,16 @@
+export { AvmSimulatorPool, type AvmSimulatorPoolOptions } from './avm_simulator_pool.js';
+export type { PublicContractsDBInterface } from './db_interfaces.js';
 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 type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
 export {
-  CppPublicTxSimulator,
+  PublicTxSimulator,
+  MeasuredPublicTxSimulator,
   createPublicTxSimulatorForBlockBuilding,
-  DumpingCppPublicTxSimulator,
+  DumpingPublicTxSimulator,
   type PublicTxSimulatorInterface,
-  TelemetryCppPublicTxSimulator,
+  TelemetryPublicTxSimulator,
 } 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_db_sources.ts

@@ -55,7 +55,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     this.log = createLogger('simulator:contracts-data-source', bindings);
   }
 
-  /** Parses raw log data from the C++/NAPI bridge and inserts the resulting contracts into the current checkpoint. */
+  /** Parses raw contract deployment data and inserts the resulting contracts into the current checkpoint. */
   public addContractsFromLogs(contractDeploymentData: ContractDeploymentData): void {
     const currentState = this.getCurrentState();
 

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -12,7 +12,7 @@ import type {
   TreeInfo,
 } from '@aztec/stdlib/trees';
 import type { BlockHeader, StateReference } from '@aztec/stdlib/tx';
-import type { WorldStateRevision, WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
 
 /**
  * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
@@ -94,9 +94,12 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   getInitialHeader(): BlockHeader {
     return this.target.getInitialHeader();
   }
-  public getRevision(): WorldStateRevision | WorldStateRevisionWithHandle {
+  public getRevision(): WorldStateRevision {
     return this.target.getRevision();
   }
+  public getIpcPath(): string {
+    return this.target.getIpcPath();
+  }
   getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>> {
     return this.guardAndPush(() => this.target.getSiblingPath(treeId, index));
   }

package/src/public/public_processor/public_processor.ts

@@ -1,9 +1,4 @@
-import {
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  MAX_TX_BLOB_DATA_SIZE_IN_FIELDS,
-  NULLIFIER_SUBTREE_HEIGHT,
-} from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
@@ -55,11 +50,12 @@ import { ForkCheckpoint } from '@aztec/world-state/native';
 
 import { AssertionError } from 'assert';
 
+import type { AvmSimulator } from '../avm_simulator.js';
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import {
   type PublicTxSimulatorConfig,
   type PublicTxSimulatorInterface,
-  TelemetryCppPublicTxSimulator,
+  TelemetryPublicTxSimulator,
 } from '../public_tx_simulator/index.js';
 import { GuardedMerkleTreeOperations } from './guarded_merkle_tree.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
@@ -71,6 +67,7 @@ export class PublicProcessorFactory {
   private log: Logger;
   constructor(
     private contractDataSource: ContractDataSource,
+    private avmSimulator: AvmSimulator,
     private dateProvider: DateProvider = new DateProvider(),
     protected telemetryClient: TelemetryClient = getTelemetryClient(),
     bindings?: LoggerBindings,
@@ -79,7 +76,9 @@ export class PublicProcessorFactory {
   }
 
   /**
-   * Creates a new instance of a PublicProcessor.
+   * Creates a new instance of a PublicProcessor. The simulator it drives reads contract data from the fork's
+   * contracts DB, scoped by the fork id so AVM requests route to the right state.
+   *
    * @param globalVariables - The global variables for the block being processed.
    * @param contractsDB - Optional pre-populated contracts DB; a fresh one is constructed if omitted.
    * @returns A new instance of a PublicProcessor.
@@ -90,8 +89,10 @@ export class PublicProcessorFactory {
     config: PublicSimulatorConfig,
     contractsDB: PublicContractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings()),
   ): PublicProcessor {
+    const forkId = merkleTree.getRevision().forkId;
+
     const guardedFork = new GuardedMerkleTreeOperations(merkleTree);
-    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, config);
+    const publicTxSimulator = this.createPublicTxSimulator(forkId, globalVariables, contractsDB, config);
 
     return new PublicProcessor(
       globalVariables,
@@ -105,15 +106,16 @@ export class PublicProcessorFactory {
   }
 
   protected createPublicTxSimulator(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    forkId: number,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
     config?: Partial<PublicTxSimulatorConfig>,
   ): PublicTxSimulatorInterface {
-    return new TelemetryCppPublicTxSimulator(
-      merkleTree,
-      contractsDB,
+    return new TelemetryPublicTxSimulator(
+      this.avmSimulator,
       globalVariables,
+      contractsDB,
+      forkId,
       this.telemetryClient,
       config,
       this.log.getBindings(),
@@ -135,10 +137,6 @@ class PublicProcessorAbortError extends Error {
   }
 }
 
-function isPublicProcessorInterruptError(err: any) {
-  return err?.name === 'PublicProcessorTimeoutError' || err?.name === 'PublicProcessorAbortError';
-}
-
 /**
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
  * any public function calls in them. Txs with private calls only are unaffected.
@@ -272,22 +270,6 @@ export class PublicProcessor implements Traceable {
         const txBlobFields = processedTx.txEffect.getNumBlobFields();
         const txSize = txBlobFields * Fr.SIZE_IN_BYTES;
 
-        // A single tx's effects must fit within the per-tx blob encoding: the rollup circuit encodes each
-        // tx into a fixed [Field; MAX_TX_BLOB_DATA_SIZE_IN_FIELDS] array, so a larger tx effect cannot be
-        // proven. The per-category side-effect limits already guarantee this upstream, so reaching here means
-        // the tx is malformed; reject it as invalid rather than letting it poison proving.
-        if (txBlobFields > MAX_TX_BLOB_DATA_SIZE_IN_FIELDS) {
-          const error = new Error(
-            `Tx ${txHash} produced ${txBlobFields} blob fields, exceeding the per-tx maximum of ${MAX_TX_BLOB_DATA_SIZE_IN_FIELDS}`,
-          );
-          this.log.error(error.message, { txHash, txBlobFields });
-          await checkpoint.revert();
-          this.contractsDB.revertCheckpoint();
-          failed.push({ tx, error });
-          returns.push(new NestedProcessReturnValues([]));
-          continue;
-        }
-
         // If the actual blob fields of this tx would exceed the limit, skip it.
         // Note: maxBlobFields already accounts for block end blob fields and previous blocks in checkpoint.
         if (maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
@@ -347,11 +329,15 @@ export class PublicProcessor implements Traceable {
         // Commit the tx-level contracts checkpoint on success
         this.contractsDB.commitCheckpoint();
       } catch (err: any) {
-        if (isPublicProcessorInterruptError(err)) {
-          const interruptReason = err.name === 'PublicProcessorTimeoutError' ? 'timeout' : 'abort signal';
-          this.log.warn(`Stopping tx processing due to ${interruptReason}.`);
-          // The tx may still be executing on a worker thread (C++ via NAPI).
-          // Signal cancellation AND WAIT for the simulation to actually stop before touching fork checkpoints.
+        if (err?.name === 'PublicProcessorTimeoutError' || err?.name === 'PublicProcessorAbortError') {
+          this.log.warn(
+            `Stopping tx processing due to ${err.name === 'PublicProcessorTimeoutError' ? 'timeout' : 'abort'}.`,
+          );
+          // We hit the transaction execution deadline or an external abort signal.
+          // There may still be a simulation in progress.
+          // Signal cancellation AND WAIT for the simulation to actually stop. Cancellation is
+          // cooperative: the simulator may be mid slow-operation and won't observe the flag until it
+          // completes, and without waiting we'd revert checkpoints while it's still writing to state.
           await this.publicTxSimulator.cancel?.();
 
           // Now stop the guarded fork to prevent any further TS-side access to the world state.