@aztec/simulator 3.0.0-nightly.20251208 → 3.0.0-nightly.20251210

package/src/public/fuzzing/helpers.ts

@@ -0,0 +1,154 @@
+import {
+  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
+  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 type { AvmTxHint } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { siloNullifier } from '@aztec/stdlib/hash';
+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 { MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { BlockHeader, HashedValues, Tx, TxConstantData, TxContext, TxHash } from '@aztec/stdlib/tx';
+
+// Registers a contract by inserting its address nullifier into the nullifier tree
+export async function registerContract(
+  merkleTrees: MerkleTreeWriteOperations,
+  contractAddress: AztecAddress,
+): Promise<void> {
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    contractAddress.toField(),
+  );
+  await merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);
+}
+
+/**
+ * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
+ * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ *
+ * @param cppTx - Deserialized C++ Tx from msgpack (matches AvmTxHint structure)
+ * @returns A TypeScript Tx suitable for PublicTxSimulator
+ */
+export async function createFuzzerTx(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
+  );
+
+  // todo(ilyas): I don't think we need to construct this, but keeping for now - the hashing could get costly with
+  // large number of enqueued calls or large calldata so keep an eye on this!
+  // 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,
+  );
+}

package/src/public/hinting_db_sources.ts

@@ -1,6 +1,6 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { sha256Trunc } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 import type { FunctionSelector } from '@aztec/stdlib/abi';

package/src/public/index.ts

@@ -3,6 +3,8 @@ export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_t
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
 export {
   CppPublicTxSimulator,
+  createPublicTxSimulatorForBlockBuilding,
+  DumpingCppPublicTxSimulator,
   type PublicTxSimulatorInterface,
   TelemetryCppPublicTxSimulator,
 } from './public_tx_simulator/index.js';

package/src/public/public_db_sources.ts

@@ -4,7 +4,7 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   PUBLIC_DATA_SUBTREE_HEIGHT,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';

package/src/public/public_processor/public_processor.ts

@@ -1,6 +1,6 @@
 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/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
@@ -523,7 +523,7 @@ export class PublicProcessor implements Traceable {
 
     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;
+    const { hints, publicInputs, publicTxEffect, gasUsed, revertCode /*callStackMetadata*/ } = result;
 
     const contractClassLogs = revertCode.isOK()
       ? tx.getContractClassLogs()
@@ -542,10 +542,15 @@ export class PublicProcessor implements Traceable {
     const appLogicReturnValues: NestedProcessReturnValues[] = result.getAppLogicReturnValues();
     // Extract the revert reason from the call stack metadata.
     const revertReason = result.findRevertReason();
+    // Create proving request if we have hints and public inputs.
+    const avmProvingRequest =
+      hints && publicInputs ? PublicProcessor.generateProvingRequest(publicInputs, hints) : undefined;
 
     const processedTx = makeProcessedTxFromTxWithPublicCalls(
       tx,
-      PublicProcessor.generateProvingRequest(publicInputs, hints),
+      this.globalVariables,
+      avmProvingRequest,
+      publicTxEffect,
       gasUsed,
       revertCode,
       revertReason,

package/src/public/public_tx_simulator/contract_provider_for_cpp.ts

@@ -1,11 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { ContractProvider } from '@aztec/native';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ContractDeploymentData } from '@aztec/stdlib/contract';
-import { ContractClassLog, ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 import type { PublicContractsDB } from '../public_db_sources.js';
@@ -55,8 +54,8 @@ export class ContractProviderForCpp implements ContractProvider {
 
     const rawData: any = deserializeFromMessagePack(contractDeploymentDataBuffer);
 
-    // Construct class instances using the from method
-    const contractDeploymentData = this.reconstructContractDeploymentData(rawData);
+    // Construct ContractDeploymentData from plain object.
+    const contractDeploymentData = ContractDeploymentData.fromPlainObject(rawData);
 
     // Add contracts to the contracts DB
     this.log.debug(`Calling contractsDB.addContracts`);
@@ -114,49 +113,4 @@ export class ContractProviderForCpp implements ContractProvider {
     this.log.debug(`Contract provider callback: revertCheckpoint`);
     return Promise.resolve(this.contractsDB.revertCheckpoint());
   };
-
-  /**
-   * Reconstruct ContractDeploymentData from plain msgpack-deserialized objects.
-   *
-   * msgpackr does not automatically apply extensions to nested fields, so we need to
-   * manually reconstruct ContractClassLog and PrivateLog instances with proper types.
-   *
-   * TODO(dbanks12): we really shouldn't have to do this.... We need to for now because
-   * msgpack deserialization doesn't give us actual typed objects, but rather just JSON.
-   * It would be easier if all types matched between languages (like AztecAddress which is just
-   * FF in C++).
-   */
-  private reconstructContractDeploymentData(rawData: any): ContractDeploymentData {
-    // Helper to ensure a value is an Fr instance
-    const toFr = (value: any): Fr => {
-      if (value instanceof Fr) {
-        return value;
-      }
-      if (Buffer.isBuffer(value)) {
-        return Fr.fromBuffer(value);
-      }
-      return new Fr(value);
-    };
-
-    // Reconstruct ContractClassLogs
-    const contractClassLogs = (rawData.contractClassLogs || []).map((log: any) => {
-      // Convert contractAddress to TS AztecAddress
-      const addressFr = toFr(log.contractAddress);
-      const address = AztecAddress.fromField(addressFr);
-
-      // Ensure all fields are Fr instances
-      const fields = (log.fields.fields || []).map((field: any) => toFr(field));
-
-      // Create proper ContractClassLog instance
-      return new ContractClassLog(address, new ContractClassLogFields(fields), log.emittedLength);
-    });
-
-    // Reconstruct PrivateLogs - ensure fields are Fr instances
-    const privateLogs = (rawData.privateLogs || []).map((log: any) => {
-      const fields = (log.fields || []).map((field: any) => toFr(field));
-      return new PrivateLog(fields as any, log.emittedLength);
-    });
-
-    return new ContractDeploymentData(contractClassLogs, privateLogs);
-  }
 }

package/src/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.ts

@@ -64,7 +64,7 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
     this.log.debug(`TS simulation succeeded for tx ${txHash}`);
 
     // Extract the full AvmCircuitInputs from the TS result
-    const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints!, tsResult.publicInputs);
+    const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints!, tsResult.publicInputs!);
 
     // Second, run C++ simulation with hinted DBs
     this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);

package/src/public/public_tx_simulator/cpp_vs_ts_public_tx_simulator.ts

@@ -1,5 +1,4 @@
 import { type Logger, createLogger, logLevel } from '@aztec/foundation/log';
-import { writeTestData } from '@aztec/foundation/testing/files';
 import { avmSimulate } from '@aztec/native';
 import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import {
@@ -126,12 +125,6 @@ export class CppVsTsPublicTxSimulator extends PublicTxSimulator implements Publi
     // Deserialize the msgpack result
     this.log.debug(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
     const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
-    // Write testdata if AZTEC_WRITE_TESTDATA=1.
-    writeTestData(
-      `barretenberg/cpp/src/barretenberg/vm2/testing/tx_result_${txHash}.testdata.bin`,
-      resultBuffer,
-      /*raw=*/ true,
-    );
     this.log.debug(`Deserializing C++ result to PublicTxResult...`);
     const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
     this.log.debug(`Done.`);
@@ -140,7 +133,10 @@ export class CppVsTsPublicTxSimulator extends PublicTxSimulator implements Publi
     assert(cppResult.gasUsed.publicGas.equals(tsResult.gasUsed.publicGas));
     assert(cppResult.gasUsed.teardownGas.equals(tsResult.gasUsed.teardownGas));
     assert(cppResult.gasUsed.billedGas.equals(tsResult.gasUsed.billedGas));
-    assert(cppResult.publicInputs.toBuffer().equals(tsResult.publicInputs.toBuffer()));
+    assert(cppResult.publicTxEffect.equals(tsResult.publicTxEffect));
+    if (cppResult.publicInputs !== undefined) {
+      assert(cppResult.publicInputs!.toBuffer().equals(tsResult.publicInputs!.toBuffer()));
+    }
 
     // TODO(fcarreiro): complete this.
     // Check that C++ hints are a strict subset of TS hints.

package/src/public/public_tx_simulator/dumping_cpp_public_tx_simulator.ts

@@ -0,0 +1,81 @@
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  serializeWithMessagePack,
+} from '@aztec/stdlib/avm';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables, Tx, TxHash } from '@aztec/stdlib/tx';
+
+import { strict as assert } from 'assert';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { CppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+
+/**
+ * A C++ public tx simulator that dumps AVM circuit inputs to disk after simulation.
+ * Used during nightly CI runs to collect circuit inputs for benchmarking.
+ */
+export class DumpingCppPublicTxSimulator extends CppPublicTxSimulator {
+  private readonly outputDir: string;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config: Partial<PublicSimulatorConfig>,
+    outputDir: string,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+    assert(config.collectHints === true, 'collectHints must be enabled to dump AVM circuit inputs');
+    assert(config.collectPublicInputs === true, 'collectPublicInputs must be enabled to dump AVM circuit inputs');
+    this.outputDir = outputDir;
+  }
+
+  public override async simulate(tx: Tx): Promise<PublicTxResult> {
+    const result = await super.simulate(tx);
+
+    // Dump the circuit inputs after successful simulation
+    const txHash = this.computeTxHash(tx);
+    this.dumpAvmCircuitInputs(result, txHash);
+
+    return result;
+  }
+
+  /**
+   * Dumps AVM circuit inputs to disk.
+   *
+   * @param result - The simulation result containing hints and public inputs
+   * @param txHash - The transaction hash to use in the filename
+   */
+  private dumpAvmCircuitInputs(result: PublicTxResult, txHash: TxHash): void {
+    try {
+      // Ensure the output directory exists
+      mkdirSync(this.outputDir, { recursive: true });
+
+      // Generate filename using transaction hash
+      const filename = `avm-circuit-inputs-tx-${txHash.toString()}.bin`;
+      const filepath = join(this.outputDir, filename);
+
+      // Create circuit inputs from the result
+      const hints = result.hints ?? AvmExecutionHints.empty();
+      const publicInputs = result.publicInputs ?? AvmCircuitPublicInputs.empty();
+      const avmCircuitInputs = new AvmCircuitInputs(hints, publicInputs);
+
+      // Serialize the circuit inputs using MessagePack
+      const serialized = serializeWithMessagePack(avmCircuitInputs);
+
+      // Write to disk
+      writeFileSync(filepath, serialized);
+
+      this.log.debug(`Dumped AVM circuit inputs to ${filepath}`);
+    } catch (error) {
+      // Non-blocking error handling - log but don't interrupt processing
+      this.log.warn(`Failed to dump AVM circuit inputs for tx ${txHash.toString()}: ${error}`);
+    }
+  }
+}

package/src/public/public_tx_simulator/factories.ts

@@ -0,0 +1,41 @@
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+import { DumpingCppPublicTxSimulator } from './dumping_cpp_public_tx_simulator.js';
+
+/**
+ * Creates a public tx simulator for block building.
+ * Uses DumpingCppPublicTxSimulator if DUMP_AVM_INPUTS_TO_DIR env var is set (for CI/testing avm circuit),
+ * otherwise uses TelemetryCppPublicTxSimulator (for production).
+ */
+export function createPublicTxSimulatorForBlockBuilding(
+  merkleTree: MerkleTreeWriteOperations,
+  contractsDB: PublicContractsDB,
+  globalVariables: GlobalVariables,
+  telemetryClient: TelemetryClient,
+) {
+  const config = PublicSimulatorConfig.from({
+    skipFeeEnforcement: false,
+    collectDebugLogs: false,
+    collectHints: false,
+    collectPublicInputs: false,
+    collectStatistics: false,
+    collectCallMetadata: false,
+  });
+
+  const dumpDir = process.env.DUMP_AVM_INPUTS_TO_DIR;
+  if (dumpDir) {
+    // must collect hints and PIs for dumping
+    const dumpingConfig = {
+      ...config,
+      collectHints: true,
+      collectPublicInputs: true,
+    };
+    return new DumpingCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, dumpingConfig, dumpDir);
+  }
+  return new TelemetryCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, telemetryClient, config);
+}

package/src/public/public_tx_simulator/index.ts

@@ -1,5 +1,7 @@
 export * from './public_tx_simulator.js';
 export { CppPublicTxSimulator, TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+export { DumpingCppPublicTxSimulator } from './dumping_cpp_public_tx_simulator.js';
+export { createPublicTxSimulatorForBlockBuilding } from './factories.js';
 export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
 export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { Timer } from '@aztec/foundation/timer';
 import type { PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
 import type { Gas } from '@aztec/stdlib/gas';

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -6,7 +6,7 @@ import {
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   AvmAccumulatedData,

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,9 +1,9 @@
 import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { AvmExecutionHints, AvmTxHint, PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
+import { AvmExecutionHints, AvmTxHint, PublicSimulatorConfig, PublicTxEffect, PublicTxResult } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
@@ -209,6 +209,16 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
       (appLogicReturnValues as any).revertReason = context.revertReason;
     }
 
+    // Create PublicTxEffect from PublicInputs.
+    const publicTxEffect = new PublicTxEffect(
+      publicInputs.transactionFee,
+      publicInputs.accumulatedData.noteHashes.filter(h => !h.isEmpty()),
+      publicInputs.accumulatedData.nullifiers.filter(n => !n.isEmpty()),
+      publicInputs.accumulatedData.l2ToL1Msgs.filter(m => !m.isEmpty()),
+      publicInputs.accumulatedData.publicLogs.toLogs(),
+      publicInputs.accumulatedData.publicDataWrites.filter(w => !w.isEmpty()),
+    );
+
     return new PublicTxResult(
       /*gasUsed=*/ {
         totalGas: context.getActualGasUsed(),
@@ -217,6 +227,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
         billedGas: context.getTotalGasUsed(),
       },
       /*revertCode=*/ revertCode,
+      /*publicTxEffect=*/ publicTxEffect,
       /*callStackMetadata=*/ appLogicReturnValues,
       /*logs=*/ context.state.getActiveStateManager().getLogs(),
       /*hints=*/ hints,
@@ -303,7 +314,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     );
 
     if (result.reverted) {
-      const culprit = `${contractAddress}:${callRequest.functionSelector}`;
+      const culprit = `${contractAddress}:${fnName}`;
       context.revert(phase, result.revertReason, culprit);
     }
 

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';

package/src/public/side_effect_trace.ts

@@ -7,8 +7,8 @@ import {
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { type LogLevel, createLogger } from '@aztec/foundation/log';
 import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';

package/src/public/side_effect_trace_interface.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogLevel } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { DebugLog } from '@aztec/stdlib/logs';

package/src/public/state_manager/nullifiers.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { PublicTreesDB } from '../public_db_sources.js';
 import { NullifierCollisionError } from '../side_effect_errors.js';

package/src/public/state_manager/public_storage.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import type { PublicStateDBInterface } from '../db_interfaces.js';

package/src/public/state_manager/state_manager.ts

@@ -6,8 +6,8 @@ import {
   MULTI_CALL_ENTRYPOINT_ADDRESS,
   ROUTER_ADDRESS,
 } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type LogLevel, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';