@aztec/simulator 0.72.1 → 0.73.0

package/src/public/fixtures/index.ts

@@ -1,387 +1,2 @@
-import { MerkleTreeId, type MerkleTreeWriteOperations, PublicExecutionRequest, Tx } from '@aztec/circuit-types';
-import {
-  type AvmCircuitInputs,
-  BlockHeader,
-  CallContext,
-  type ContractClassPublic,
-  type ContractDataSource,
-  type ContractInstanceWithAddress,
-  DEFAULT_GAS_LIMIT,
-  DEPLOYER_CONTRACT_ADDRESS,
-  FunctionSelector,
-  Gas,
-  GasFees,
-  GasSettings,
-  GlobalVariables,
-  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
-  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
-  PartialPrivateTailPublicInputsForPublic,
-  PrivateKernelTailCircuitPublicInputs,
-  type PublicFunction,
-  PublicKeys,
-  RollupValidationRequests,
-  SerializableContractInstance,
-  TxConstantData,
-  TxContext,
-  computePublicBytecodeCommitment,
-} from '@aztec/circuits.js';
-import { siloNullifier } from '@aztec/circuits.js/hash';
-import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/circuits.js/testing';
-import { type ContractArtifact, type FunctionArtifact } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr, Point } from '@aztec/foundation/fields';
-import { openTmpStore } from '@aztec/kv-store/lmdb';
-import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
-import { MerkleTrees } from '@aztec/world-state';
-
-import { strict as assert } from 'assert';
-
-import { initContext, initExecutionEnvironment, initPersistableStateManager } from '../../avm/fixtures/index.js';
-import { AvmEphemeralForest, AvmSimulator } from '../../server.js';
-import { PublicEnqueuedCallSideEffectTrace } from '../enqueued_call_side_effect_trace.js';
-import { WorldStateDB } from '../public_db_sources.js';
-import { PublicTxSimulator } from '../public_tx_simulator.js';
-
-const TIMESTAMP = new Fr(99833);
-
-export async function simulateAvmTestContractGenerateCircuitInputs(
-  setupFunctionNames: string[],
-  setupArgs: Fr[][] = [],
-  appFunctionNames: string[],
-  appArgs: Fr[][] = [],
-  teardownFunctionName?: string,
-  teardownArgs: Fr[] = [],
-  expectRevert: boolean = false,
-  contractDataSource?: MockedAvmTestContractDataSource,
-  assertionErrString?: string,
-): Promise<AvmCircuitInputs> {
-  const globals = GlobalVariables.empty();
-  globals.timestamp = TIMESTAMP;
-
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
-  if (!contractDataSource) {
-    contractDataSource = await MockedAvmTestContractDataSource.create();
-  }
-  await contractDataSource.deployContracts(merkleTrees);
-  const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-
-  const simulator = new PublicTxSimulator(merkleTrees, worldStateDB, globals, /*doMerkleOperations=*/ true);
-
-  const sender = await AztecAddress.random();
-  const callContext = new CallContext(
-    sender,
-    contractDataSource.firstContractInstance.address,
-    contractDataSource.fnSelector,
-    /*isStaticCall=*/ false,
-  );
-  const setupExecutionRequests: PublicExecutionRequest[] = [];
-  for (let i = 0; i < setupFunctionNames.length; i++) {
-    const functionSelector = getAvmTestContractFunctionSelector(setupFunctionNames[i]);
-    const fnArgs = [functionSelector.toField(), ...setupArgs[i]];
-    const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
-    setupExecutionRequests.push(executionRequest);
-  }
-  const appExecutionRequests: PublicExecutionRequest[] = [];
-  for (let i = 0; i < appFunctionNames.length; i++) {
-    const functionSelector = getAvmTestContractFunctionSelector(appFunctionNames[i]);
-    const fnArgs = [functionSelector.toField(), ...appArgs[i]];
-    const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
-    appExecutionRequests.push(executionRequest);
-  }
-
-  let teardownExecutionRequest: PublicExecutionRequest | undefined = undefined;
-  if (teardownFunctionName) {
-    const functionSelector = getAvmTestContractFunctionSelector(teardownFunctionName);
-    const fnArgs = [functionSelector.toField(), ...teardownArgs];
-    teardownExecutionRequest = new PublicExecutionRequest(callContext, fnArgs);
-  }
-
-  const tx: Tx = createTxForPublicCalls(
-    setupExecutionRequests,
-    appExecutionRequests,
-    Fr.random(),
-    teardownExecutionRequest,
-  );
-
-  const avmResult = await simulator.simulate(tx);
-
-  if (!expectRevert) {
-    expect(avmResult.revertCode.isOK()).toBe(true);
-  } else {
-    // Explicit revert when an assertion failed.
-    expect(avmResult.revertCode.isOK()).toBe(false);
-    expect(avmResult.revertReason).toBeDefined();
-    if (assertionErrString !== undefined) {
-      expect(avmResult.revertReason?.getMessage()).toContain(assertionErrString);
-    }
-  }
-
-  const avmCircuitInputs: AvmCircuitInputs = avmResult.avmProvingRequest.inputs;
-  return avmCircuitInputs;
-}
-
-export async function simulateAvmTestContractCall(
-  functionName: string,
-  args: Fr[] = [],
-  expectRevert: boolean = false,
-  contractDataSource?: MockedAvmTestContractDataSource,
-) {
-  const globals = GlobalVariables.empty();
-  globals.timestamp = TIMESTAMP;
-
-  if (!contractDataSource) {
-    contractDataSource = await MockedAvmTestContractDataSource.create();
-  }
-
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
-  await contractDataSource.deployContracts(merkleTrees);
-  const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-
-  const trace = new PublicEnqueuedCallSideEffectTrace();
-  const ephemeralTrees = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
-  const persistableState = initPersistableStateManager({
-    worldStateDB,
-    trace,
-    merkleTrees: ephemeralTrees,
-    doMerkleOperations: true,
-  });
-
-  const sender = await AztecAddress.random();
-  const functionSelector = getAvmTestContractFunctionSelector(functionName);
-  args = [functionSelector.toField(), ...args];
-  const environment = initExecutionEnvironment({
-    calldata: args,
-    globals,
-    address: contractDataSource.firstContractInstance.address,
-    sender,
-  });
-  const context = initContext({ env: environment, persistableState });
-
-  // First we simulate (though it's not needed in this simple case).
-  const simulator = new AvmSimulator(context);
-  const results = await simulator.execute();
-
-  expect(results.reverted).toBe(expectRevert);
-}
-
-/**
- * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
- */
-export function createTxForPublicCalls(
-  setupExecutionRequests: PublicExecutionRequest[],
-  appExecutionRequests: PublicExecutionRequest[],
-  firstNullifier: Fr,
-  teardownExecutionRequest?: PublicExecutionRequest,
-  gasUsedByPrivate: Gas = Gas.empty(),
-): Tx {
-  assert(
-    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
-    "Can't create public tx with no enqueued calls",
-  );
-  const setupCallRequests = setupExecutionRequests.map(er => er.toCallRequest());
-  const appCallRequests = appExecutionRequests.map(er => er.toCallRequest());
-  // use max limits
-  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
-
-  const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
-  // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier; // fake tx nullifier
-
-  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
-  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
-    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
-  }
-  for (let i = appCallRequests.length - 1; i >= 0; i--) {
-    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
-  }
-  if (teardownExecutionRequest) {
-    forPublic.publicTeardownCallRequest = teardownExecutionRequest.toCallRequest();
-  }
-
-  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
-  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
-  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
-  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-
-  const txData = new PrivateKernelTailCircuitPublicInputs(
-    constantData,
-    RollupValidationRequests.empty(),
-    /*gasUsed=*/ gasUsedByPrivate,
-    AztecAddress.zero(),
-    forPublic,
-  );
-  const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
-
-  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
-  // Also push app calls before setup calls for this reason.
-  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
-    tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
-  }
-  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
-    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
-  }
-
-  return tx;
-}
-
-export class MockedAvmTestContractDataSource implements ContractDataSource {
-  private fnName = 'public_dispatch';
-  public fnSelector: FunctionSelector = getAvmTestContractFunctionSelector(this.fnName);
-  private bytecode: Buffer;
-  private publicFn: PublicFunction;
-  private bytecodeCommitment: Fr;
-
-  // maps contract class ID to class
-  private contractClasses: Map<string, ContractClassPublic> = new Map();
-  // maps contract instance address to instance
-  public contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
-
-  public firstContractInstance: ContractInstanceWithAddress = SerializableContractInstance.default().withAddress(
-    AztecAddress.fromNumber(0),
-  );
-  public instanceSameClassAsFirstContract: ContractInstanceWithAddress =
-    SerializableContractInstance.default().withAddress(AztecAddress.fromNumber(0));
-  public otherContractInstance!: ContractInstanceWithAddress;
-
-  private constructor(private skipContractDeployments: boolean) {
-    this.bytecode = getAvmTestContractBytecode(this.fnName);
-    this.fnSelector = getAvmTestContractFunctionSelector(this.fnName);
-    this.publicFn = { bytecode: this.bytecode, selector: this.fnSelector };
-    this.bytecodeCommitment = computePublicBytecodeCommitment(this.bytecode);
-  }
-
-  async deployContracts(merkleTrees: MerkleTreeWriteOperations) {
-    if (!this.skipContractDeployments) {
-      for (const contractInstance of this.contractInstances.values()) {
-        const contractAddressNullifier = siloNullifier(
-          AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-          contractInstance.address.toField(),
-        );
-        await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
-      }
-
-      const instanceSameClassAsFirstContractNullifier = siloNullifier(
-        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-        this.instanceSameClassAsFirstContract.address.toField(),
-      );
-      await merkleTrees.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        [instanceSameClassAsFirstContractNullifier.toBuffer()],
-        0,
-      );
-
-      // other contract address used by the bulk test's GETCONTRACTINSTANCE test
-      const otherContractAddressNullifier = siloNullifier(
-        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-        this.otherContractInstance.address.toField(),
-      );
-      await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [otherContractAddressNullifier.toBuffer()], 0);
-    }
-  }
-
-  public static async create(skipContractDeployments: boolean = false): Promise<MockedAvmTestContractDataSource> {
-    const dataSource = new MockedAvmTestContractDataSource(skipContractDeployments);
-    // create enough unique classes to hit the limit (plus two extra)
-    for (let i = 0; i < MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS + 1; i++) {
-      const contractClass = makeContractClassPublic(/*seed=*/ i, dataSource.publicFn);
-      const contractInstance = await makeContractInstanceFromClassId(contractClass.id, /*seed=*/ i);
-      dataSource.contractClasses.set(contractClass.id.toString(), contractClass);
-      dataSource.contractInstances.set(contractInstance.address.toString(), contractInstance);
-      if (i === 0) {
-        dataSource.firstContractInstance = contractInstance;
-      }
-    }
-    // a contract with the same class but different instance/address as the first contract
-    dataSource.instanceSameClassAsFirstContract = await makeContractInstanceFromClassId(
-      dataSource.firstContractInstance.contractClassId,
-      /*seed=*/ 1000,
-    );
-
-    // The values here should match those in `avm_simulator.test.ts`
-    // Used for GETCONTRACTINSTANCE test
-    dataSource.otherContractInstance = new SerializableContractInstance({
-      version: 1,
-      salt: new Fr(0x123),
-      deployer: new AztecAddress(new Fr(0x456)),
-      contractClassId: new Fr(0x789),
-      initializationHash: new Fr(0x101112),
-      publicKeys: new PublicKeys(
-        new Point(new Fr(0x131415), new Fr(0x161718), false),
-        new Point(new Fr(0x192021), new Fr(0x222324), false),
-        new Point(new Fr(0x252627), new Fr(0x282930), false),
-        new Point(new Fr(0x313233), new Fr(0x343536), false),
-      ),
-    }).withAddress(AztecAddress.fromNumber(0x4444));
-    return dataSource;
-  }
-
-  getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
-    return Promise.resolve(this.publicFn);
-  }
-
-  getBlockNumber(): Promise<number> {
-    throw new Error('Method not implemented.');
-  }
-
-  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    return Promise.resolve(this.contractClasses.get(id.toString()));
-  }
-
-  getBytecodeCommitment(_id: Fr): Promise<Fr> {
-    return Promise.resolve(this.bytecodeCommitment);
-  }
-
-  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
-    return Promise.resolve();
-  }
-
-  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    if (!this.skipContractDeployments) {
-      if (address.equals(this.otherContractInstance.address)) {
-        return Promise.resolve(this.otherContractInstance);
-      } else if (address.equals(this.instanceSameClassAsFirstContract.address)) {
-        return Promise.resolve(this.instanceSameClassAsFirstContract);
-      } else {
-        return Promise.resolve(this.contractInstances.get(address.toString()));
-      }
-    }
-    return Promise.resolve(undefined);
-  }
-
-  getContractClassIds(): Promise<Fr[]> {
-    throw new Error('Method not implemented.');
-  }
-
-  getContractArtifact(_address: AztecAddress): Promise<ContractArtifact | undefined> {
-    throw new Error('Method not implemented.');
-  }
-
-  getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
-    return Promise.resolve(this.fnName);
-  }
-
-  registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-function getAvmTestContractFunctionSelector(functionName: string): FunctionSelector {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
-}
-
-function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact;
-}
-
-function getAvmTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmTestContractArtifact(functionName);
-  return artifact.bytecode;
-}
+export * from './public_tx_simulation_tester.js';
+export * from './utils.js';

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -0,0 +1,174 @@
+import { MerkleTreeId, PublicExecutionRequest, type Tx } from '@aztec/circuit-types';
+import {
+  type AvmCircuitPublicInputs,
+  CallContext,
+  FunctionSelector,
+  GasFees,
+  GlobalVariables,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+  PUBLIC_DISPATCH_SELECTOR,
+} from '@aztec/circuits.js';
+import { type ContractArtifact, encodeArguments } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { openTmpStore } from '@aztec/kv-store/lmdb';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+import { MerkleTrees } 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.js';
+import { createTxForPublicCalls } from './index.js';
+
+const TIMESTAMP = new Fr(99833);
+const DEFAULT_GAS_FEES = new GasFees(2, 3);
+
+export type TestEnqueuedCall = {
+  address: AztecAddress;
+  fnName: string;
+  args: any[];
+  isStaticCall?: boolean;
+};
+
+/**
+ * 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;
+
+  public static async create(skipContractDeployments = false): Promise<PublicTxSimulationTester> {
+    const contractDataSource = new SimpleContractDataSource();
+    const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
+    return new PublicTxSimulationTester(contractDataSource, merkleTrees, skipContractDeployments);
+  }
+
+  public async simulateTx(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[] = [],
+    appCalls: TestEnqueuedCall[] = [],
+    teardownCall?: TestEnqueuedCall,
+    feePayer: AztecAddress = AztecAddress.zero(),
+  ): Promise<PublicTxResult> {
+    const globals = GlobalVariables.empty();
+    globals.timestamp = TIMESTAMP;
+    globals.gasFees = DEFAULT_GAS_FEES;
+
+    const worldStateDB = new WorldStateDB(this.merkleTrees, this.contractDataSource);
+    const simulator = new PublicTxSimulator(this.merkleTrees, worldStateDB, globals, /*doMerkleOperations=*/ true);
+
+    const setupExecutionRequests: PublicExecutionRequest[] = [];
+    for (let i = 0; i < setupCalls.length; i++) {
+      const address = setupCalls[i].address;
+      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      const req = await executionRequestForCall(
+        sender,
+        address,
+        setupCalls[i].fnName,
+        setupCalls[i].args,
+        setupCalls[i].isStaticCall,
+        contractArtifact,
+      );
+      setupExecutionRequests.push(req);
+    }
+    const appExecutionRequests: PublicExecutionRequest[] = [];
+    for (let i = 0; i < appCalls.length; i++) {
+      const address = appCalls[i].address;
+      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      const req = await executionRequestForCall(
+        sender,
+        address,
+        appCalls[i].fnName,
+        appCalls[i].args,
+        appCalls[i].isStaticCall,
+        contractArtifact,
+      );
+      appExecutionRequests.push(req);
+    }
+
+    let teardownExecutionRequest: PublicExecutionRequest | undefined = undefined;
+    if (teardownCall) {
+      const address = teardownCall.address;
+      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      teardownExecutionRequest = await executionRequestForCall(
+        sender,
+        address,
+        teardownCall.fnName,
+        teardownCall.args,
+        teardownCall.isStaticCall,
+        contractArtifact,
+      );
+    }
+
+    // Use a fake "first nullifier" to make sure note hash nonces are computed properly,
+    // but make sure each tx has a unique first nullifier.
+    const firstNullifier = new Fr(420000 + this.txCount++);
+
+    const tx: Tx = await createTxForPublicCalls(
+      firstNullifier,
+      setupExecutionRequests,
+      appExecutionRequests,
+      teardownExecutionRequest,
+      feePayer,
+    );
+
+    const avmResult = await simulator.simulate(tx);
+
+    if (avmResult.revertCode.isOK()) {
+      await this.commitTxStateUpdates(avmResult.avmProvingRequest.inputs.publicInputs);
+    }
+
+    return avmResult;
+  }
+
+  private async commitTxStateUpdates(avmCircuitInputs: AvmCircuitPublicInputs) {
+    await this.merkleTrees.appendLeaves(
+      MerkleTreeId.NOTE_HASH_TREE,
+      padArrayEnd(avmCircuitInputs.accumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    );
+    try {
+      await this.merkleTrees.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        padArrayEnd(avmCircuitInputs.accumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
+        NULLIFIER_SUBTREE_HEIGHT,
+      );
+    } catch (error) {
+      this.logger.warn(`Detected duplicate nullifier.`);
+    }
+
+    await this.merkleTrees.batchInsert(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      avmCircuitInputs.accumulatedData.publicDataWrites.map(w => w.toBuffer()),
+      PUBLIC_DATA_TREE_HEIGHT,
+    );
+  }
+}
+
+async function executionRequestForCall(
+  sender: AztecAddress,
+  address: AztecAddress,
+  fnName: string,
+  args: Fr[] = [],
+  isStaticCall: boolean = false,
+  contractArtifact: ContractArtifact = AvmTestContractArtifact,
+): 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);
+}

package/src/public/fixtures/utils.ts

@@ -0,0 +1,110 @@
+import { type PublicExecutionRequest, Tx } from '@aztec/circuit-types';
+import {
+  BlockHeader,
+  DEFAULT_GAS_LIMIT,
+  FunctionSelector,
+  Gas,
+  GasFees,
+  GasSettings,
+  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  PartialPrivateTailPublicInputsForPublic,
+  PrivateKernelTailCircuitPublicInputs,
+  RollupValidationRequests,
+  TxConstantData,
+  TxContext,
+} from '@aztec/circuits.js';
+import { type FunctionArtifact } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+
+import { strict as assert } from 'assert';
+
+export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+
+/**
+ * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
+ */
+export async function createTxForPublicCalls(
+  firstNullifier: Fr,
+  setupExecutionRequests: PublicExecutionRequest[],
+  appExecutionRequests: PublicExecutionRequest[],
+  teardownExecutionRequest?: PublicExecutionRequest,
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = Gas.empty(),
+): Promise<Tx> {
+  assert(
+    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
+    "Can't create public tx with no enqueued calls",
+  );
+  const setupCallRequests = await Promise.all(setupExecutionRequests.map(er => er.toCallRequest()));
+  const appCallRequests = await Promise.all(appExecutionRequests.map(er => er.toCallRequest()));
+  // use max limits
+  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+
+  const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
+  // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
+  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier; // fake tx nullifier
+
+  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
+  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+  }
+  for (let i = appCallRequests.length - 1; i >= 0; i--) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+  }
+  if (teardownExecutionRequest) {
+    forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+  }
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    RollupValidationRequests.empty(),
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    forPublic,
+  );
+  const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
+
+  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
+  // Also push app calls before setup calls for this reason.
+  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
+  }
+  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
+  }
+
+  return tx;
+}
+
+export function getAvmTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
+  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
+  const params = artifact.parameters;
+  return FunctionSelector.fromNameAndParameters(artifact.name, params);
+}
+
+export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
+  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  assert(
+    !!artifact?.bytecode,
+    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
+  );
+  return artifact;
+}
+
+export function getAvmTestContractBytecode(functionName: string): Buffer {
+  const artifact = getAvmTestContractArtifact(functionName);
+  return artifact.bytecode;
+}
+
+export function getAvmTestContractPublicDispatchBytecode(): Buffer {
+  return getAvmTestContractBytecode(PUBLIC_DISPATCH_FN_NAME);
+}

package/src/public/index.ts

@@ -4,5 +4,5 @@ export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult }
 export * from './fee_payment.js';
 export * from './public_db_sources.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
-export { PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
+export { SideEffectTrace } from './side_effect_trace.js';
 export { getExecutionRequestsByPhase } from './utils.js';