@aztec/simulator 0.59.0 → 0.60.0

package/src/client/client_execution_context.ts

@@ -68,7 +68,6 @@ export class ClientExecutionContext extends ViewDataOracle {
   private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
 
   constructor(
-    contractAddress: AztecAddress,
     private readonly argsHash: Fr,
     private readonly txContext: TxContext,
     private readonly callContext: CallContext,
@@ -84,7 +83,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     log = createDebugLogger('aztec:simulator:client_execution_context'),
     scopes?: AztecAddress[],
   ) {
-    super(contractAddress, authWitnesses, db, node, log, scopes);
+    super(callContext.contractAddress, authWitnesses, db, node, log, scopes);
   }
 
   // We still need this function until we can get user-defined ordering of structs for fn arguments
@@ -240,10 +239,10 @@ export class ClientExecutionContext extends ViewDataOracle {
     status: NoteStatus,
   ): Promise<NoteData[]> {
     // Nullified pending notes are already removed from the list.
-    const pendingNotes = this.noteCache.getNotes(this.callContext.storageContractAddress, storageSlot);
+    const pendingNotes = this.noteCache.getNotes(this.callContext.contractAddress, storageSlot);
 
-    const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.storageContractAddress);
-    const dbNotes = await this.db.getNotes(this.callContext.storageContractAddress, storageSlot, status, this.scopes);
+    const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.contractAddress);
+    const dbNotes = await this.db.getNotes(this.callContext.contractAddress, storageSlot, status, this.scopes);
     const dbNotesFiltered = dbNotes.filter(n => !pendingNullifiers.has((n.siloedNullifier as Fr).value));
 
     const notes = pickNotes<NoteData>([...dbNotesFiltered, ...pendingNotes], {
@@ -261,7 +260,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     });
 
     this.log.debug(
-      `Returning ${notes.length} notes for ${this.callContext.storageContractAddress} at ${storageSlot}: ${notes
+      `Returning ${notes.length} notes for ${this.callContext.contractAddress} at ${storageSlot}: ${notes
         .map(n => `${n.nonce.toString()}:[${n.note.items.map(i => i.toString()).join(',')}]`)
         .join(', ')}`,
     );
@@ -297,7 +296,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const note = new Note(noteItems);
     this.noteCache.addNewNote(
       {
-        contractAddress: this.callContext.storageContractAddress,
+        contractAddress: this.callContext.contractAddress,
         storageSlot,
         nonce: Fr.ZERO, // Nonce cannot be known during private execution.
         note,
@@ -317,7 +316,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     const nullifiedNoteHashCounter = this.noteCache.nullifyNote(
-      this.callContext.storageContractAddress,
+      this.callContext.contractAddress,
       innerNullifier,
       noteHash,
     );
@@ -391,11 +390,11 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   #checkValidStaticCall(childExecutionResult: PrivateExecutionResult) {
     if (
-      childExecutionResult.callStackItem.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.l2ToL1Msgs.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.encryptedLogsHashes.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.unencryptedLogsHashes.some(item => !item.isEmpty())
+      childExecutionResult.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
+      childExecutionResult.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
+      childExecutionResult.publicInputs.l2ToL1Msgs.some(item => !item.isEmpty()) ||
+      childExecutionResult.publicInputs.encryptedLogsHashes.some(item => !item.isEmpty()) ||
+      childExecutionResult.publicInputs.unencryptedLogsHashes.some(item => !item.isEmpty())
     ) {
       throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);
     }
@@ -408,7 +407,6 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param argsHash - The packed arguments 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.
-   * @param isDelegateCall - Whether the call is a delegate call.
    * @returns The execution result.
    */
   override async callPrivateFunction(
@@ -417,10 +415,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     argsHash: Fr,
     sideEffectCounter: number,
     isStaticCall: boolean,
-    isDelegateCall: boolean,
   ) {
     this.log.debug(
-      `Calling private function ${this.contractAddress}:${functionSelector} from ${this.callContext.storageContractAddress}`,
+      `Calling private function ${this.contractAddress}:${functionSelector} from ${this.callContext.contractAddress}`,
     );
 
     isStaticCall = isStaticCall || this.callContext.isStaticCall;
@@ -429,15 +426,9 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     const derivedTxContext = this.txContext.clone();
 
-    const derivedCallContext = this.deriveCallContext(
-      targetContractAddress,
-      targetArtifact,
-      isDelegateCall,
-      isStaticCall,
-    );
+    const derivedCallContext = this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
 
     const context = new ClientExecutionContext(
-      targetContractAddress,
       argsHash,
       derivedTxContext,
       derivedCallContext,
@@ -465,7 +456,7 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     this.nestedExecutions.push(childExecutionResult);
 
-    const publicInputs = childExecutionResult.callStackItem.publicInputs;
+    const publicInputs = childExecutionResult.publicInputs;
     return {
       endSideEffectCounter: publicInputs.endSideEffectCounter,
       returnsHash: publicInputs.returnsHash,
@@ -473,7 +464,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Creates a PublicCallStackItem object representing the request to call a public function.
+   * 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 packed arguments to pass to the function.
@@ -488,15 +479,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     argsHash: Fr,
     sideEffectCounter: number,
     isStaticCall: boolean,
-    isDelegateCall: boolean,
   ) {
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
-    const derivedCallContext = this.deriveCallContext(
-      targetContractAddress,
-      targetArtifact,
-      isDelegateCall,
-      isStaticCall,
-    );
+    const derivedCallContext = this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
     const args = this.packedValuesCache.unpack(argsHash);
 
     this.log.verbose(
@@ -506,7 +491,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     const request = PublicExecutionRequest.from({
       args,
       callContext: derivedCallContext,
-      contractAddress: targetContractAddress,
     });
 
     if (callType === 'enqueued') {
@@ -517,7 +501,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Creates and enqueues a PublicCallStackItem object representing the request to call a public function. No function
+   * 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.
    * @param targetContractAddress - The address of the contract to call.
@@ -533,7 +517,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     argsHash: Fr,
     sideEffectCounter: number,
     isStaticCall: boolean,
-    isDelegateCall: boolean,
   ): Promise<Fr> {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
     // WARNING: This is insecure and should be temporary!
@@ -552,13 +535,12 @@ export class ClientExecutionContext extends ViewDataOracle {
       newArgsHash,
       sideEffectCounter,
       isStaticCall,
-      isDelegateCall,
     );
     return newArgsHash;
   }
 
   /**
-   * Creates a PublicCallStackItem and sets it as the public teardown function. No function
+   * 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.
    * @param targetContractAddress - The address of the contract to call.
@@ -574,7 +556,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     argsHash: Fr,
     sideEffectCounter: number,
     isStaticCall: boolean,
-    isDelegateCall: boolean,
   ): Promise<Fr> {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
     // WARNING: This is insecure and should be temporary!
@@ -593,7 +574,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       newArgsHash,
       sideEffectCounter,
       isStaticCall,
-      isDelegateCall,
     );
     return newArgsHash;
   }
@@ -606,21 +586,18 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.
    * @param targetArtifact - The artifact of the function being called.
-   * @param isDelegateCall - Whether the call is a delegate call.
    * @param isStaticCall - Whether the call is a static call.
    * @returns The derived call context.
    */
   private deriveCallContext(
     targetContractAddress: AztecAddress,
     targetArtifact: FunctionArtifact,
-    isDelegateCall = false,
     isStaticCall = false,
   ) {
     return new CallContext(
-      isDelegateCall ? this.callContext.msgSender : this.contractAddress,
-      isDelegateCall ? this.contractAddress : targetContractAddress,
+      this.contractAddress,
+      targetContractAddress,
       FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
-      isDelegateCall,
       isStaticCall,
     );
   }

package/src/client/private_execution.ts

@@ -2,10 +2,8 @@ import { PrivateExecutionResult } from '@aztec/circuit-types';
 import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
   Fr,
-  FunctionData,
   PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,
   PRIVATE_CONTEXT_INPUTS_LENGTH,
-  PrivateCallStackItem,
   PrivateCircuitPublicInputs,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector, countArgumentsSize } from '@aztec/foundation/abi';
@@ -64,12 +62,6 @@ export async function executePrivateFunction(
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
 
-  const callStackItem = new PrivateCallStackItem(
-    contractAddress,
-    new FunctionData(functionSelector, true),
-    publicInputs,
-  );
-
   const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
 
   const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
@@ -85,7 +77,7 @@ export async function executePrivateFunction(
     acir,
     Buffer.from(artifact.verificationKey!, 'hex'),
     partialWitness,
-    callStackItem,
+    publicInputs,
     noteHashLeafIndexMap,
     newNotes,
     noteHashNullifierCounterMap,

package/src/client/simulator.ts

@@ -66,14 +66,12 @@ export class AcirSimulator {
       msgSender,
       contractAddress,
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
-      false,
       entryPointArtifact.isStatic,
     );
 
     const txHash = request.toTxRequest().hash();
 
     const context = new ClientExecutionContext(
-      contractAddress,
       request.firstCallArgsHash,
       request.txContext,
       callContext,

package/src/mocks/fixtures.ts

@@ -79,7 +79,7 @@ export class PublicExecutionResultBuilder {
     revertReason?: SimulationError;
   }) {
     const builder = new PublicExecutionResultBuilder(
-      new PublicExecutionRequest(tx.to, new CallContext(from, tx.to, tx.selector, false, false), tx.args),
+      new PublicExecutionRequest(new CallContext(from, tx.to, tx.selector, false), tx.args),
     );
 
     builder.withNestedExecutions(...nestedExecutions);

package/src/public/dual_side_effect_trace.ts

@@ -32,35 +32,35 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     return this.innerCallTrace.getCounter();
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
-    this.innerCallTrace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
-    this.enqueuedCallTrace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
+  public tracePublicStorageRead(contractAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
+    this.innerCallTrace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
+    this.enqueuedCallTrace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
   }
 
-  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.innerCallTrace.tracePublicStorageWrite(storageAddress, slot, value);
-    this.enqueuedCallTrace.tracePublicStorageWrite(storageAddress, slot, value);
+  public tracePublicStorageWrite(contractAddress: Fr, slot: Fr, value: Fr) {
+    this.innerCallTrace.tracePublicStorageWrite(contractAddress, slot, value);
+    this.enqueuedCallTrace.tracePublicStorageWrite(contractAddress, slot, value);
   }
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
-    this.innerCallTrace.traceNoteHashCheck(_storageAddress, noteHash, leafIndex, exists);
-    this.enqueuedCallTrace.traceNoteHashCheck(_storageAddress, noteHash, leafIndex, exists);
+  public traceNoteHashCheck(_contractAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
+    this.innerCallTrace.traceNoteHashCheck(_contractAddress, noteHash, leafIndex, exists);
+    this.enqueuedCallTrace.traceNoteHashCheck(_contractAddress, noteHash, leafIndex, exists);
   }
 
-  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
-    this.innerCallTrace.traceNewNoteHash(_storageAddress, noteHash);
-    this.enqueuedCallTrace.traceNewNoteHash(_storageAddress, noteHash);
+  public traceNewNoteHash(_contractAddress: Fr, noteHash: Fr) {
+    this.innerCallTrace.traceNewNoteHash(_contractAddress, noteHash);
+    this.enqueuedCallTrace.traceNewNoteHash(_contractAddress, noteHash);
   }
 
-  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean) {
-    this.innerCallTrace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
-    this.enqueuedCallTrace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
+  public traceNullifierCheck(contractAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean) {
+    this.innerCallTrace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
+    this.enqueuedCallTrace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
   }
 
-  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
-    this.innerCallTrace.traceNewNullifier(storageAddress, nullifier);
-    this.enqueuedCallTrace.traceNewNullifier(storageAddress, nullifier);
+  public traceNewNullifier(contractAddress: Fr, nullifier: Fr) {
+    this.innerCallTrace.traceNewNullifier(contractAddress, nullifier);
+    this.enqueuedCallTrace.traceNewNullifier(contractAddress, nullifier);
   }
 
   public traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {

package/src/public/enqueued_call_side_effect_trace.ts

@@ -157,7 +157,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.sideEffectCounter++;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: boolean) {
+  public tracePublicStorageRead(contractAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: boolean) {
     // NOTE: exists and cached are unused for now but may be used for optimizations or kernel hints later
     if (
       this.contractStorageReads.length + this.previousValidationRequestArrayLengths.publicDataReads >=
@@ -167,7 +167,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     }
 
     this.contractStorageReads.push(
-      new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(storageAddress)),
+      new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(contractAddress)),
     );
     this.avmCircuitHints.storageValues.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ value),
@@ -176,7 +176,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
+  public tracePublicStorageWrite(contractAddress: Fr, slot: Fr, value: Fr) {
     if (
       this.contractStorageUpdateRequests.length + this.previousAccumulatedDataArrayLengths.publicDataUpdateRequests >=
       MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
@@ -185,15 +185,15 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     }
 
     this.contractStorageUpdateRequests.push(
-      new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, storageAddress),
+      new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, contractAddress),
     );
     this.log.debug(`SSTORE cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
   }
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
-    // NOTE: storageAddress is unused because noteHash is an already-siloed leaf
+  public traceNoteHashCheck(_contractAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
+    // NOTE: contractAddress is unused because noteHash is an already-siloed leaf
     if (
       this.noteHashReadRequests.length + this.previousValidationRequestArrayLengths.noteHashReadRequests >=
       MAX_NOTE_HASH_READ_REQUESTS_PER_TX
@@ -208,22 +208,22 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
-  public traceNewNoteHash(storageAddress: Fr, noteHash: Fr) {
+  public traceNewNoteHash(contractAddress: Fr, noteHash: Fr) {
     if (this.noteHashes.length + this.previousAccumulatedDataArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
       throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
     }
 
-    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(AztecAddress.fromField(storageAddress)));
+    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(AztecAddress.fromField(contractAddress)));
     this.log.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
-  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
+  public traceNullifierCheck(contractAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
     // NOTE: isPending and leafIndex are unused for now but may be used for optimizations or kernel hints later
     this.enforceLimitOnNullifierChecks();
 
     const readRequest = new ReadRequest(nullifier, this.sideEffectCounter).scope(
-      AztecAddress.fromField(storageAddress),
+      AztecAddress.fromField(contractAddress),
     );
     if (exists) {
       this.nullifierReadRequests.push(readRequest);
@@ -237,14 +237,14 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
+  public traceNewNullifier(contractAddress: Fr, nullifier: Fr) {
     if (this.nullifiers.length + this.previousAccumulatedDataArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
 
     this.nullifiers.push(
       new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO).scope(
-        AztecAddress.fromField(storageAddress),
+        AztecAddress.fromField(contractAddress),
       ),
     );
     this.log.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
@@ -538,15 +538,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
 function createPublicCallRequest(avmEnvironment: AvmExecutionEnvironment): PublicCallRequest {
   const callContext = CallContext.from({
     msgSender: avmEnvironment.sender,
-    storageContractAddress: avmEnvironment.storageAddress,
+    contractAddress: avmEnvironment.address,
     functionSelector: avmEnvironment.functionSelector,
-    isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
   });
-  return new PublicCallRequest(
-    avmEnvironment.address,
-    callContext,
-    computeVarArgsHash(avmEnvironment.calldata),
-    /*counter=*/ 0,
-  );
+  return new PublicCallRequest(callContext, computeVarArgsHash(avmEnvironment.calldata), /*counter=*/ 0);
 }

package/src/public/enqueued_call_simulator.ts

@@ -16,7 +16,6 @@ import {
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
-  FunctionData,
   Gas,
   type GlobalVariables,
   type Header,
@@ -42,7 +41,6 @@ import {
   PublicAccumulatedDataArrayLengths,
   PublicCallData,
   type PublicCallRequest,
-  PublicCallStackItem,
   PublicCircuitPublicInputs,
   PublicInnerCallRequest,
   type PublicKernelCircuitPublicInputs,
@@ -157,7 +155,7 @@ export class EnqueuedCallSimulator {
     );
 
     const callStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PublicInnerCallRequest.empty);
-    callStack[0].item.contractAddress = callRequest.contractAddress;
+    callStack[0].item.contractAddress = callRequest.callContext.contractAddress;
     callStack[0].item.callContext = callRequest.callContext;
     callStack[0].item.argsHash = callRequest.argsHash;
 
@@ -197,22 +195,19 @@ export class EnqueuedCallSimulator {
       // Accumulate gas used in this enqueued call.
       gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
 
+      const { contractAddress, functionSelector } = result.executionRequest.callContext;
+
       // Sanity check for a current upstream assumption.
       // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-      const functionSelector = result.executionRequest.callContext.functionSelector.toString();
       if (result.reverted && !result.revertReason) {
         throw new Error(
-          `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-            result.functionName
-          }) reverted with no reason.`,
+          `Simulation of ${contractAddress}:${functionSelector}(${result.functionName}) reverted with no reason.`,
         );
       }
 
       // Simulate the public kernel circuit.
       this.log.debug(
-        `Running public kernel inner circuit for ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-          result.functionName
-        })`,
+        `Running public kernel inner circuit for ${contractAddress}:${functionSelector}(${result.functionName})`,
       );
 
       const callData = await this.getPublicCallData(result);
@@ -226,9 +221,7 @@ export class EnqueuedCallSimulator {
       // TODO(@leila) we shouldn't drop everything when it reverts. The tail kernel needs the data to prove that it's reverted for the correct reason.
       if (result.reverted) {
         this.log.debug(
-          `Reverting on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-            result.functionName
-          }) with reason: ${result.revertReason}`,
+          `Reverting on ${contractAddress}:${functionSelector}(${result.functionName}) with reason: ${result.revertReason}`,
         );
         // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
 
@@ -278,15 +271,15 @@ export class EnqueuedCallSimulator {
    */
   private async getPublicCallData(result: PublicExecutionResult) {
     const bytecodeHash = await this.getBytecodeHash(result);
-    const callStackItem = await this.getPublicCallStackItem(result);
-    return new PublicCallData(callStackItem, makeEmptyProof(), bytecodeHash);
+    const publicInputs = await this.getPublicCircuitPublicInputs(result);
+    return new PublicCallData(publicInputs, makeEmptyProof(), bytecodeHash);
   }
 
-  private async getPublicCallStackItem(result: PublicExecutionResult) {
+  private async getPublicCircuitPublicInputs(result: PublicExecutionResult) {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
     this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
 
-    const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
+    return PublicCircuitPublicInputs.from({
       callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
       argsHash: computeVarArgsHash(result.executionRequest.args),
@@ -340,12 +333,6 @@ export class EnqueuedCallSimulator {
       // TODO(@just-mitch): need better mapping from simulator to revert code.
       revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
     });
-
-    return new PublicCallStackItem(
-      result.executionRequest.contractAddress,
-      new FunctionData(result.executionRequest.callContext.functionSelector, false),
-      publicCircuitPublicInputs,
-    );
   }
 
   private getBytecodeHash(_result: PublicExecutionResult) {

package/src/public/enqueued_calls_processor.ts

@@ -265,9 +265,7 @@ export class EnqueuedCallsProcessor {
 
       if (enqueuedCallResult.revertReason && !PhaseIsRevertible[phase]) {
         this.log.debug(
-          `Simulation error on ${executionRequest.contractAddress.toString()}:${
-            executionRequest.callContext.functionSelector
-          } with reason: ${enqueuedCallResult.revertReason}`,
+          `Simulation error on ${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector} with reason: ${enqueuedCallResult.revertReason}`,
         );
         throw enqueuedCallResult.revertReason;
       }

package/src/public/execution.ts

@@ -139,7 +139,7 @@ export function checkValidStaticCall(
 export function resultToPublicCallRequest(result: PublicExecutionResult) {
   const request = result.executionRequest;
   const item = new PublicCallStackItemCompressed(
-    request.contractAddress,
+    request.callContext.contractAddress,
     request.callContext,
     computeVarArgsHash(request.args),
     computeVarArgsHash(result.returnValues),

package/src/public/executor.ts

@@ -63,11 +63,13 @@ export class PublicExecutor {
     previousValidationRequestArrayLengths: PublicValidationRequestArrayLengths = PublicValidationRequestArrayLengths.empty(),
     previousAccumulatedDataArrayLengths: PublicAccumulatedDataArrayLengths = PublicAccumulatedDataArrayLengths.empty(),
   ): Promise<PublicExecutionResult> {
-    const address = executionRequest.contractAddress;
+    const address = executionRequest.callContext.contractAddress;
     const selector = executionRequest.callContext.functionSelector;
     const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, selector, executionRequest.args);
 
-    PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}@${address}.`);
+    PublicExecutor.log.verbose(
+      `[AVM] Executing public external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`,
+    );
     const timer = new Timer();
 
     const innerCallTrace = new PublicSideEffectTrace(startSideEffectCounter);
@@ -132,6 +134,12 @@ export class PublicExecutor {
       avmResult,
     );
 
+    PublicExecutor.log.verbose(
+      `[AVM] ${fnName} simulation complete. Reverted=${avmResult.reverted}. Consumed ${
+        allocatedGas.l2Gas - avmContext.machineState.gasLeft.l2Gas
+      } L2 gas, ending with ${avmContext.machineState.gasLeft.l2Gas} L2 gas left.`,
+    );
+
     return publicExecutionResult;
   }
 }
@@ -149,15 +157,13 @@ function createAvmExecutionEnvironment(
   transactionFee: Fr,
 ): AvmExecutionEnvironment {
   return new AvmExecutionEnvironment(
-    executionRequest.contractAddress,
-    executionRequest.callContext.storageContractAddress,
+    executionRequest.callContext.contractAddress,
     executionRequest.callContext.msgSender,
     executionRequest.callContext.functionSelector,
     /*contractCallDepth=*/ Fr.zero(),
     transactionFee,
     globalVariables,
     executionRequest.callContext.isStaticCall,
-    executionRequest.callContext.isDelegateCall,
     executionRequest.args,
   );
 }