@aztec/simulator 0.0.1-commit.5476d83 → 0.0.1-commit.6230efd

package/src/public/public_tx_simulator/cpp_vs_ts_public_tx_simulator.ts

@@ -0,0 +1,237 @@
+import { type Logger, createLogger, logLevel } from '@aztec/foundation/log';
+import { avmSimulate } from '@aztec/native';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
+import {
+  AvmFastSimulationInputs,
+  AvmTxHint,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  deserializeFromMessagePack,
+} from '@aztec/stdlib/avm';
+import { SimulationError } from '@aztec/stdlib/errors';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+
+import { strict as assert } from 'assert';
+
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+import type {
+  MeasuredPublicTxSimulatorInterface,
+  PublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
+
+/**
+ * An implementation of PublicTxSimulator that first simulates in C++, then TS, an compares the results.
+ * The C++ simulator accesses the world state directly/natively within C++.
+ * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
+ */
+export class CppVsTsPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
+  protected override log: Logger;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+    this.log = createLogger(`simulator:cpp_vs_public_tx_simulator`);
+  }
+
+  /**
+   * Simulate a transaction's public portion using the C++ avvm simulator.
+   *
+   * @param tx - The transaction to simulate.
+   * @returns The result of the transaction's public execution.
+   */
+  public override async simulate(tx: Tx): Promise<PublicTxResult> {
+    const txHash = this.computeTxHash(tx);
+    this.log.debug(`C++ simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+      txHash,
+    });
+
+    // Run TS simulation to generate hints and public inputs
+    this.log.debug(`Running TS simulation for tx ${txHash}`);
+
+    // create checkpoint for ws
+    let tsResult: PublicTxResult | undefined;
+    let tsStateRef: StateReference | undefined;
+    await this.merkleTree.createCheckpoint();
+    this.contractsDB.createCheckpoint();
+    try {
+      // Run the full TypeScript simulation using the parent class
+      // This will modify the merkle tree with the transaction's state changes
+      tsResult = await super.simulate(tx);
+      this.log.debug(`TS simulation completed for tx ${txHash}`);
+
+      tsStateRef = await this.merkleTree.getStateReference(); // capture tree roots for later comparsion
+    } catch (error: any) {
+      this.log.warn(`TS simulation failed, but still continuing with C++ simulation: ${error.message} ${error.stack}`);
+    } finally {
+      // revert checkpoint for ws and clear contract db changes
+      // (cpp should reapply exactly the same changes if there are no bugs)
+      await this.merkleTree.revertCheckpoint();
+      this.contractsDB.revertCheckpoint();
+    }
+
+    this.log.debug(`Running C++ simulation for tx ${txHash}`);
+
+    // Using the "as WorldStateRevisionWithHandle" is a bit of a "trust me bro", hence the assert.
+    let wsRevision = this.merkleTree.getRevision();
+    assert(
+      wsRevision instanceof WorldStateRevisionWithHandle,
+      'CppPublicTxSimulator a real NativeWorldStateInstance with a handle to the C++ WorldState object',
+    );
+    const wsCppHandle = (wsRevision as WorldStateRevisionWithHandle).handle;
+    wsRevision = wsRevision.toWorldStateRevision(); // for msgpack serialization, we don't include the handle in the type
+
+    this.log.debug(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
+
+    // Create the fast simulation inputs
+    const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
+    const protocolContracts = ProtocolContractsList;
+    const fastSimInputs = new AvmFastSimulationInputs(
+      wsRevision,
+      this.config,
+      txHint,
+      this.globalVariables,
+      protocolContracts,
+    );
+
+    // Create contract provider for callbacks to TypeScript PublicContractsDB from C++
+    const contractProvider = new ContractProviderForCpp(this.contractsDB, this.globalVariables);
+
+    // Serialize to msgpack and call the C++ simulator
+    this.log.debug(`Serializing fast simulation inputs to msgpack...`);
+    const inputBuffer = fastSimInputs.serializeWithMessagePack();
+
+    let resultBuffer: Buffer;
+    try {
+      this.log.debug(`Calling C++ simulator for tx ${txHash}`);
+      resultBuffer = await avmSimulate(inputBuffer, contractProvider, wsCppHandle, logLevel);
+    } catch (error: any) {
+      throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
+    }
+
+    // If we've reached this point, C++ succeeded during simulation,
+    // so we assert that TS also succeeded.
+    assert(tsResult !== undefined, 'TS simulation should have succeeded if C++ succeeded');
+    assert(tsStateRef !== undefined, 'TS state reference should have been captured if C++ succeeded');
+
+    // Deserialize the msgpack result
+    this.log.debug(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
+    const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
+    this.log.debug(`Deserializing C++ result to PublicTxResult...`);
+    const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
+    this.log.debug(`Done.`);
+    assert(cppResult.revertCode.equals(tsResult.revertCode));
+    assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
+    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.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.
+    // Then enable for misc tests and validate hints.
+    //if (this.config?.collectHints) {
+    //}
+
+    if (this.config?.collectCallMetadata) {
+      assert(cppResult.getAppLogicReturnValues().length === tsResult.getAppLogicReturnValues().length);
+      for (let i = 0; i < cppResult.getAppLogicReturnValues().length; i++) {
+        assert(cppResult.getAppLogicReturnValues()[i].equals(tsResult.getAppLogicReturnValues()[i]));
+      }
+    }
+    // Messages are still not ok for exceptional halts (they are not plumbed in C++).
+    const cppRevertReason = cppResult.findRevertReason() || {};
+    const tsRevertReason = tsResult.findRevertReason() || {};
+    const cppRevertReasonAsObject = JSON.parse(JSON.stringify(cppRevertReason));
+    const tsRevertReasonAsObject = JSON.parse(JSON.stringify(tsRevertReason));
+    if (JSON.stringify(cppRevertReasonAsObject) !== JSON.stringify(tsRevertReasonAsObject)) {
+      this.log.debug('cppResult.findRevertReason()', cppRevertReasonAsObject);
+      this.log.debug('tsResult.findRevertReason()', tsRevertReasonAsObject);
+    }
+    // TODO: dont compare the strings since this is not deterministic.
+
+    // Sometimes error messages are different between C++ and TS, so we omit in the default comparison
+    const cppRevertReasonWithoutMessage = { ...cppRevertReasonAsObject, originalMessage: undefined };
+    const tsRevertReasonWithoutMessage = { ...tsRevertReasonAsObject, originalMessage: undefined };
+    assert(JSON.stringify(cppRevertReasonWithoutMessage) === JSON.stringify(tsRevertReasonWithoutMessage));
+
+    const cppHasRevertMessage =
+      cppRevertReasonAsObject.originalMessage && cppRevertReasonAsObject.originalMessage.length > 0;
+    const tsHasRevertMessage =
+      tsRevertReasonAsObject.originalMessage && tsRevertReasonAsObject.originalMessage.length > 0;
+    // assert that if one of the error messages is non-empty, the other is
+    assert(
+      cppHasRevertMessage === tsHasRevertMessage,
+      'One of the AVM simulators (C++ or TS) produced a revert message, but the other did not',
+    );
+    // Ideally, we'd love to be able to compare full error messages, but without a lot of work
+    // the two simulators will always be able to produce some differing errors.
+    // Commenting out the code below will enforce that the error messages are at least
+    // similar (one contains the other). Even this is not something we can guarantee.
+    //if (cppHasRevertMessage) {
+    //  const cppRevertMessageContainsTs = cppRevertReasonAsObject.originalMessage.includes(
+    //    tsRevertReasonAsObject.originalMessage,
+    //  );
+    //  const tsRevertMessageContainsCpp = tsRevertReasonAsObject.originalMessage.includes(
+    //    cppRevertReasonAsObject.originalMessage,
+    //  );
+    //  assert(
+    //    cppRevertMessageContainsTs || tsRevertMessageContainsCpp,
+    //    'The AVM simulators (C++ and TS) produced different revert messages (neither was a substring of the other)',
+    //  );
+    //}
+
+    // Confirm that tree roots match
+    const cppStateRef = await this.merkleTree.getStateReference();
+    assert(
+      cppStateRef.equals(tsStateRef),
+      `Tree roots mismatch between TS and C++ public simulations for tx ${txHash}`,
+    );
+
+    this.log.debug(`C++ simulation completed for tx ${txHash}`, {
+      txHash,
+      reverted: !cppResult.revertCode.isOK(),
+      cppGasUsed: cppResult.gasUsed.totalGas.l2Gas,
+    });
+
+    // Return cpp result as it has more detailed metadata / revert reasons
+    return cppResult;
+  }
+}
+
+export class MeasuredCppVsTsPublicTxSimulator
+  extends CppVsTsPublicTxSimulator
+  implements MeasuredPublicTxSimulatorInterface
+{
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    protected readonly metrics: ExecutorMetricsInterface,
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let result: PublicTxResult | undefined;
+    try {
+      result = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
+    }
+    return result;
+  }
+}

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,4 +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,11 +1,11 @@
 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 type { Gas } from '@aztec/stdlib/gas';
+import { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
@@ -129,7 +129,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
       const setupResult = await this.simulatePhase(TxExecutionPhase.SETUP, context);
       if (setupResult.reverted) {
         throw new Error(
-          `Setup phase reverted! The transaction will be thrown out. ${setupResult.revertReason?.message}`,
+          `[SETUP] UNRECOVERABLE ERROR! The transaction will be thrown out. ${setupResult.revertReason?.message}`,
         );
       }
       processedPhases.push(setupResult);
@@ -200,10 +200,25 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     const publicInputs = await context.generateAvmCircuitPublicInputs();
     const revertCode = context.getFinalRevertCode();
 
-    // We only return the app logic phase information.
-    const appLogicReturnValues =
+    // We only return the app logic phase information, and only 1 per phase.
+    const appLogicReturnValues: NestedProcessReturnValues[] =
       processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
 
+    // TODO(fcarreiro): This is a temporary backwards compatibility layer until we migrate to the C++ simulator.
+    if (context.revertReason !== undefined) {
+      (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(),
@@ -212,8 +227,8 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
         billedGas: context.getTotalGasUsed(),
       },
       /*revertCode=*/ revertCode,
-      /*revertReason=*/ context.revertReason,
-      /*appLogicReturnValues=*/ appLogicReturnValues,
+      /*publicTxEffect=*/ publicTxEffect,
+      /*callStackMetadata=*/ appLogicReturnValues,
       /*logs=*/ context.state.getActiveStateManager().getLogs(),
       /*hints=*/ hints,
       /*publicInputs=*/ publicInputs,
@@ -299,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/public_tx_simulator_interface.ts

@@ -3,8 +3,31 @@ import type { Tx } from '@aztec/stdlib/tx';
 
 export interface PublicTxSimulatorInterface {
   simulate(tx: Tx): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   *                        This is important because signaling cancellation doesn't immediately stop C++ -
+   *                        it only sets a flag that C++ checks at certain points. If C++ is in the middle
+   *                        of a slow operation (e.g., pad_trees), it won't stop until that completes.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
 }
 
 export interface MeasuredPublicTxSimulatorInterface {
   simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
 }

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,11 +6,12 @@ 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';
+import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
@@ -26,7 +27,7 @@ import { strict as assert } from 'assert';
 
 import type { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import type { PublicContractsDBInterface } from '../db_interfaces.js';
-import { getPublicFunctionDebugName } from '../debug_fn_name.js';
+import { getPublicFunctionDebugName, getPublicFunctionSelectorAndName } from '../debug_fn_name.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
 import {
   L1ToL2MessageIndexOutOfRangeError,
@@ -532,6 +533,12 @@ export class PublicPersistableStateManager {
     return await getPublicFunctionDebugName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
   }
 
+  public async getPublicFunctionSelectorAndName(
+    avmEnvironment: AvmExecutionEnvironment,
+  ): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
+    return await getPublicFunctionSelectorAndName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
+  }
+
   public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
     await this.treesDB.padTree(treeId, leavesToInsert);
   }