@aztec/simulator 0.0.1-commit.3100065 → 0.0.1-commit.321f6a9

package/src/public/avm/avm_simulator.ts

@@ -1,279 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GlobalVariables } from '@aztec/stdlib/tx';
-
-import { strict as assert } from 'assert';
-
-import { CheckedPublicExecutionError } from '../public_errors.js';
-import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
-import { AvmContext } from './avm_context.js';
-import { AvmContractCallResult } from './avm_contract_call_result.js';
-import { AvmExecutionEnvironment } from './avm_execution_environment.js';
-import type { Gas } from './avm_gas.js';
-import { AvmMachineState } from './avm_machine_state.js';
-import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
-import { type CallData, ReturnDataArray } from './calldata.js';
-import { AvmRevertReason, InvalidProgramCounterError } from './errors.js';
-import type { Instruction } from './opcodes/instruction.js';
-import { revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './revert_reason.js';
-import {
-  INSTRUCTION_SET,
-  type InstructionSet,
-  decodeInstructionFromBytecode,
-} from './serialization/bytecode_serialization.js';
-
-type OpcodeTally = {
-  count: number;
-  gas: Gas;
-};
-
-export class AvmSimulator implements AvmSimulatorInterface {
-  private log: Logger;
-  private bytecode: Buffer | undefined;
-  private opcodeTallies: Map<string, OpcodeTally> = new Map();
-  // maps pc to [instr, bytesRead]
-  private deserializedInstructionsCache: Map<number, [Instruction, number]> = new Map();
-
-  private tallyPrintFunction = () => {};
-  private tallyInstructionFunction = (_b: string, _c: Gas) => {};
-
-  // Test Purposes only: Logger will not have the proper function name. Use this constructor for testing purposes
-  // only. Otherwise, use build() below.
-  constructor(
-    private context: AvmContext,
-    private instructionSet: InstructionSet = INSTRUCTION_SET,
-    enableTallying = false,
-  ) {
-    // This will be used by the CALL opcode to create a new simulator. It is required to
-    // avoid a dependency cycle.
-    context.provideSimulator = AvmSimulator.build;
-    this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata.read(0)})`);
-    // Turn on tallying if explicitly enabled or if trace logging
-    if (enableTallying || this.log.isLevelEnabled('trace')) {
-      this.tallyPrintFunction = this.printOpcodeTallies;
-      this.tallyInstructionFunction = this.tallyInstruction;
-    }
-  }
-
-  // Factory to have a proper function name in the logger. Retrieving the name is asynchronous and
-  // cannot be done as part of the constructor.
-  public static async build(context: AvmContext): Promise<AvmSimulator> {
-    const simulator = new AvmSimulator(context);
-    const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
-    simulator.log = createLogger(`simulator:avm(f:${fnName.slice(0, 128)})`);
-
-    return simulator;
-  }
-
-  public static async create(
-    stateManager: PublicPersistableStateManager,
-    address: AztecAddress,
-    sender: AztecAddress,
-    transactionFee: Fr,
-    globals: GlobalVariables,
-    isStaticCall: boolean,
-    calldata: CallData,
-    allocatedGas: Gas,
-    config: PublicSimulatorConfig,
-  ) {
-    const avmExecutionEnv = new AvmExecutionEnvironment(
-      address,
-      sender,
-      /*contractCallDepth=*/ Fr.zero(),
-      transactionFee,
-      globals,
-      isStaticCall,
-      calldata,
-      config,
-    );
-
-    const avmMachineState = new AvmMachineState(allocatedGas);
-    const avmContext = new AvmContext(stateManager, avmExecutionEnv, avmMachineState);
-    return await AvmSimulator.build(avmContext);
-  }
-
-  /**
-   * Fetch the bytecode and execute it in the current context.
-   */
-  public async execute(): Promise<AvmContractCallResult> {
-    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
-    // getBytecode returns undefined if bytecode is not found or if the limit of contract calls to unique class IDs is reached.
-    // If it throws an error that reaches this point, it is a bug.
-
-    if (!bytecode) {
-      return await this.handleFailureToRetrieveBytecode(
-        `No bytecode found. Contract is not deployed, or limit encountered for max calls to unique contract class IDs. Contract address: ${this.context.environment.address}. Reverting...`,
-      );
-    }
-
-    return await this.executeBytecode(bytecode);
-  }
-
-  /**
-   * Return the bytecode used for execution, if any.
-   */
-  public getBytecode(): Buffer | undefined {
-    return this.bytecode;
-  }
-
-  /**
-   * Executes the provided bytecode in the current context.
-   * This method is useful for testing and debugging.
-   */
-  public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
-    const timer = new Timer();
-    assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
-
-    this.bytecode = bytecode;
-    let instructionName = 'NONE'; // This is used for logging purposes
-
-    const { machineState } = this.context;
-    const callStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
-    try {
-      // Execute instruction pointed to by the current program counter
-      // continuing until the machine state signifies a halt
-      while (!machineState.getHalted()) {
-        // Get the instruction from cache, or deserialize for the first time
-        let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
-
-        if (cachedInstruction === undefined) {
-          cachedInstruction = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
-          this.deserializedInstructionsCache.set(machineState.pc, cachedInstruction);
-        }
-        const [instruction, bytesRead] = cachedInstruction;
-
-        const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
-
-        if (this.log.isLevelEnabled('trace')) {
-          // Skip this entirely to avoid toStringing etc if trace is not enabled
-          this.log.trace(
-            `[PC:${machineState.pc}] [IC:${machineState.instrCounter}] ${instruction.toString()} (gasLeft l2=${
-              machineState.l2GasLeft
-            } da=${machineState.daGasLeft})`,
-          );
-        }
-        machineState.nextPc = machineState.pc + bytesRead;
-
-        instructionName = instruction.constructor.name;
-        // Execute the instruction.
-        // Normal returns and reverts will return normally here.
-        // "Exceptional halts" will throw.
-        await instruction.execute(this.context);
-        if (!instruction.handlesPC()) {
-          // Increment PC if the instruction doesn't handle it itself
-          machineState.pc += bytesRead;
-        }
-
-        machineState.instrCounter++;
-
-        // gas used by this instruction - used for profiling/tallying
-        const gasUsed: Gas = {
-          l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
-          daGas: instrStartGas.daGas - machineState.daGasLeft,
-        };
-        this.tallyInstructionFunction(instruction.constructor.name, gasUsed);
-
-        if (machineState.pc >= bytecode.length) {
-          this.log.warn('Passed end of program');
-          throw new InvalidProgramCounterError(machineState.pc, /*max=*/ bytecode.length - 1);
-        }
-      }
-
-      const output = machineState.getOutput();
-      const reverted = machineState.getReverted();
-      const revertReason = reverted
-        ? await revertReasonFromExplicitRevert(output.bestEffortReadAll(), this.context)
-        : undefined;
-      const results = new AvmContractCallResult(
-        reverted,
-        output,
-        machineState.gasLeft,
-        revertReason,
-        machineState.instrCounter,
-      );
-      this.log.debug(`Context execution results: ${results.toString()}`);
-      const totalGasUsed: Gas = {
-        l2Gas: callStartGas.l2Gas - machineState.l2GasLeft,
-        daGas: callStartGas.daGas - machineState.daGasLeft,
-      };
-      this.log.debug(`Executed ${machineState.instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
-
-      this.tallyPrintFunction();
-
-      this.log.debug(`Core AVM simulation took ${timer.ms()}ms`);
-
-      // Return results for processing by calling context
-      return results;
-    } catch (err: any) {
-      this.log.info(
-        `Exceptional halt (revert by something other than REVERT opcode) for instruction
-         ${instructionName} at pc ${machineState.pc} and instruction counter ${machineState.instrCounter}`,
-      );
-      if (!(err instanceof CheckedPublicExecutionError)) {
-        this.log.error(`Unchecked/unknown error thrown by AVM. This is a bug. Error: ${err}`);
-        throw err;
-      }
-
-      const revertReason = await revertReasonFromExceptionalHalt(err, this.context);
-      // Exceptional halts consume all allocated gas
-      const noGasLeft = { l2Gas: 0, daGas: 0 };
-      // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(
-        /*reverted=*/ true,
-        /*output=*/ new ReturnDataArray([]),
-        noGasLeft,
-        revertReason,
-        machineState.instrCounter,
-      );
-      this.log.debug(`Context execution results: ${results.toString()}`);
-
-      this.tallyPrintFunction();
-      // Return results for processing by calling context
-      return results;
-    }
-  }
-
-  private async handleFailureToRetrieveBytecode(message: string): Promise<AvmContractCallResult> {
-    // revert, consuming all gas
-    const { functionSelector, functionName } = await this.context.persistableState.getPublicFunctionSelectorAndName(
-      this.context.environment,
-    );
-    const revertReason = new AvmRevertReason(
-      message,
-      /*failingFunction=*/ {
-        contractAddress: this.context.environment.address,
-        functionSelector,
-        functionName,
-      },
-      /*noirCallStack=*/ [],
-    );
-    this.log.warn(message);
-    return new AvmContractCallResult(
-      /*reverted=*/ true,
-      /*output=*/ new ReturnDataArray([]),
-      /*gasLeft=*/ { l2Gas: 0, daGas: 0 }, // consumes all allocated gas
-      revertReason,
-    );
-  }
-
-  private tallyInstruction(opcode: string, gasUsed: Gas) {
-    const opcodeTally = this.opcodeTallies.get(opcode) || ({ count: 0, gas: { l2Gas: 0, daGas: 0 } } as OpcodeTally);
-    opcodeTally.count++;
-    opcodeTally.gas.l2Gas += gasUsed.l2Gas;
-    opcodeTally.gas.daGas += gasUsed.daGas;
-    this.opcodeTallies.set(opcode, opcodeTally);
-  }
-
-  private printOpcodeTallies() {
-    this.log.debug(`Printing tallies per opcode sorted by gas...`);
-    // sort descending by L2 gas consumed
-    const sortedOpcodes = Array.from(this.opcodeTallies.entries()).sort((a, b) => b[1].gas.l2Gas - a[1].gas.l2Gas);
-    for (const [opcode, tally] of sortedOpcodes) {
-      // NOTE: don't care to clutter the logs with DA gas for now
-      this.log.debug(`${opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`);
-    }
-  }
-}

package/src/public/avm/avm_simulator_interface.ts

@@ -1,8 +0,0 @@
-/**
- * Interface for AvmSimulator to break the circular dependency between avm_context.ts and avm_simulator.ts
- */
-export interface AvmSimulatorInterface {
-  execute(): Promise<any>; // Using any here to avoid importing AvmContractCallResult
-  executeBytecode(bytecode: Buffer): Promise<any>;
-  getBytecode(): Buffer | undefined;
-}

package/src/public/avm/calldata.ts

@@ -1,101 +0,0 @@
-import type { Fr } from '@aztec/foundation/schemas';
-
-import { TaggedMemory } from './avm_memory_types.js';
-
-// Allow reading up to 300 kB of return data when unspecified.
-const DEFAULT_BEST_EFFORT_READ_CAP = 10000;
-
-export interface LazyReader {
-  bestEffortReadAll(readCap?: number): Fr[];
-  readAll(): Fr[];
-  read(idx: number): Fr | undefined;
-  slice(start: number, end: number): Fr[];
-  length(): number;
-}
-
-export class LazyReaderMemory implements LazyReader {
-  constructor(
-    private memory: TaggedMemory,
-    private offset: number,
-    private size: number,
-  ) {}
-
-  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
-    const size = Math.min(this.size, readCap, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
-    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
-  }
-
-  public read(idx: number): Fr | undefined {
-    if (idx >= this.size) {
-      return undefined;
-    }
-    return this.memory.get(this.offset + idx).toFr();
-  }
-
-  public slice(start: number, end: number): Fr[] {
-    const clampedEnd = Math.min(end, this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
-    const length = Math.max(0, clampedEnd - start);
-    return this.memory.getSlice(this.offset + start, length).map(word => word.toFr());
-  }
-
-  public readAll(): Fr[] {
-    const size = Math.min(this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
-    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
-  }
-
-  public length(): number {
-    return this.size;
-  }
-}
-
-export class LazyReaderArray implements LazyReader {
-  constructor(private array: Fr[]) {}
-
-  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
-    return this.array.slice(0, readCap);
-  }
-
-  public read(idx: number): Fr | undefined {
-    return this.array[idx];
-  }
-
-  public slice(start: number, end: number): Fr[] {
-    return this.array.slice(start, end);
-  }
-
-  public readAll(): Fr[] {
-    return this.array;
-  }
-
-  public length(): number {
-    return this.array.length;
-  }
-}
-
-// Compile time branding to avoid swapping CallData and ReturnData by accident.
-declare const CallDataBrand: unique symbol;
-declare const ReturnDataBrand: unique symbol;
-
-export type CallData = LazyReader & {
-  readonly [CallDataBrand]: true;
-};
-
-export type ReturnData = LazyReader & {
-  readonly [ReturnDataBrand]: true;
-};
-
-export class CallDataArray extends LazyReaderArray implements CallData {
-  declare readonly [CallDataBrand]: true;
-}
-
-export class CallDataMemory extends LazyReaderMemory implements CallData {
-  declare readonly [CallDataBrand]: true;
-}
-
-export class ReturnDataArray extends LazyReaderArray implements ReturnData {
-  declare readonly [ReturnDataBrand]: true;
-}
-
-export class ReturnDataMemory extends LazyReaderMemory implements ReturnData {
-  declare readonly [ReturnDataBrand]: true;
-}

package/src/public/avm/errors.ts

@@ -1,177 +0,0 @@
-import type { Point } from '@aztec/foundation/curves/grumpkin';
-import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
-
-import { ExecutionError } from '../../common/errors.js';
-import { CheckedPublicExecutionError } from '../public_errors.js';
-
-/**
- * Avm-specific errors should derive from this
- */
-export abstract class AvmExecutionError extends CheckedPublicExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'AvmExecutionError';
-  }
-}
-
-export class ArithmeticError extends AvmExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ArithmeticError';
-  }
-}
-
-/**
- * Error is thrown when the program counter goes to an invalid location.
- * There is no instruction at the provided pc
- */
-export class InvalidProgramCounterError extends AvmExecutionError {
-  constructor(pc: number, max: number) {
-    super(`Invalid program counter ${pc}, max is ${max}`);
-    this.name = 'InvalidProgramCounterError';
-  }
-}
-
-/**
- * Error is thrown when the program counter points to a byte
- * of an invalid opcode.
- */
-export class InvalidOpcodeError extends AvmExecutionError {
-  constructor(str: string) {
-    super(str);
-    this.name = 'InvalidOpcodeError';
-  }
-}
-
-/**
- * Error is thrown during parsing.
- */
-export class AvmParsingError extends AvmExecutionError {
-  constructor(str: string) {
-    super(str);
-    this.name = 'AvmParsingError';
-  }
-}
-
-/**
- * Error is thrown when the tag has an invalid value.
- */
-export class InvalidTagValueError extends AvmExecutionError {
-  constructor(tagValue: number) {
-    super(`Tag check failed: Tag value ${tagValue} is invalid.`);
-    this.name = 'InvalidTagValueError';
-  }
-}
-
-/**
- * Error thrown during an instruction's execution (during its execute()).
- */
-export class InstructionExecutionError extends AvmExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InstructionExecutionError';
-  }
-}
-
-/**
- * Error thrown on failed AVM memory tag check.
- */
-export class TagCheckError extends AvmExecutionError {
-  public static forBaseAddress(gotTag: string): TagCheckError {
-    return new TagCheckError(`Base address (mem[0]) is not a valid address (has tag ${gotTag})`);
-  }
-  public static forIndirectAddress(address: number, gotTag: string): TagCheckError {
-    return new TagCheckError(`Address after indirection is not a valid address (address ${address} has tag ${gotTag})`);
-  }
-  public static forOffset(offset: number, gotTag: string, expectedTag: string): TagCheckError {
-    return new TagCheckError(`Tag mismatch at offset ${offset}, got ${gotTag}, expected ${expectedTag}`);
-  }
-
-  public static forTag(gotTag: string, expectedTag: string): TagCheckError {
-    return new TagCheckError(`Tag mismatch, got ${gotTag}, expected ${expectedTag}`);
-  }
-
-  constructor(message: string) {
-    super(message);
-    this.name = 'TagCheckError';
-  }
-}
-
-/**
- * Error is thrown when a relative memory address resolved to an offset which
- * is out of range, i.e, greater than maxUint32.
- */
-export class RelativeAddressOutOfRangeError extends AvmExecutionError {
-  constructor(baseAddr: number, relOffset: number) {
-    super(`Relative address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
-    this.name = 'RelativeAddressOutOfRangeError';
-  }
-}
-
-/**
- * Error is thrown when a memory slice contains addresses which are
- * out of range, i.e, greater than maxUint32.
- */
-export class MemorySliceOutOfRangeError extends AvmExecutionError {
-  constructor(baseAddr: number, size: number) {
-    super(`Memory slice is out of range. Base address ${baseAddr}, size ${size}`);
-    this.name = 'MemorySliceOutOfRangeError';
-  }
-}
-
-/** Error thrown when out of gas. */
-export class OutOfGasError extends AvmExecutionError {
-  constructor(dimensions: string[]) {
-    super(`Not enough ${dimensions.map(d => d.toUpperCase()).join(', ')} gas left`);
-    this.name = 'OutOfGasError';
-  }
-}
-
-/**
- * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for ECADD opcode.
- */
-export class EcAddPointNotOnCurveError extends AvmExecutionError {
-  constructor(pointIndex: number, point: Point) {
-    super(`EcAdd point${pointIndex} (${point.toString()}) is not on the curve.`);
-    this.name = 'EcAddPointNotOnCurveError';
-  }
-}
-
-/**
- * Error is thrown when some inputs of ToRadixBE are not valid.
- */
-export class InvalidToRadixInputsError extends AvmExecutionError {
-  constructor(errorString: string) {
-    super(errorString);
-    this.name = 'InvalidToRadixInputsError';
-  }
-}
-
-/**
- * Error is thrown when a static call attempts to alter some state
- */
-export class StaticCallAlterationError extends InstructionExecutionError {
-  constructor() {
-    super('Static call cannot update the state, emit L2->L1 messages or generate logs');
-    this.name = 'StaticCallAlterationError';
-  }
-}
-
-/**
- * Meaningfully named alias for ExecutionError when used in the context of the AVM.
- * Maintains a recursive structure reflecting the AVM's external callstack/errorstack, where
- * options.cause is the error that caused this error (if this is not the root-cause itself).
- */
-export class AvmRevertReason extends ExecutionError {
-  constructor(message: string, failingFunction: FailingFunction, noirCallStack: NoirCallStack, options?: ErrorOptions) {
-    super(message, failingFunction, noirCallStack, options);
-  }
-}
-
-/**
- * Helper to annotate errors occurring during instruction fetching.
- */
-export function duringInstrFetch(error: Error, pc: number) {
-  error.message = `Instruction fetching error at pc ${pc}: ${error.message}`;
-  return error;
-}

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -1,122 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { encodeArguments } from '@aztec/stdlib/abi';
-import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasFees } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-import { NativeWorldStateService } from '@aztec/world-state';
-
-import { SideEffectTrace } from '../../../public/side_effect_trace.js';
-import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
-import { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
-import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
-import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
-import { AvmSimulator } from '../avm_simulator.js';
-import { CallDataArray } from '../calldata.js';
-import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
-import { initContext, initExecutionEnvironment } from './initializers.js';
-import {
-  DEFAULT_TIMESTAMP,
-  getContractFunctionAbi,
-  getFunctionSelector,
-  resolveContractAssertionMessage,
-} from './utils.js';
-
-const DEFAULT_GAS_FEES = new GasFees(2, 3);
-
-/**
- * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the core AvmSimulator.
- * It provides an interface for simulating one top-level call at a time and maintains state between
- * subsequent top-level calls.
- */
-export class AvmSimulationTester extends BaseAvmSimulationTester {
-  constructor(
-    contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
-    private stateManager: PublicPersistableStateManager,
-  ) {
-    super(contractDataSource, merkleTrees);
-  }
-
-  static async create(
-    worldStateService: NativeWorldStateService, // make sure to close this later
-  ): Promise<AvmSimulationTester> {
-    const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await worldStateService.fork();
-    const treesDB = new PublicTreesDB(merkleTrees);
-    const contractsDB = new PublicContractsDB(contractDataSource);
-    const trace = new SideEffectTrace();
-    const firstNullifier = new Fr(420000);
-
-    const stateManager = PublicPersistableStateManager.create(
-      treesDB,
-      contractsDB,
-      trace,
-      firstNullifier,
-      DEFAULT_TIMESTAMP,
-    );
-    return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
-  }
-
-  /**
-   * Simulate a top-level contract call.
-   */
-  async simulateCall(
-    sender: AztecAddress,
-    address: AztecAddress,
-    fnName: string,
-    args: any[],
-    isStaticCall = false,
-  ): Promise<AvmContractCallResult> {
-    const contractArtifact = await this.contractDataSource.getContractArtifact(address);
-    if (!contractArtifact) {
-      throw new Error(`Contract not found at address: ${address}`);
-    }
-    const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionAbi(fnName, contractArtifact);
-    const encodedArgs = encodeArguments(fnAbi!, args);
-    const calldata = [fnSelector.toField(), ...encodedArgs];
-
-    const globals = GlobalVariables.empty();
-    globals.timestamp = DEFAULT_TIMESTAMP;
-    globals.gasFees = DEFAULT_GAS_FEES;
-
-    const config = PublicSimulatorConfig.from({
-      skipFeeEnforcement: false,
-      collectDebugLogs: true,
-      collectHints: false,
-      collectStatistics: false,
-      collectCallMetadata: true,
-    });
-    const environment = initExecutionEnvironment({
-      calldata: new CallDataArray(calldata),
-      globals,
-      address,
-      sender,
-      isStaticCall,
-      config,
-    });
-    const persistableState = await this.stateManager.fork();
-    const context = initContext({ env: environment, persistableState });
-
-    // First we simulate (though it's not needed in this simple case).
-    const simulator = new AvmSimulator(context);
-    const result = await simulator.execute();
-    if (result.reverted) {
-      this.logger.error(`Error in ${fnName}:`);
-      this.logger.error(
-        resolveContractAssertionMessage(
-          fnName,
-          result.revertReason!,
-          result.output.bestEffortReadAll(),
-          contractArtifact,
-        )!,
-      );
-    } else {
-      this.logger.info(`Simulation of function ${fnName} succeeded!`);
-      await this.stateManager.merge(persistableState);
-    }
-    return result;
-  }
-}