@aztec/simulator 0.0.0-test.0

package/src/public/avm/serialization/instruction_serialization.ts

@@ -0,0 +1,208 @@
+import { strict as assert } from 'assert';
+
+import { BufferCursor } from './buffer_cursor.js';
+
+/**
+ * All AVM opcodes. (Keep in sync with cpp counterpart code avm_opcode.hpp and rs in opcodes.rs).
+ * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
+ */
+export enum Opcode {
+  // Compute
+  ADD_8,
+  ADD_16,
+  SUB_8,
+  SUB_16,
+  MUL_8,
+  MUL_16,
+  DIV_8,
+  DIV_16,
+  FDIV_8,
+  FDIV_16,
+  EQ_8,
+  EQ_16,
+  LT_8,
+  LT_16,
+  LTE_8,
+  LTE_16,
+  AND_8,
+  AND_16,
+  OR_8,
+  OR_16,
+  XOR_8,
+  XOR_16,
+  NOT_8,
+  NOT_16,
+  SHL_8,
+  SHL_16,
+  SHR_8,
+  SHR_16,
+  CAST_8,
+  CAST_16,
+  // Execution environment
+  GETENVVAR_16,
+  CALLDATACOPY,
+  SUCCESSCOPY,
+  RETURNDATASIZE,
+  RETURNDATACOPY,
+  // Control flow
+  JUMP_32,
+  JUMPI_32,
+  INTERNALCALL,
+  INTERNALRETURN,
+  // Memory
+  SET_8,
+  SET_16,
+  SET_32,
+  SET_64,
+  SET_128,
+  SET_FF,
+  MOV_8,
+  MOV_16,
+  // World state
+  SLOAD,
+  SSTORE,
+  NOTEHASHEXISTS,
+  EMITNOTEHASH,
+  NULLIFIEREXISTS,
+  EMITNULLIFIER,
+  L1TOL2MSGEXISTS,
+  GETCONTRACTINSTANCE,
+  EMITUNENCRYPTEDLOG,
+  SENDL2TOL1MSG,
+  // External calls
+  CALL,
+  STATICCALL,
+  RETURN,
+  REVERT_8,
+  REVERT_16,
+  // Misc
+  DEBUGLOG,
+  // Gadgets
+  POSEIDON2,
+  SHA256COMPRESSION,
+  KECCAKF1600,
+  ECADD,
+  // Conversion
+  TORADIXBE,
+}
+
+export const MAX_OPCODE_VALUE = Math.max(
+  ...Object.values(Opcode)
+    .map(k => +k)
+    .filter(k => !isNaN(k)),
+);
+
+// Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
+// See vm/avm_trace/deserialization.cpp)
+// Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
+// this one is parsed as UINT8.
+export enum OperandType {
+  UINT8,
+  UINT16,
+  UINT32,
+  UINT64,
+  UINT128,
+  FF,
+}
+
+type OperandNativeType = number | bigint;
+type OperandWriter = (value: any) => void;
+
+// Specifies how to read and write each operand type.
+const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNativeType, OperandWriter]>([
+  [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
+  [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
+  [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
+  [OperandType.UINT64, [8, Buffer.prototype.readBigInt64BE, Buffer.prototype.writeBigInt64BE]],
+  [OperandType.UINT128, [16, readBigInt128BE, writeBigInt128BE]],
+  [OperandType.FF, [32, readBigInt254BE, writeBigInt254BE]],
+]);
+
+function readBigInt254BE(this: Buffer, offset: number): bigint {
+  const totalBytes = 32;
+  let ret: bigint = 0n;
+  for (let i = 0; i < totalBytes; ++i) {
+    ret <<= 8n;
+    ret |= BigInt(this.readUint8(i + offset));
+  }
+  return ret;
+}
+
+function writeBigInt254BE(this: Buffer, value: bigint): void {
+  const totalBytes = 32;
+  for (let offset = totalBytes - 1; offset >= 0; --offset) {
+    this.writeUint8(Number(value & 0xffn), offset);
+    value >>= 8n;
+  }
+}
+
+function readBigInt128BE(this: Buffer, offset: number): bigint {
+  const totalBytes = 16;
+  let ret: bigint = 0n;
+  for (let i = 0; i < totalBytes; ++i) {
+    ret <<= 8n;
+    ret |= BigInt(this.readUint8(i + offset));
+  }
+  return ret;
+}
+
+function writeBigInt128BE(this: Buffer, value: bigint): void {
+  const totalBytes = 16;
+  for (let offset = totalBytes - 1; offset >= 0; --offset) {
+    this.writeUint8(Number(value & 0xffn), offset);
+    value >>= 8n;
+  }
+}
+
+/**
+ * Reads an array of operands from a buffer.
+ * @param cursor Buffer to read from. Might be longer than needed.
+ * @param operands Specification of the operand types.
+ * @returns An array as big as {@code operands}, with the converted TS values.
+ */
+export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[] {
+  const argValues = [];
+  if (Buffer.isBuffer(cursor)) {
+    cursor = new BufferCursor(cursor);
+  }
+
+  for (const op of operands) {
+    const opType = op;
+    const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
+    argValues.push(reader.call(cursor.buffer(), cursor.position()));
+    cursor.advance(sizeBytes);
+  }
+
+  return argValues;
+}
+
+/**
+ * Serializes a class using the specified operand types.
+ * More specifically, this serializes {@code [cls.constructor.opcode, ...Object.values(cls)]}.
+ * Observe in particular that:
+ *   (1) the first operand type specified must correspond to the opcode;
+ *   (2) the rest of the operand types must be specified in the order returned by {@code Object.values()}.
+ * @param operands Type specification for the values to be serialized.
+ * @param cls The class to be serialized.
+ * @returns
+ */
+export function serializeAs(operands: OperandType[], opcode: Opcode, cls: any): Buffer {
+  const chunks: Buffer[] = [];
+
+  const rawClassValues: any[] = [opcode, ...Object.values(cls)];
+  assert(
+    rawClassValues.length === operands.length,
+    `Got ${rawClassValues.length} values but only ${operands.length} serialization operands are specified!`,
+  );
+  const classValues = rawClassValues as OperandNativeType[];
+
+  for (let i = 0; i < operands.length; i++) {
+    const opType = operands[i];
+    const [sizeBytes, _reader, writer] = OPERAND_SPEC.get(opType)!;
+    const buf = Buffer.alloc(sizeBytes);
+    writer.call(buf, classValues[i]);
+    chunks.push(buf);
+  }
+
+  return Buffer.concat(chunks);
+}

package/src/public/avm/test_utils.ts

@@ -0,0 +1,81 @@
+import { Fr } from '@aztec/foundation/fields';
+import {
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  computePublicBytecodeCommitment,
+} from '@aztec/stdlib/contract';
+
+import type { jest } from '@jest/globals';
+import { mock } from 'jest-mock-extended';
+
+import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
+
+export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+  const commitment = await computePublicBytecodeCommitment(bytecode);
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
+}
+
+export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
+  (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
+    nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
+  );
+}
+
+export function mockStorageRead(worldStateDB: WorldStateDB, value: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockResolvedValue(value);
+}
+
+export function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number) {
+  (mockedTrace as jest.Mocked<PublicSideEffectTraceInterface>).getNoteHashCount.mockReturnValue(count);
+}
+
+export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockImplementation((_address, slot) =>
+    Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
+  );
+}
+
+export function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
+}
+
+export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getCommitmentValue.mockImplementation((index: bigint) => {
+    if (index == _leafIndex.toBigInt()) {
+      return Promise.resolve(value);
+    } else {
+      // This is ok for now since the traceing functions handle it
+      return Promise.resolve(undefined);
+    }
+  });
+}
+
+export function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockL1ToL2MessageExists(
+  worldStateDB: WorldStateDB,
+  leafIndex: Fr,
+  value: Fr,
+  valueAtOtherIndices?: Fr,
+) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+    if (index == leafIndex.toBigInt()) {
+      return Promise.resolve(value);
+    } else {
+      // any indices other than mockAtLeafIndex will return a different value
+      // (or undefined if no value is specified for other indices)
+      return Promise.resolve(valueAtOtherIndices!);
+    }
+  });
+}
+
+export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
+}
+
+export function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getContractClass.mockResolvedValue(contractClass);
+}

package/src/public/bytecode_errors.ts

@@ -0,0 +1,6 @@
+export class ContractClassBytecodeError extends Error {
+  constructor(contractAddress: string) {
+    super(`Failed to get bytecode for contract at address ${contractAddress}`);
+    this.name = 'ContractClassBytecodeError';
+  }
+}

package/src/public/execution.ts

@@ -0,0 +1,140 @@
+import type { Fr } from '@aztec/foundation/fields';
+import {
+  type AvmExecutionHints,
+  type ContractStorageRead,
+  type ContractStorageUpdateRequest,
+  PublicCallStackItemCompressed,
+  type PublicDataUpdateRequest,
+  PublicInnerCallRequest,
+  RevertCode,
+} from '@aztec/stdlib/avm';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+import type { NoteHash, Nullifier, ReadRequest, TreeLeafReadRequest } from '@aztec/stdlib/kernel';
+import type { PublicLog } from '@aztec/stdlib/logs';
+import type { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import type { PublicExecutionRequest } from '@aztec/stdlib/tx';
+
+export interface PublicSideEffects {
+  /** The contract storage update requests performed. */
+  publicDataWrites: PublicDataUpdateRequest[];
+  /** The new note hashes to be inserted into the note hashes tree. */
+  noteHashes: NoteHash[];
+  /** The new nullifiers to be inserted into the nullifier tree. */
+  nullifiers: Nullifier[];
+  /** The new l2 to l1 messages generated to be inserted into the messages tree. */
+  l2ToL1Messages: ScopedL2ToL1Message[];
+  /** Public logs emitted during execution. */
+  publicLogs: PublicLog[];
+}
+
+export interface EnqueuedPublicCallExecutionResult {
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** The side effect counter after execution */
+  endSideEffectCounter: Fr;
+
+  /** The return values of the function. */
+  returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+}
+
+export interface EnqueuedPublicCallExecutionResultWithSideEffects {
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** The side effect counter after execution */
+  endSideEffectCounter: Fr;
+
+  /** The return values of the function. */
+  returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+
+  /** The public side effects of the function. */
+  sideEffects: PublicSideEffects;
+}
+
+/**
+ * The public function execution result.
+ */
+export interface PublicFunctionCallResult {
+  /** The execution request that triggered this result. */
+  executionRequest: PublicExecutionRequest;
+
+  /** The side effect counter at the start of the function call. */
+  startSideEffectCounter: Fr;
+  /** The side effect counter after executing this function call */
+  endSideEffectCounter: Fr;
+  /** How much gas was available for this public execution. */
+  startGasLeft: Gas;
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** Transaction fee set for this tx. */
+  transactionFee: Fr;
+
+  /** Bytecode used for this execution. */
+  bytecode?: Buffer;
+  /** Calldata used for this execution. */
+  calldata: Fr[];
+  /** The return values of the function. */
+  returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+
+  /** The contract storage reads performed by the function. */
+  contractStorageReads: ContractStorageRead[];
+  /** The contract storage update requests performed by the function. */
+  contractStorageUpdateRequests: ContractStorageUpdateRequest[];
+  /** The new note hashes to be inserted into the note hashes tree. */
+  noteHashes: NoteHash[];
+  /** The new l2 to l1 messages generated in this call. */
+  l2ToL1Messages: L2ToL1Message[];
+  /** The new nullifiers to be inserted into the nullifier tree. */
+  nullifiers: Nullifier[];
+  /** The note hash read requests emitted in this call. */
+  noteHashReadRequests: TreeLeafReadRequest[];
+  /** The nullifier read requests emitted in this call. */
+  nullifierReadRequests: ReadRequest[];
+  /** The nullifier non existent read requests emitted in this call. */
+  nullifierNonExistentReadRequests: ReadRequest[];
+  /** L1 to L2 message read requests emitted in this call. */
+  l1ToL2MsgReadRequests: TreeLeafReadRequest[];
+  /**
+   * The public logs emitted in this call.
+   * Note: PublicLog has no counter - unsure if this is needed bc this struct is unused
+   */
+  publicLogs: PublicLog[];
+  /** The requests to call public functions made by this call. */
+  publicCallRequests: PublicInnerCallRequest[];
+  /** The results of nested calls. */
+  nestedExecutions: this[];
+
+  /** Hints for proving AVM execution. */
+  avmCircuitHints: AvmExecutionHints;
+
+  /** The name of the function that was executed. Only used for logging. */
+  functionName: string;
+}
+
+export async function resultToPublicCallRequest(result: PublicFunctionCallResult) {
+  const request = result.executionRequest;
+  const item = new PublicCallStackItemCompressed(
+    request.callContext.contractAddress,
+    request.callContext,
+    await computeVarArgsHash(request.args),
+    await computeVarArgsHash(result.returnValues),
+    // TODO(@just-mitch): need better mapping from simulator to revert code.
+    result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
+    Gas.from(result.startGasLeft),
+    Gas.from(result.endGasLeft),
+  );
+  return new PublicInnerCallRequest(item, result.startSideEffectCounter.toNumber());
+}

package/src/public/executor_metrics.ts

@@ -0,0 +1,71 @@
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class ExecutorMetrics {
+  public readonly tracer: Tracer;
+  private fnCount: UpDownCounter;
+  private fnDuration: Histogram;
+  private manaPerSecond: Histogram;
+  private privateEffectsInsertions: Histogram;
+
+  constructor(client: TelemetryClient, name = 'PublicExecutor') {
+    this.tracer = client.getTracer(name);
+    const meter = client.getMeter(name);
+
+    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
+      description: 'Number of functions executed',
+    });
+
+    this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION, {
+      description: 'How long it takes to execute a function',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.manaPerSecond = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_PER_SECOND, {
+      description: 'Mana used per second',
+      unit: 'mana/s',
+      valueType: ValueType.INT,
+    });
+
+    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTION_PRIVATE_EFFECTS_INSERTION, {
+      description: 'Private effects insertion time',
+      unit: 'us',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordFunctionSimulation(durationMs: number, manaUsed: number, fnName: string) {
+    this.fnCount.add(1, {
+      [Attributes.OK]: true,
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+      [Attributes.MANA_USED]: manaUsed,
+    });
+    this.fnDuration.record(Math.ceil(durationMs));
+    if (durationMs > 0 && manaUsed > 0) {
+      const manaPerSecond = Math.round((manaUsed * 1000) / durationMs);
+      this.manaPerSecond.record(manaPerSecond, {
+        [Attributes.APP_CIRCUIT_NAME]: fnName,
+      });
+    }
+  }
+
+  recordFunctionSimulationFailure() {
+    this.fnCount.add(1, {
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
+    this.privateEffectsInsertions.record(Math.ceil(durationUs), {
+      [Attributes.REVERTIBILITY]: type,
+    });
+  }
+}

package/src/public/fixtures/index.ts

@@ -0,0 +1,2 @@
+export * from './public_tx_simulation_tester.js';
+export * from './utils.js';

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -0,0 +1,179 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { type ContractArtifact, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { PublicExecutionRequest, type Tx } from '@aztec/stdlib/tx';
+import { CallContext, GlobalVariables } from '@aztec/stdlib/tx';
+import { NativeWorldStateService } from '@aztec/world-state';
+
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { getContractFunctionArtifact, getFunctionSelector } from '../avm/fixtures/index.js';
+import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
+import { WorldStateDB } from '../public_db_sources.js';
+import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { createTxForPublicCalls } from './index.js';
+
+const TIMESTAMP = new Fr(99833);
+const DEFAULT_GAS_FEES = new GasFees(2, 3);
+export const DEFAULT_BLOCK_NUMBER = 42;
+
+export type TestEnqueuedCall = {
+  address: AztecAddress;
+  fnName: string;
+  args: any[];
+  isStaticCall?: boolean;
+  contractArtifact?: ContractArtifact;
+};
+
+/**
+ * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the PublicTxSimulator.
+ * It provides an interface for simulating one transaction at a time and maintains state between subsequent
+ * transactions.
+ */
+export class PublicTxSimulationTester extends BaseAvmSimulationTester {
+  private txCount = 0;
+
+  constructor(
+    private worldStateDB: WorldStateDB,
+    contractDataSource: SimpleContractDataSource,
+    merkleTrees: MerkleTreeWriteOperations,
+  ) {
+    super(contractDataSource, merkleTrees);
+  }
+
+  public static async create(): Promise<PublicTxSimulationTester> {
+    const contractDataSource = new SimpleContractDataSource();
+    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
+    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees);
+  }
+
+  public async createTx(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[] = [],
+    appCalls: TestEnqueuedCall[] = [],
+    teardownCall?: TestEnqueuedCall,
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+  ): Promise<Tx> {
+    const setupExecutionRequests: PublicExecutionRequest[] = [];
+    for (let i = 0; i < setupCalls.length; i++) {
+      const address = setupCalls[i].address;
+      const contractArtifact =
+        setupCalls[i].contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
+      const req = await executionRequestForCall(
+        contractArtifact,
+        sender,
+        address,
+        setupCalls[i].fnName,
+        setupCalls[i].args,
+        setupCalls[i].isStaticCall,
+      );
+      setupExecutionRequests.push(req);
+    }
+    const appExecutionRequests: PublicExecutionRequest[] = [];
+    for (let i = 0; i < appCalls.length; i++) {
+      const address = appCalls[i].address;
+      const contractArtifact =
+        appCalls[i].contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
+      const req = await executionRequestForCall(
+        contractArtifact,
+        sender,
+        address,
+        appCalls[i].fnName,
+        appCalls[i].args,
+        appCalls[i].isStaticCall,
+      );
+      appExecutionRequests.push(req);
+    }
+
+    let teardownExecutionRequest: PublicExecutionRequest | undefined = undefined;
+    if (teardownCall) {
+      const address = teardownCall.address;
+      const contractArtifact =
+        teardownCall.contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
+      teardownExecutionRequest = await executionRequestForCall(
+        contractArtifact,
+        sender,
+        address,
+        teardownCall.fnName,
+        teardownCall.args,
+        teardownCall.isStaticCall,
+      );
+    }
+
+    return await createTxForPublicCalls(
+      firstNullifier,
+      setupExecutionRequests,
+      appExecutionRequests,
+      teardownExecutionRequest,
+      feePayer,
+    );
+  }
+
+  public async simulateTx(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[] = [],
+    appCalls: TestEnqueuedCall[] = [],
+    teardownCall?: TestEnqueuedCall,
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+    globals = defaultGlobals(),
+  ): Promise<PublicTxResult> {
+    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier);
+
+    await this.setFeePayerBalance(feePayer);
+
+    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
+
+    const startTime = performance.now();
+    const avmResult = await simulator.simulate(tx);
+    const endTime = performance.now();
+    this.logger.debug(`Public transaction simulation took ${endTime - startTime}ms`);
+
+    return avmResult;
+  }
+}
+
+async function executionRequestForCall(
+  contractArtifact: ContractArtifact,
+  sender: AztecAddress,
+  address: AztecAddress,
+  fnName: string,
+  args: Fr[] = [],
+  isStaticCall: boolean = false,
+): Promise<PublicExecutionRequest> {
+  const fnSelector = await getFunctionSelector(fnName, contractArtifact);
+  const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
+  const encodedArgs = encodeArguments(fnAbi!, args);
+  const calldata = [fnSelector.toField(), ...encodedArgs];
+
+  const callContext = new CallContext(
+    sender,
+    address,
+    /*selector=*/ new FunctionSelector(PUBLIC_DISPATCH_SELECTOR),
+    isStaticCall,
+  );
+  return new PublicExecutionRequest(callContext, calldata);
+}
+
+function defaultGlobals() {
+  const globals = GlobalVariables.empty();
+  globals.timestamp = TIMESTAMP;
+  globals.gasFees = DEFAULT_GAS_FEES; // apply some nonzero default gas fees
+  globals.blockNumber = new Fr(DEFAULT_BLOCK_NUMBER);
+  return globals;
+}