@aztec/simulator 0.82.0 → 0.82.1

package/src/private/private_execution_oracle.ts

@@ -1,8 +1,4 @@
-import {
-  MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS,
-  PRIVATE_CONTEXT_INPUTS_LENGTH,
-  PUBLIC_DISPATCH_SELECTOR,
-} from '@aztec/constants';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import {
@@ -23,10 +19,8 @@ import {
   CallContext,
   Capsule,
   CountedContractClassLog,
-  CountedPublicExecutionRequest,
   NoteAndSlot,
   PrivateCallExecutionResult,
-  PublicExecutionRequest,
   type TxContext,
 } from '@aztec/stdlib/tx';
 
@@ -64,8 +58,6 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
   private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private contractClassLogs: CountedContractClassLog[] = [];
   private nestedExecutions: PrivateCallExecutionResult[] = [];
-  private enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[] = [];
-  private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
 
   constructor(
     private readonly argsHash: Fr,
@@ -80,7 +72,7 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     private readonly noteCache: ExecutionNoteCache,
     executionDataProvider: ExecutionDataProvider,
     private provider: SimulationProvider,
-    private totalPublicArgsCount: number,
+    private totalPublicCalldataCount: number,
     protected sideEffectCounter: number = 0,
     log = createLogger('simulator:client_execution_context'),
     scopes?: AztecAddress[],
@@ -100,8 +92,8 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
 
     const args = this.executionCache.getPreimage(this.argsHash);
 
-    if (args.length !== argumentsSize) {
-      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args.length}`);
+    if (args?.length !== argumentsSize) {
+      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args?.length}`);
     }
 
     const privateContextInputs = new PrivateContextInputs(
@@ -152,27 +144,13 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     return this.nestedExecutions;
   }
 
-  /**
-   * Return the enqueued public function calls during this execution.
-   */
-  public getEnqueuedPublicFunctionCalls() {
-    return this.enqueuedPublicFunctionCalls;
-  }
-
-  /**
-   * Return the public teardown function call set during this execution.
-   */
-  public getPublicTeardownFunctionCall() {
-    return this.publicTeardownFunctionCall;
-  }
-
   /**
    * Store values in the execution cache.
    * @param values - Values to store.
    * @returns The hash of the values.
    */
-  public override storeInExecutionCache(values: Fr[]): Promise<Fr> {
-    return this.executionCache.store(values);
+  public override storeInExecutionCache(values: Fr[], hash: Fr) {
+    return this.executionCache.store(values, hash);
   }
 
   /**
@@ -181,7 +159,11 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
    * @returns The values.
    */
   public override loadFromExecutionCache(hash: Fr): Promise<Fr[]> {
-    return Promise.resolve(this.executionCache.getPreimage(hash));
+    const preimage = this.executionCache.getPreimage(hash);
+    if (!preimage) {
+      throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
+    }
+    return Promise.resolve(preimage);
   }
 
   /**
@@ -413,7 +395,7 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
       this.noteCache,
       this.executionDataProvider,
       this.provider,
-      this.totalPublicArgsCount,
+      this.totalPublicCalldataCount,
       sideEffectCounter,
       this.log,
       this.scopes,
@@ -440,131 +422,50 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     };
   }
 
-  /**
-   * Creates a PublicExecutionRequest object representing the request to call a public function.
-   * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
-   * @param argsHash - The arguments hash to pass to the function.
-   * @param sideEffectCounter - The side effect counter at the start of the call.
-   * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
-   */
-  protected async createPublicExecutionRequest(
-    callType: 'enqueued' | 'teardown',
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ) {
-    const targetArtifact = await this.executionDataProvider.getFunctionArtifact(
-      targetContractAddress,
-      functionSelector,
-    );
-    const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
-    const args = this.executionCache.getPreimage(argsHash);
-
-    this.log.verbose(
-      `Created ${callType} public execution request to ${targetArtifact.name}@${targetContractAddress}`,
-      {
-        sideEffectCounter,
-        isStaticCall,
-        functionSelector,
-        targetContractAddress,
-        callType,
-      },
-    );
-
-    const request = PublicExecutionRequest.from({
-      args,
-      callContext: derivedCallContext,
-    });
+  #onNewPublicFunctionCall(calldataHash: Fr) {
+    const calldata = this.executionCache.getPreimage(calldataHash);
+    if (!calldata) {
+      throw new Error('Calldata for public call not found in cache');
+    }
 
-    if (callType === 'enqueued') {
-      this.enqueuedPublicFunctionCalls.push(new CountedPublicExecutionRequest(request, sideEffectCounter));
-    } else {
-      this.publicTeardownFunctionCall = request;
+    this.totalPublicCalldataCount += calldata.length;
+    if (this.totalPublicCalldataCount > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+      throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS})`);
     }
   }
 
   /**
-   * Creates and enqueues a PublicExecutionRequest object representing the request to call a public function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Verify relevant information when a public function is enqueued.
    * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
-   * @param argsHash - The arguments hash to pass to the function.
+   * @param calldataHash - The hash of the function selector and arguments.
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
    */
-  public override async enqueuePublicFunctionCall(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<Fr> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
-    // WARNING: This is insecure and should be temporary!
-    // The oracle re-hashes the arguments and returns a new args_hash.
-    // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
-    // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
-    // b) this is only temporary.
-    const newArgs = [functionSelector.toField(), ...this.executionCache.getPreimage(argsHash)];
-    const newArgsHash = await this.executionCache.store(newArgs);
-    await this.createPublicExecutionRequest(
-      'enqueued',
-      targetContractAddress,
-      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-      newArgsHash,
-      sideEffectCounter,
-      isStaticCall,
-    );
-    this.totalPublicArgsCount += newArgs.length;
-    if (this.totalPublicArgsCount > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
-      throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS})`);
-    }
-    return newArgsHash;
+  public override notifyEnqueuedPublicFunctionCall(
+    _targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ) {
+    this.#onNewPublicFunctionCall(calldataHash);
+    return Promise.resolve();
   }
 
   /**
-   * Creates a PublicExecutionRequest and sets it as the public teardown function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Verify relevant information when a public teardown function is set.
    * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
    * @param argsHash - The arguments hash to pass to the function.
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
    */
-  public override async setPublicTeardownFunctionCall(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<Fr> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
-    // WARNING: This is insecure and should be temporary!
-    // The oracle rehashes the arguments and returns a new args_hash.
-    // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
-    // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
-    // b) this is only temporary.
-    const newArgsHash = await this.executionCache.store([
-      functionSelector.toField(),
-      ...this.executionCache.getPreimage(argsHash),
-    ]);
-    await this.createPublicExecutionRequest(
-      'teardown',
-      targetContractAddress,
-      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-      newArgsHash,
-      sideEffectCounter,
-      isStaticCall,
-    );
-    return newArgsHash;
+  public override notifySetPublicTeardownFunctionCall(
+    _targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ) {
+    this.#onNewPublicFunctionCall(calldataHash);
+    return Promise.resolve();
   }
 
   public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void> {

package/src/private/simulator.ts

@@ -4,7 +4,7 @@ import type { AbiDecoded, FunctionCall } from '@aztec/stdlib/abi';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CallContext, PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
+import { CallContext, HashedValues, PrivateExecutionResult, TxExecutionRequest, collectNested } from '@aztec/stdlib/tx';
 
 import { createSimulationError } from '../common/errors.js';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
@@ -97,7 +97,19 @@ export class AcirSimulator {
       );
       const { usedTxRequestHashForNonces } = noteCache.finish();
       const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
-      return new PrivateExecutionResult(executionResult, firstNullifierHint);
+
+      const publicCallRequests = collectNested([executionResult], r => [
+        ...r.publicInputs.publicCallRequests.map(r => r.inner),
+        r.publicInputs.publicTeardownCallRequest,
+      ]).filter(r => !r.isEmpty());
+      const publicFunctionsCalldata = await Promise.all(
+        publicCallRequests.map(async r => {
+          const calldata = await context.loadFromExecutionCache(r.calldataHash);
+          return new HashedValues(calldata, r.calldataHash);
+        }),
+      );
+
+      return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }

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

@@ -9,7 +9,7 @@ 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 {
-  getContractFunctionArtifact,
+  getContractFunctionAbi,
   getFunctionSelector,
   initContext,
   initExecutionEnvironment,
@@ -73,7 +73,7 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       throw new Error(`Contract not found at address: ${address}`);
     }
     const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
+    const fnAbi = getContractFunctionAbi(fnName, contractArtifact);
     const encodedArgs = encodeArguments(fnAbi!, args);
     const calldata = [fnSelector.toField(), ...encodedArgs];
 

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

@@ -1,8 +1,4 @@
-import {
-  DEPLOYER_CONTRACT_ADDRESS,
-  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
-  PUBLIC_DISPATCH_SELECTOR,
-} from '@aztec/constants';
+import { DEPLOYER_CONTRACT_ADDRESS, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { AvmGadgetsTestContract } from '@aztec/noir-contracts.js/AvmGadgetsTest';
@@ -165,13 +161,18 @@ export function getFunctionSelector(
 export function getContractFunctionArtifact(
   functionName: string,
   contractArtifact: ContractArtifact,
-): FunctionArtifact | FunctionAbi | undefined {
-  const artifact = contractArtifact.functions.find(f => f.name === functionName)!;
-  if (!artifact) {
-    const abi = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName);
-    return abi || undefined;
-  }
-  return artifact;
+): FunctionArtifact | undefined {
+  return contractArtifact.functions.find(f => f.name === functionName);
+}
+
+export function getContractFunctionAbi(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): FunctionAbi | undefined {
+  return (
+    contractArtifact.functions.find(f => f.name === functionName) ??
+    contractArtifact.nonDispatchPublicFunctions.find(f => f.name === functionName)
+  );
 }
 
 export function resolveContractAssertionMessage(
@@ -279,12 +280,9 @@ export async function createContractClassAndInstance(
 }> {
   const bytecode = (getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact) as FunctionArtifact)!
     .bytecode;
-  const contractClass = await makeContractClassPublic(
-    seed,
-    /*publicDispatchFunction=*/ { bytecode, selector: new FunctionSelector(PUBLIC_DISPATCH_SELECTOR) },
-  );
+  const contractClass = await makeContractClassPublic(seed, bytecode);
 
-  const constructorAbi = getContractFunctionArtifact('constructor', contractArtifact);
+  const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
   const { publicKeys } = await deriveKeys(Fr.random());
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
   const contractInstance =

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

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
@@ -76,7 +76,7 @@ export class SimpleContractDataSource implements ContractDataSource {
     return Promise.resolve(this.contractArtifacts.get(contractInstance!.currentContractClassId.toString()));
   }
 
-  getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
+  getDebugFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
     return Promise.resolve(PUBLIC_DISPATCH_FN_NAME);
   }
 

package/src/public/avm/journal/journal.ts

@@ -13,8 +13,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { ContractClassWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import {
   computeNoteHashNonce,
   computePublicDataTreeLeafSlot,
@@ -439,11 +439,11 @@ export class AvmPersistableStateManager {
    * @param classId - class id to retrieve.
    * @returns the contract class or undefined if it does not exist.
    */
-  public async getContractClass(classId: Fr): Promise<ContractClassWithCommitment | undefined> {
+  public async getContractClass(classId: Fr): Promise<ContractClassPublicWithCommitment | undefined> {
     this.log.trace(`Getting contract class for id ${classId}`);
-    const klass = await this.contractsDB.getContractClass(classId);
-    const exists = klass !== undefined;
-    let extendedClass: ContractClassWithCommitment | undefined = undefined;
+    const contractClass = await this.contractsDB.getContractClass(classId);
+    const exists = contractClass !== undefined;
+    let extendedClass: ContractClassPublicWithCommitment | undefined = undefined;
 
     // Note: We currently do not generate info to check the nullifier tree, because
     // this is not needed for our use cases.
@@ -456,7 +456,7 @@ export class AvmPersistableStateManager {
         `Bytecode commitment was not found in DB for contract class (${classId}). This should not happen!`,
       );
       extendedClass = {
-        ...klass,
+        ...contractClass,
         publicBytecodeCommitment: bytecodeCommitment,
       };
     } else {

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,19 +1,19 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { asyncMap } from '@aztec/foundation/async-map';
 import { Fr } from '@aztec/foundation/fields';
-import { type ContractArtifact, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { type ContractArtifact, 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 { PublicCallRequest } from '@aztec/stdlib/kernel';
+import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } 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 { getContractFunctionAbi, getFunctionSelector } from '../avm/fixtures/index.js';
 import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
-import { createTxForPublicCalls } from './index.js';
+import { createTxForPublicCalls } from './utils.js';
 
 const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
@@ -54,68 +54,13 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     /* 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);
-    }
+    const setupCallRequests = await asyncMap(setupCalls, call => this.#createPubicCallRequestForCall(call, sender));
+    const appCallRequests = await asyncMap(appCalls, call => this.#createPubicCallRequestForCall(call, sender));
+    const teardownCallRequest = teardownCall
+      ? await this.#createPubicCallRequestForCall(teardownCall, sender)
+      : undefined;
 
-    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,
-    );
+    return createTxForPublicCalls(firstNullifier, setupCallRequests, appCallRequests, teardownCallRequest, feePayer);
   }
 
   public async simulateTx(
@@ -143,28 +88,26 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     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);
+  async #createPubicCallRequestForCall(
+    call: TestEnqueuedCall,
+    sender: AztecAddress,
+  ): Promise<PublicCallRequestWithCalldata> {
+    const address = call.address;
+    const contractArtifact = call.contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+    if (!contractArtifact) {
+      throw new Error(`Contract artifact not found for address: ${address}`);
+    }
+
+    const fnSelector = await getFunctionSelector(call.fnName, contractArtifact);
+    const fnAbi = getContractFunctionAbi(call.fnName, contractArtifact)!;
+    const encodedArgs = encodeArguments(fnAbi, call.args);
+    const calldata = [fnSelector.toField(), ...encodedArgs];
+    const isStaticCall = call.isStaticCall ?? false;
+    const request = await PublicCallRequest.fromCalldata(sender, address, isStaticCall, calldata);
+
+    return new PublicCallRequestWithCalldata(request, calldata);
+  }
 }
 
 export function defaultGlobals() {

package/src/public/fixtures/utils.ts

@@ -24,28 +24,33 @@ import {
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
 import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
-import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
-import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import {
+  BlockHeader,
+  HashedValues,
+  PublicCallRequestWithCalldata,
+  Tx,
+  TxConstantData,
+  TxContext,
+} from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
-export async function createTxForPublicCalls(
+export function createTxForPublicCalls(
   firstNullifier: Fr,
-  setupExecutionRequests: PublicExecutionRequest[],
-  appExecutionRequests: PublicExecutionRequest[],
-  teardownExecutionRequest?: PublicExecutionRequest,
+  setupCallRequests: PublicCallRequestWithCalldata[],
+  appCallRequests: PublicCallRequestWithCalldata[],
+  teardownCallRequest?: PublicCallRequestWithCalldata,
   feePayer = AztecAddress.zero(),
   gasUsedByPrivate: Gas = Gas.empty(),
-): Promise<Tx> {
+): Tx {
   assert(
-    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
+    setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== 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);
 
@@ -55,17 +60,18 @@ export async function createTxForPublicCalls(
 
   // 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];
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[setupCallRequests.length - i - 1] =
+      setupCallRequests[i].request;
   }
   for (let i = appCallRequests.length - 1; i >= 0; i--) {
-    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+    forPublic.revertibleAccumulatedData.publicCallRequests[appCallRequests.length - i - 1] = appCallRequests[i].request;
   }
-  if (teardownExecutionRequest) {
-    forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+  if (teardownCallRequest) {
+    forPublic.publicTeardownCallRequest = teardownCallRequest.request;
   }
 
   const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+  const teardownGasLimits = teardownCallRequest ? 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());
@@ -77,18 +83,14 @@ export async function createTxForPublicCalls(
     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]);
-  }
+  const calldata = [
+    ...setupCallRequests,
+    ...appCallRequests,
+    ...(teardownCallRequest ? [teardownCallRequest] : []),
+  ].map(r => new HashedValues(r.calldata, r.request.calldataHash));
 
-  return tx;
+  return new Tx(txData, ClientIvcProof.empty(), [], calldata);
 }
 
 export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate: Gas = new Gas(10, 10)): Tx {
@@ -110,7 +112,7 @@ export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedBy
     /*forPublic=*/ undefined,
     forRollup,
   );
-  return Tx.newWithTxData(txData);
+  return new Tx(txData, ClientIvcProof.empty(), [], []);
 }
 
 export async function addNewContractClassToTx(