@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/public/fixtures/utils.ts

@@ -1,99 +1,169 @@
 import {
-  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
-  DEFAULT_GAS_LIMIT,
-  DEPLOYER_CONTRACT_ADDRESS,
-  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
+  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
+  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
+  DEFAULT_DA_GAS_LIMIT,
+  DEFAULT_L2_GAS_LIMIT,
+  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
+  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
   PRIVATE_LOG_SIZE_IN_FIELDS,
-  REGISTERER_CONTRACT_ADDRESS,
-  REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { assertLength } from '@aztec/foundation/serialize';
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec/protocol-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import {
+  LogHash,
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
   PrivateKernelTailCircuitPublicInputs,
-  RollupValidationRequests,
-  ScopedLogHash,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
-import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
-import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
-import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
+import { ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
+import type { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import {
+  BlockHeader,
+  GlobalVariables,
+  HashedValues,
+  PublicCallRequestWithCalldata,
+  Tx,
+  TxConstantData,
+  TxContext,
+} from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
+export type TestPrivateInsertions = {
+  revertible?: {
+    nullifiers?: Fr[];
+    noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
+  };
+  nonRevertible?: {
+    nullifiers?: Fr[];
+    noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
+  };
+};
+
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
 export async function createTxForPublicCalls(
-  firstNullifier: Fr,
-  setupExecutionRequests: PublicExecutionRequest[],
-  appExecutionRequests: PublicExecutionRequest[],
-  teardownExecutionRequest?: PublicExecutionRequest,
+  privateInsertions: TestPrivateInsertions,
+  setupCallRequests: PublicCallRequestWithCalldata[],
+  appCallRequests: PublicCallRequestWithCalldata[],
+  teardownCallRequest?: PublicCallRequestWithCalldata,
   feePayer = AztecAddress.zero(),
   gasUsedByPrivate: Gas = Gas.empty(),
+  globals: GlobalVariables = GlobalVariables.empty(),
 ): Promise<Tx> {
   assert(
-    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
+    setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined,
     "Can't create public tx with no enqueued calls",
   );
-  const setupCallRequests = await Promise.all(setupExecutionRequests.map(er => er.toCallRequest()));
-  const appCallRequests = await Promise.all(appExecutionRequests.map(er => er.toCallRequest()));
   // use max limits
-  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
-  // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
 
-  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
-  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
-    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+  // Non revertible private insertions
+  if (!privateInsertions.nonRevertible?.nullifiers?.length) {
+    throw new Error('At least one non-revertible nullifier is required');
   }
-  for (let i = appCallRequests.length - 1; i >= 0; i--) {
-    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+
+  for (let i = 0; i < privateInsertions.nonRevertible.nullifiers.length; i++) {
+    assert(i < forPublic.nonRevertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+    forPublic.nonRevertibleAccumulatedData.nullifiers[i] = privateInsertions.nonRevertible.nullifiers[i];
   }
-  if (teardownExecutionRequest) {
-    forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+  if (privateInsertions.nonRevertible.noteHashes) {
+    for (let i = 0; i < privateInsertions.nonRevertible.noteHashes.length; i++) {
+      assert(i < forPublic.nonRevertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+      forPublic.nonRevertibleAccumulatedData.noteHashes[i] = privateInsertions.nonRevertible.noteHashes[i];
+    }
+  }
+  if (privateInsertions.nonRevertible.l2ToL1Msgs) {
+    for (let i = 0; i < privateInsertions.nonRevertible.l2ToL1Msgs.length; i++) {
+      assert(i < forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+      forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.nonRevertible.l2ToL1Msgs[i];
+    }
+  }
+
+  // Revertible private insertions
+  if (privateInsertions.revertible) {
+    if (privateInsertions.revertible.noteHashes) {
+      for (let i = 0; i < privateInsertions.revertible.noteHashes.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+        forPublic.revertibleAccumulatedData.noteHashes[i] = privateInsertions.revertible.noteHashes[i];
+      }
+    }
+    if (privateInsertions.revertible.nullifiers) {
+      for (let i = 0; i < privateInsertions.revertible.nullifiers.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+        forPublic.revertibleAccumulatedData.nullifiers[i] = privateInsertions.revertible.nullifiers[i];
+      }
+    }
+    if (privateInsertions.revertible.l2ToL1Msgs) {
+      for (let i = 0; i < privateInsertions.revertible.l2ToL1Msgs.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+        forPublic.revertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.revertible.l2ToL1Msgs[i];
+      }
+    }
+  }
+
+  for (let i = 0; i < setupCallRequests.length; i++) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i].request;
+  }
+  for (let i = 0; i < appCallRequests.length; i++) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i].request;
+  }
+  if (teardownCallRequest) {
+    forPublic.publicTeardownCallRequest = teardownCallRequest.request;
   }
 
   const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+  const teardownGasLimits = teardownCallRequest
+    ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
+    : Gas.empty();
   const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
-  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+  const header = BlockHeader.empty({ globalVariables: globals });
+  const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
+  const includeByTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    RollupValidationRequests.empty(),
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
+    includeByTimestamp,
     forPublic,
   );
-  const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
 
-  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
-  // Also push app calls before setup calls for this reason.
-  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
-    tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
-  }
-  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
-    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
-  }
+  const calldata = [
+    ...setupCallRequests,
+    ...appCallRequests,
+    ...(teardownCallRequest ? [teardownCallRequest] : []),
+  ].map(r => new HashedValues(r.calldata, r.request.calldataHash));
 
-  return tx;
+  return await Tx.create({
+    data: txData,
+    chonkProof: ChonkProof.random(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: calldata,
+  });
 }
 
-export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate: Gas = new Gas(10, 10)): Tx {
+export async function createTxForPrivateOnly(
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = new Gas(10, 10),
+): Promise<Tx> {
   // use max limits
-  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
 
   const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
 
@@ -101,16 +171,22 @@ export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedBy
   const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+  const includeByTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    RollupValidationRequests.empty(),
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
+    includeByTimestamp,
     /*forPublic=*/ undefined,
     forRollup,
   );
-  return Tx.newWithTxData(txData);
+  return await Tx.create({
+    data: txData,
+    chonkProof: ChonkProof.empty(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: [],
+  });
 }
 
 export async function addNewContractClassToTx(
@@ -119,25 +195,21 @@ export async function addNewContractClassToTx(
   skipNullifierInsertion = false,
 ) {
   const contractClassLogFields = [
-    new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+    new Fr(CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE),
     contractClass.id,
     new Fr(contractClass.version),
     new Fr(contractClass.artifactHash),
     new Fr(contractClass.privateFunctionsRoot),
     ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
   ];
-  const contractClassLog = ContractClassLog.fromFields([
-    new Fr(REGISTERER_CONTRACT_ADDRESS),
-    ...contractClassLogFields.concat(
-      new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO),
-    ),
-  ]);
-  const contractClassLogHash = ScopedLogHash.fromFields([
-    await contractClassLog.hash(),
-    new Fr(7),
-    new Fr(contractClassLog.getEmittedLength()),
-    new Fr(REGISTERER_CONTRACT_ADDRESS),
-  ]);
+  const contractAddress = new AztecAddress(new Fr(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS));
+  const emittedLength = contractClassLogFields.length;
+  const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+
+  const contractClassLogHash = LogHash.from({
+    value: await logFields.hash(),
+    length: emittedLength,
+  }).scope(contractAddress);
 
   const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
   if (!skipNullifierInsertion) {
@@ -148,7 +220,7 @@ export async function addNewContractClassToTx(
   const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
   accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
 
-  tx.contractClassLogs.push(contractClassLog);
+  tx.contractClassLogFields.push(logFields);
 }
 
 export async function addNewContractInstanceToTx(
@@ -168,8 +240,8 @@ export async function addNewContractInstanceToTx(
     contractInstance.publicKeys.masterTaggingPublicKey.x,
     contractInstance.publicKeys.masterTaggingPublicKey.y,
   ];
-  const fields = [
-    DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+  const logFields = [
+    CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
     contractInstance.address.toField(),
     new Fr(contractInstance.version),
     new Fr(contractInstance.salt),
@@ -177,14 +249,14 @@ export async function addNewContractInstanceToTx(
     contractInstance.initializationHash,
     ...publicKeysAsFields,
     contractInstance.deployer.toField(),
-    new Fr(0),
-    new Fr(0),
-    new Fr(0),
   ];
-  const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
+  const contractInstanceLog = new PrivateLog(
+    padArrayEnd(logFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS),
+    logFields.length,
+  );
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -0,0 +1,240 @@
+import {
+  MAX_ENQUEUED_CALLS_PER_TX,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_TX,
+} from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AvmTxHint, type PublicTxResult } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { contractClassPublicFromPlainObject, contractInstanceWithAddressFromPlainObject } from '@aztec/stdlib/contract';
+import {
+  PartialPrivateTailPublicInputsForPublic,
+  PrivateKernelTailCircuitPublicInputs,
+  PrivateToPublicAccumulatedData,
+  PublicCallRequest,
+} from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables, HashedValues, Tx, TxConstantData, TxContext, TxHash } from '@aztec/stdlib/tx';
+import type { NativeWorldStateService } from '@aztec/world-state';
+
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.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';
+
+/**
+ * Request structure for fuzzer simulation communication from C++.
+ * Matches the C++ FuzzerSimulationRequest struct
+ */
+export class FuzzerSimulationRequest {
+  constructor(
+    public readonly wsDataDir: string,
+    public readonly wsMapSizeKb: number,
+    public readonly tx: AvmTxHint,
+    public readonly globals: GlobalVariables,
+    public readonly contractClasses: any[], // Raw, processed by addContractClassFromCpp
+    public readonly contractInstances: [any, any][], // Raw pairs [address, instance]
+  ) {}
+
+  static fromPlainObject(obj: any): FuzzerSimulationRequest {
+    if (obj instanceof FuzzerSimulationRequest) {
+      return obj;
+    }
+    return new FuzzerSimulationRequest(
+      obj.wsDataDir,
+      obj.wsMapSizeKb,
+      AvmTxHint.fromPlainObject(obj.tx),
+      GlobalVariables.fromPlainObject(obj.globals),
+      obj.contractClasses,
+      obj.contractInstances,
+    );
+  }
+}
+
+/**
+ * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
+ * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ */
+async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
+  // Create TxHash from the C++ tx hash string
+  if (!cppTx.hash) {
+    throw new Error(`cppTx.hash is undefined. Keys: ${Object.keys(cppTx || {}).join(', ')}`);
+  }
+  const txHash = TxHash.fromString(cppTx.hash);
+
+  // Extract PublicCallRequest instances from enqueued calls
+  const setupCallRequests = cppTx.setupEnqueuedCalls.map(call => call.request);
+  const paddedSetupCalls = padArrayEnd(setupCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+
+  const appLogicCallRequests = cppTx.appLogicEnqueuedCalls.map(call => call.request);
+  const paddedAppLogicCalls = padArrayEnd(appLogicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+
+  // Build non-revertible accumulated data from C++ tx
+  const emptyNonRevertible = PrivateToPublicAccumulatedData.empty();
+  const nonRevertibleAccumulatedData = new PrivateToPublicAccumulatedData(
+    padArrayEnd(cppTx.nonRevertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    padArrayEnd(cppTx.nonRevertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+    padArrayEnd(
+      cppTx.nonRevertibleAccumulatedData.l2ToL1Messages,
+      ScopedL2ToL1Message.empty(),
+      MAX_L2_TO_L1_MSGS_PER_TX,
+    ),
+    padArrayEnd(cppTx.nonRevertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+    emptyNonRevertible.contractClassLogsHashes,
+    paddedSetupCalls,
+  );
+
+  // Build revertible accumulated data from C++ tx
+  const emptyRevertible = PrivateToPublicAccumulatedData.empty();
+  const revertibleAccumulatedData = new PrivateToPublicAccumulatedData(
+    padArrayEnd(cppTx.revertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    padArrayEnd(cppTx.revertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+    padArrayEnd(cppTx.revertibleAccumulatedData.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+    padArrayEnd(cppTx.revertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+    emptyRevertible.contractClassLogsHashes,
+    paddedAppLogicCalls,
+  );
+
+  // Build teardown call request (if exists)
+  const teardownCallRequest = cppTx.teardownEnqueuedCall?.request ?? PublicCallRequest.empty();
+
+  // Create forPublic structure
+  const forPublic = new PartialPrivateTailPublicInputsForPublic(
+    nonRevertibleAccumulatedData,
+    revertibleAccumulatedData,
+    teardownCallRequest,
+  );
+
+  // Build TxContext - gasSettings is already a proper GasSettings after AvmTxHint.fromPlainObject
+  const txContext = new TxContext(
+    Fr.ZERO, // chainId - this is fine because simulation actually reads from globalVariables not here
+    Fr.ZERO, // version - this is fine because simulation actually reads from globalVariables not here
+    cppTx.gasSettings,
+  );
+
+  // Build TxConstantData
+  const constants = new TxConstantData(
+    BlockHeader.empty(), // anchorBlockHeader (unused in simulation)
+    txContext,
+    Fr.ZERO, // vkTreeRoot - not needed for public simulation
+    Fr.ZERO, // protocolContractsHash - not needed for public simulation
+  );
+
+  const data = new PrivateKernelTailCircuitPublicInputs(
+    constants,
+    cppTx.gasUsedByPrivate,
+    cppTx.feePayer,
+    0n, // includeByTimestamp
+    forPublic,
+    undefined, // forRollup - not needed for public simulation
+  );
+
+  // Build publicFunctionCalldata from all enqueued calls
+  // Calldata is already Fr[] after AvmTxHint.fromPlainObject
+  const publicFunctionCalldata: HashedValues[] = [];
+
+  // Add setup calls
+  for (const call of cppTx.setupEnqueuedCalls || []) {
+    publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+  }
+
+  // Add app logic calls
+  for (const call of cppTx.appLogicEnqueuedCalls || []) {
+    publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+  }
+
+  // Add teardown call if present
+  if (cppTx.teardownEnqueuedCall) {
+    publicFunctionCalldata.push(await HashedValues.fromCalldata(cppTx.teardownEnqueuedCall.calldata));
+  }
+
+  // Extract contract class log fields from ContractDeploymentData
+  const contractClassLogFields = [
+    ...cppTx.nonRevertibleContractDeploymentData.contractClassLogs.map(log => log.fields),
+    ...cppTx.revertibleContractDeploymentData.contractClassLogs.map(log => log.fields),
+  ];
+
+  // Create the Tx
+  return new Tx(
+    txHash,
+    data,
+    ChonkProof.empty(), // No real proof needed for simulation
+    contractClassLogFields,
+    publicFunctionCalldata,
+  );
+}
+
+/**
+ * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
+ * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ */
+export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
+  private simulator: PublicTxSimulator;
+
+  constructor(
+    merkleTrees: MerkleTreeWriteOperations,
+    contractDataSource: SimpleContractDataSource,
+    globals: GlobalVariables,
+  ) {
+    super(contractDataSource, merkleTrees);
+    const contractsDb = new PublicContractsDB(contractDataSource);
+    this.simulator = new PublicTxSimulator(merkleTrees, contractsDb, globals, {
+      skipFeeEnforcement: false,
+      collectDebugLogs: false,
+      collectHints: false,
+      collectStatistics: false,
+      collectCallMetadata: false,
+    });
+  }
+
+  /**
+   * Static factory method to create an AvmFuzzerSimulator.
+   */
+  public static async create(
+    worldStateService: NativeWorldStateService,
+    globals: GlobalVariables,
+  ): Promise<AvmFuzzerSimulator> {
+    const contractDataSource = new SimpleContractDataSource();
+    const merkleTrees = await worldStateService.fork();
+    return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals);
+  }
+
+  /**
+   * Simulate a transaction from a C++ AvmTxHint.
+   */
+  public async simulate(txHint: AvmTxHint): Promise<PublicTxResult> {
+    // Compute fee from gas limits and max fees per gas (upper bound on fee)
+    const totalFee =
+      BigInt(txHint.gasSettings.gasLimits.daGas) * txHint.gasSettings.maxFeesPerGas.feePerDaGas +
+      BigInt(txHint.gasSettings.gasLimits.l2Gas) * txHint.gasSettings.maxFeesPerGas.feePerL2Gas;
+
+    await this.setFeePayerBalance(txHint.feePayer, new Fr(totalFee));
+
+    const tx = await createTxFromHint(txHint);
+    return await this.simulator.simulate(tx);
+  }
+
+  /**
+   * Add a contract class from C++ raw msgpack data.
+   */
+  public async addContractClassFromCpp(rawClass: any): Promise<void> {
+    const contractClass = contractClassPublicFromPlainObject(rawClass);
+    await this.contractDataSource.addContractClass(contractClass);
+  }
+
+  /**
+   * Add a contract instance from C++ raw msgpack data.
+   * This also inserts the contract address nullifier into the nullifier tree.
+   */
+  public async addContractInstanceFromCpp(rawAddress: any, rawInstance: any): Promise<void> {
+    const address = AztecAddress.fromPlainObject(rawAddress);
+    const instance = contractInstanceWithAddressFromPlainObject(address, rawInstance);
+    await this.addContractInstance(instance);
+  }
+}