@aztec/simulator 0.81.0 → 0.82.1-alpha-testnet.1

package/src/public/avm/test_utils.ts

@@ -28,7 +28,7 @@ export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorag
 }
 
 export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: Fr, value?: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).getCommitmentValue.mockImplementation((index: bigint) => {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
     if (index == _leafIndex.toBigInt()) {
       return Promise.resolve(value);
     } 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(

package/src/public/index.ts

@@ -1,9 +1,8 @@
 export * from '../common/db_interfaces.js';
 export * from './public_tx_simulator/public_tx_simulator.js';
-export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
 export * from './public_db_sources.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
 export { SideEffectTrace } from './side_effect_trace.js';
-export { getExecutionRequestsByPhase } from './utils.js';
 export { PublicTxSimulationTester } from './fixtures/index.js';
 export * from './avm/index.js';
+export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/src/public/public_db_sources.ts

@@ -271,7 +271,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
   }
 
   public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return await this.dataSource.getContractFunctionName(address, selector);
+    return await this.dataSource.getDebugFunctionName(address, selector);
   }
 }
 
@@ -431,13 +431,13 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     return leafValue;
   }
 
-  public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
+  public async getNoteHash(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
     const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
-    this.logger.debug(`[DB] Fetched commitment leaf value`, {
+    this.logger.debug(`[DB] Fetched note hash leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
-      operation: 'get-commitment-leaf-value',
+      operation: 'get-note-hash',
     } satisfies PublicDBAccessStats);
     return leafValue;
   }

package/src/public/public_processor/public_processor.ts

@@ -321,7 +321,7 @@ export class PublicProcessor implements Traceable {
     this.log.verbose(
       !tx.hasPublicCalls()
         ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms`
-        : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`,
+        : `Processed tx ${processedTx.hash} with ${tx.numberOfPublicCalls()} public calls in ${time}ms`,
       {
         txHash: processedTx.hash,
         txFee: processedTx.txEffect.transactionFee.toBigInt(),

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -26,7 +26,7 @@ import {
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
-  type PublicExecutionRequest,
+  PublicCallRequestWithCalldata,
   type StateReference,
   TreeSnapshots,
   type Tx,
@@ -42,7 +42,7 @@ import { AvmPersistableStateManager } from '../avm/index.js';
 import { HintingPublicContractsDB } from '../hinting_db_sources.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
 import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
-import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
+import { getCallRequestsWithCalldataByPhase } from '../utils.js';
 
 /**
  * The transaction-level context for public execution.
@@ -70,12 +70,9 @@ export class PublicTxContext {
     private readonly gasSettings: GasSettings,
     private readonly gasUsedByPrivate: Gas,
     private readonly gasAllocatedToPublic: Gas,
-    private readonly setupCallRequests: PublicCallRequest[],
-    private readonly appLogicCallRequests: PublicCallRequest[],
-    private readonly teardownCallRequests: PublicCallRequest[],
-    private readonly setupExecutionRequests: PublicExecutionRequest[],
-    private readonly appLogicExecutionRequests: PublicExecutionRequest[],
-    private readonly teardownExecutionRequests: PublicExecutionRequest[],
+    private readonly setupCallRequests: PublicCallRequestWithCalldata[],
+    private readonly appLogicCallRequests: PublicCallRequestWithCalldata[],
+    private readonly teardownCallRequests: PublicCallRequestWithCalldata[],
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
@@ -135,12 +132,9 @@ export class PublicTxContext {
       gasSettings,
       gasUsedByPrivate,
       gasAllocatedToPublic,
-      getCallRequestsByPhase(tx, TxExecutionPhase.SETUP),
-      getCallRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC),
-      getCallRequestsByPhase(tx, TxExecutionPhase.TEARDOWN),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.TEARDOWN),
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP),
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC),
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN),
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
@@ -218,7 +212,7 @@ export class PublicTxContext {
   /**
    * Get the call requests for the specified phase (including args hashes).
    */
-  getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequest[] {
+  getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequestWithCalldata[] {
     switch (phase) {
       case TxExecutionPhase.SETUP:
         return this.setupCallRequests;
@@ -229,20 +223,6 @@ export class PublicTxContext {
     }
   }
 
-  /**
-   * Get the call requests for the specified phase (including actual args).
-   */
-  getExecutionRequestsForPhase(phase: TxExecutionPhase): PublicExecutionRequest[] {
-    switch (phase) {
-      case TxExecutionPhase.SETUP:
-        return this.setupExecutionRequests;
-      case TxExecutionPhase.APP_LOGIC:
-        return this.appLogicExecutionRequests;
-      case TxExecutionPhase.TEARDOWN:
-        return this.teardownExecutionRequests;
-    }
-  }
-
   /**
    * How much gas is left as of the specified phase?
    */
@@ -353,10 +333,10 @@ export class PublicTxContext {
       /*startGasUsed=*/ this.gasUsedByPrivate,
       this.gasSettings,
       this.feePayer,
-      this.setupCallRequests,
-      this.appLogicCallRequests,
+      this.setupCallRequests.map(r => r.request),
+      this.appLogicCallRequests.map(r => r.request),
       /*teardownCallRequest=*/ this.teardownCallRequests.length
-        ? this.teardownCallRequests[0]
+        ? this.teardownCallRequests[0].request
         : PublicCallRequest.empty(),
       endTreeSnapshots,
       /*endGasUsed=*/ this.getTotalGasUsed(),

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -13,13 +13,12 @@ import {
 } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { Gas, GasUsed } from '@aztec/stdlib/gas';
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type { AvmSimulationStats } from '@aztec/stdlib/stats';
 import {
   type GlobalVariables,
   NestedProcessReturnValues,
-  PublicExecutionRequest,
+  PublicCallRequestWithCalldata,
   Tx,
   TxExecutionPhase,
 } from '@aztec/stdlib/tx';
@@ -83,7 +82,7 @@ export class PublicTxSimulator {
       const startTime = process.hrtime.bigint();
 
       const txHash = await tx.getTxHash();
-      this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
+      this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
 
       const context = await PublicTxContext.create(
         this.treesDB,
@@ -232,13 +231,11 @@ export class PublicTxSimulator {
    */
   private async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
     const callRequests = context.getCallRequestsForPhase(phase);
-    const executionRequests = context.getExecutionRequestsForPhase(phase);
 
     this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
       txHash: context.txHash.toString(),
       phase: TxExecutionPhase[phase],
       callRequests: callRequests.length,
-      executionRequests: executionRequests.length,
     });
 
     const returnValues: NestedProcessReturnValues[] = [];
@@ -251,9 +248,8 @@ export class PublicTxSimulator {
       }
 
       const callRequest = callRequests[i];
-      const executionRequest = executionRequests[i];
 
-      const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest, executionRequest);
+      const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest);
 
       returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.output));
 
@@ -276,44 +272,42 @@ export class PublicTxSimulator {
    * Simulate an enqueued public call.
    * @param phase - The current phase of public execution
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @param callRequest - The enqueued call to execute
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @returns The result of execution.
    */
-  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest) => ({
+  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest) => ({
     [Attributes.TX_HASH]: context.txHash.toString(),
-    [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
-    [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
+    [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
+    [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
     [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
   }))
   private async simulateEnqueuedCall(
     phase: TxExecutionPhase,
     context: PublicTxContext,
-    callRequest: PublicCallRequest,
-    executionRequest: PublicExecutionRequest,
+    callRequest: PublicCallRequestWithCalldata,
   ): Promise<AvmFinalizedCallResult> {
     const stateManager = context.state.getActiveStateManager();
-    const address = executionRequest.callContext.contractAddress;
-    const fnName = await getPublicFunctionDebugName(this.contractsDB, address, executionRequest.args);
+    const contractAddress = callRequest.request.contractAddress;
+    const fnName = await getPublicFunctionDebugName(this.contractsDB, contractAddress, callRequest.calldata);
 
     const allocatedGas = context.getGasLeftAtPhase(phase);
 
     // The reason we need enqueued hints at all (and cannot just use the public inputs) is
     // because they don't have the actual calldata, just the hash of it.
     // If/when we pass the whole TX to C++, we can remove this class of hints.
-    stateManager.traceEnqueuedCall(callRequest);
+    stateManager.traceEnqueuedCall(callRequest.request);
     context.hints.enqueuedCalls.push(
       new AvmEnqueuedCallHint(
-        executionRequest.callContext.msgSender,
-        executionRequest.callContext.contractAddress,
-        executionRequest.args,
-        executionRequest.callContext.isStaticCall,
+        callRequest.request.msgSender,
+        contractAddress,
+        callRequest.calldata,
+        callRequest.request.isStaticCall,
       ),
     );
 
     const result = await this.simulateEnqueuedCallInternal(
       context.state.getActiveStateManager(),
-      executionRequest,
+      callRequest,
       allocatedGas,
       /*transactionFee=*/ context.getTransactionFee(phase),
       fnName,
@@ -326,7 +320,7 @@ export class PublicTxSimulator {
     );
 
     if (result.reverted) {
-      const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
+      const culprit = `${contractAddress}:${callRequest.functionSelector}`;
       context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
     }
 
@@ -342,26 +336,26 @@ export class PublicTxSimulator {
    *
    * @param stateManager - The state manager for AvmSimulation
    * @param context - The context of the currently executing public transaction portion
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @param allocatedGas - The gas allocated to the enqueued call
    * @param fnName - The name of the function
    * @returns The result of execution.
    */
   @trackSpan(
     'PublicTxSimulator.simulateEnqueuedCallInternal',
-    (_stateManager, _executionRequest, _allocatedGas, _transactionFee, fnName) => ({
+    (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName) => ({
       [Attributes.APP_CIRCUIT_NAME]: fnName,
     }),
   )
   private async simulateEnqueuedCallInternal(
     stateManager: AvmPersistableStateManager,
-    executionRequest: PublicExecutionRequest,
+    { request, calldata }: PublicCallRequestWithCalldata,
     allocatedGas: Gas,
     transactionFee: Fr,
     fnName: string,
   ): Promise<AvmFinalizedCallResult> {
-    const address = executionRequest.callContext.contractAddress;
-    const sender = executionRequest.callContext.msgSender;
+    const address = request.contractAddress;
+    const sender = request.msgSender;
 
     this.log.debug(
       `Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`,
@@ -374,8 +368,8 @@ export class PublicTxSimulator {
       sender,
       transactionFee,
       this.globalVariables,
-      executionRequest.callContext.isStaticCall,
-      executionRequest.args,
+      request.isStaticCall,
+      calldata,
       allocatedGas,
     );
     const avmCallResult = await simulator.execute();

package/src/public/utils.ts

@@ -1,29 +1,13 @@
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
-import { type PublicExecutionRequest, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { PublicCallRequestWithCalldata, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
 
-export function getExecutionRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicExecutionRequest[] {
+export function getCallRequestsWithCalldataByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequestWithCalldata[] {
   switch (phase) {
     case TxExecutionPhase.SETUP:
-      return tx.getNonRevertiblePublicExecutionRequests();
+      return tx.getNonRevertiblePublicCallRequestsWithCalldata();
     case TxExecutionPhase.APP_LOGIC:
-      return tx.getRevertiblePublicExecutionRequests();
+      return tx.getRevertiblePublicCallRequestsWithCalldata();
     case TxExecutionPhase.TEARDOWN: {
-      const request = tx.getPublicTeardownExecutionRequest();
-      return request ? [request] : [];
-    }
-    default:
-      throw new Error(`Unknown phase: ${phase}`);
-  }
-}
-
-export function getCallRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequest[] {
-  switch (phase) {
-    case TxExecutionPhase.SETUP:
-      return tx.data.getNonRevertiblePublicCallRequests();
-    case TxExecutionPhase.APP_LOGIC:
-      return tx.data.getRevertiblePublicCallRequests();
-    case TxExecutionPhase.TEARDOWN: {
-      const request = tx.data.getTeardownPublicCallRequest();
+      const request = tx.getTeardownPublicCallRequestWithCalldata();
       return request ? [request] : [];
     }
     default:

package/src/testing.ts

@@ -0,0 +1 @@
+export { SimulationProviderRecorderWrapper } from './private/providers/circuit_recording/simulation_provider_recorder_wrapper.js';

package/dest/public/avm/bytecode_utils.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-export declare function markBytecodeAsAvm(bytecode: Buffer): Buffer;
-export declare function isAvmBytecode(bytecode: Buffer): boolean;
-//# sourceMappingURL=bytecode_utils.d.ts.map

package/dest/public/avm/bytecode_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bytecode_utils.d.ts","sourceRoot":"","sources":["../../../src/public/avm/bytecode_utils.ts"],"names":[],"mappings":";;AASA,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dest/public/avm/bytecode_utils.js

@@ -1,17 +0,0 @@
-import { Opcode } from './serialization/instruction_serialization.js';
-const AVM_MAGIC_SUFFIX = Buffer.from([
-    Opcode.MOV_16,
-    0x00,
-    ...Buffer.from('18ca', 'hex'),
-    ...Buffer.from('18ca', 'hex')
-]);
-export function markBytecodeAsAvm(bytecode) {
-    return Buffer.concat([
-        bytecode,
-        AVM_MAGIC_SUFFIX
-    ]);
-}
-export function isAvmBytecode(bytecode) {
-    const magicSize = AVM_MAGIC_SUFFIX.length;
-    return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
-}