@aztec/simulator 0.44.0 → 0.45.1

package/src/public/abstract_phase_manager.ts

@@ -25,10 +25,10 @@ import {
   L2ToL1Message,
   LogHash,
   MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
-  MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
-  MAX_NEW_NOTE_HASHES_PER_CALL,
-  MAX_NEW_NULLIFIERS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
   MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
   MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
@@ -57,7 +57,7 @@ import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import {
-  type PublicExecution,
+  type PublicExecutionRequest,
   type PublicExecutionResult,
   type PublicExecutor,
   accumulateReturnValues,
@@ -176,12 +176,14 @@ export abstract class AbstractPhaseManager {
         call => revertibleCallStack.find(p => p.equals(call)) || nonRevertibleCallStack.find(p => p.equals(call)),
       );
 
+    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
+
     if (callRequestsStack.length === 0) {
       return {
         [PublicKernelType.NON_PUBLIC]: [],
         [PublicKernelType.SETUP]: [],
         [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
         [PublicKernelType.TAIL]: [],
       };
     }
@@ -191,8 +193,6 @@ export abstract class AbstractPhaseManager {
       c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
     );
 
-    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
-
     if (firstRevertibleCallIndex === 0) {
       return {
         [PublicKernelType.NON_PUBLIC]: [],
@@ -256,7 +256,7 @@ export abstract class AbstractPhaseManager {
     const enqueuedCallResults = [];
 
     for (const enqueuedCall of enqueuedCalls) {
-      const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
+      const executionStack: (PublicExecutionRequest | PublicExecutionResult)[] = [enqueuedCall];
 
       // Keep track of which result is for the top/enqueued call
       let enqueuedExecutionResult: PublicExecutionResult | undefined;
@@ -283,10 +283,10 @@ export abstract class AbstractPhaseManager {
 
         // Sanity check for a current upstream assumption.
         // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-        const functionSelector = result.execution.functionSelector.toString();
+        const functionSelector = result.executionRequest.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
-            `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) reverted with no reason.`,
           );
@@ -294,7 +294,7 @@ export abstract class AbstractPhaseManager {
 
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
-            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Simulation error on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) with reason: ${result.revertReason}`,
           );
@@ -308,7 +308,7 @@ export abstract class AbstractPhaseManager {
 
         // Simulate the public kernel circuit.
         this.log.debug(
-          `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}(${
+          `Running public kernel circuit for ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
             result.functionName
           })`,
         );
@@ -331,7 +331,7 @@ export abstract class AbstractPhaseManager {
         // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
         if (result.reverted && kernelPublicOutput.revertCode.isOK()) {
           throw new Error(
-            `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Public kernel circuit did not revert on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }), but simulator did.`,
           );
@@ -341,7 +341,7 @@ export abstract class AbstractPhaseManager {
         // So safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
         if (result.reverted) {
           this.log.debug(
-            `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Reverting on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) with reason: ${result.revertReason}`,
           );
@@ -375,7 +375,7 @@ export abstract class AbstractPhaseManager {
 
   /** Returns all pending private and public nullifiers. */
   private getSiloedPendingNullifiers(ko: PublicKernelCircuitPublicInputs) {
-    return [...ko.end.newNullifiers, ...ko.endNonRevertibleData.newNullifiers].filter(n => !n.isEmpty());
+    return [...ko.end.nullifiers, ...ko.endNonRevertibleData.nullifiers].filter(n => !n.isEmpty());
   }
 
   protected getAvailableGas(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
@@ -430,12 +430,12 @@ export abstract class AbstractPhaseManager {
     );
 
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
-      callContext: result.execution.callContext,
+      callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
-      argsHash: computeVarArgsHash(result.execution.args),
-      newNoteHashes: padArrayEnd(result.newNoteHashes, NoteHash.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
-      newNullifiers: padArrayEnd(result.newNullifiers, Nullifier.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
-      newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
+      argsHash: computeVarArgsHash(result.executionRequest.args),
+      noteHashes: padArrayEnd(result.noteHashes, NoteHash.empty(), MAX_NOTE_HASHES_PER_CALL),
+      nullifiers: padArrayEnd(result.nullifiers, Nullifier.empty(), MAX_NULLIFIERS_PER_CALL),
+      l2ToL1Msgs: padArrayEnd(result.l2ToL1Messages, L2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_CALL),
       startSideEffectCounter: result.startSideEffectCounter,
       endSideEffectCounter: result.endSideEffectCounter,
       returnsHash: computeVarArgsHash(result.returnValues),
@@ -481,8 +481,8 @@ export abstract class AbstractPhaseManager {
     });
 
     return new PublicCallStackItem(
-      result.execution.contractAddress,
-      new FunctionData(result.execution.functionSelector, false),
+      result.executionRequest.contractAddress,
+      new FunctionData(result.executionRequest.functionSelector, false),
       publicCircuitPublicInputs,
       isExecutionRequest,
     );
@@ -506,15 +506,15 @@ export abstract class AbstractPhaseManager {
    */
   static getMaxSideEffectCounter(inputs: PublicKernelCircuitPublicInputs): number {
     const sideEffectCounters = [
-      ...inputs.endNonRevertibleData.newNoteHashes,
-      ...inputs.endNonRevertibleData.newNullifiers,
+      ...inputs.endNonRevertibleData.noteHashes,
+      ...inputs.endNonRevertibleData.nullifiers,
       ...inputs.endNonRevertibleData.noteEncryptedLogsHashes,
       ...inputs.endNonRevertibleData.encryptedLogsHashes,
       ...inputs.endNonRevertibleData.unencryptedLogsHashes,
       ...inputs.endNonRevertibleData.publicCallStack,
       ...inputs.endNonRevertibleData.publicDataUpdateRequests,
-      ...inputs.end.newNoteHashes,
-      ...inputs.end.newNullifiers,
+      ...inputs.end.noteHashes,
+      ...inputs.end.nullifiers,
       ...inputs.end.noteEncryptedLogsHashes,
       ...inputs.end.encryptedLogsHashes,
       ...inputs.end.unencryptedLogsHashes,

package/src/public/execution.ts

@@ -18,8 +18,8 @@ import { type Gas } from '../avm/avm_gas.js';
  * The public function execution result.
  */
 export interface PublicExecutionResult {
-  /** The execution that triggered this result. */
-  execution: PublicExecution;
+  /** The execution request that triggered this result. */
+  executionRequest: PublicExecutionRequest;
 
   /** The side effect counter at the start of the function call. */
   startSideEffectCounter: Fr;
@@ -48,11 +48,11 @@ export interface PublicExecutionResult {
   /** The contract storage update requests performed by the function. */
   contractStorageUpdateRequests: ContractStorageUpdateRequest[];
   /** The new note hashes to be inserted into the note hashes tree. */
-  newNoteHashes: NoteHash[];
+  noteHashes: NoteHash[];
   /** The new l2 to l1 messages generated in this call. */
-  newL2ToL1Messages: L2ToL1Message[];
+  l2ToL1Messages: L2ToL1Message[];
   /** The new nullifiers to be inserted into the nullifier tree. */
-  newNullifiers: Nullifier[];
+  nullifiers: Nullifier[];
   /** The note hash read requests emitted in this call. */
   noteHashReadRequests: ReadRequest[];
   /** The nullifier read requests emitted in this call. */
@@ -90,9 +90,13 @@ export interface PublicExecutionResult {
 }
 
 /**
- * The execution of a public function.
+ * The execution request of a public function.
+ * A subset of PublicCallRequest
  */
-export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'functionSelector' | 'callContext' | 'args'>;
+export type PublicExecutionRequest = Pick<
+  PublicCallRequest,
+  'contractAddress' | 'functionSelector' | 'callContext' | 'args'
+>;
 
 /**
  * Returns if the input is a public execution result and not just a public execution.
@@ -100,9 +104,9 @@ export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'funct
  * @returns Whether the input is a public execution result and not just a public execution.
  */
 export function isPublicExecutionResult(
-  input: PublicExecution | PublicExecutionResult,
+  input: PublicExecutionRequest | PublicExecutionResult,
 ): input is PublicExecutionResult {
-  return 'execution' in input && input.execution !== undefined;
+  return 'executionRequest' in input && input.executionRequest !== undefined;
 }
 
 /**
@@ -111,17 +115,17 @@ export function isPublicExecutionResult(
  */
 
 export function checkValidStaticCall(
-  newNoteHashes: NoteHash[],
-  newNullifiers: Nullifier[],
+  noteHashes: NoteHash[],
+  nullifiers: Nullifier[],
   contractStorageUpdateRequests: ContractStorageUpdateRequest[],
-  newL2ToL1Messages: L2ToL1Message[],
+  l2ToL1Messages: L2ToL1Message[],
   unencryptedLogs: UnencryptedFunctionL2Logs,
 ) {
   if (
     contractStorageUpdateRequests.length > 0 ||
-    newNoteHashes.length > 0 ||
-    newNullifiers.length > 0 ||
-    newL2ToL1Messages.length > 0 ||
+    noteHashes.length > 0 ||
+    nullifiers.length > 0 ||
+    l2ToL1Messages.length > 0 ||
     unencryptedLogs.logs.length > 0
   ) {
     throw new Error('Static call cannot update the state, emit L2->L1 messages or generate logs');

package/src/public/executor.ts

@@ -4,21 +4,21 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 
 import { AvmContext } from '../avm/avm_context.js';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
 import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
-import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
-import { createAvmExecutionEnvironment } from './transitional_adaptors.js';
 
 /**
  * Handles execution of public functions.
  */
 export class PublicExecutor {
   constructor(
-    private readonly stateDb: PublicStateDB,
+    private readonly publicStorageDB: PublicStateDB,
     private readonly contractsDb: PublicContractsDB,
     private readonly commitmentsDb: CommitmentsDB,
     private readonly header: Header,
@@ -38,10 +38,10 @@ export class PublicExecutor {
    * @returns The result of execution, including the results of all nested calls.
    */
   public async simulate(
-    executionRequest: PublicExecution,
+    executionRequest: PublicExecutionRequest,
     globalVariables: GlobalVariables,
     availableGas: Gas,
-    txContext: TxContext,
+    _txContext: TxContext,
     pendingSiloedNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
     startSideEffectCounter: number = 0,
@@ -53,7 +53,7 @@ export class PublicExecutor {
     PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
     const timer = new Timer();
 
-    const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
+    const hostStorage = new HostStorage(this.publicStorageDB, this.contractsDb, this.commitmentsDb);
     const trace = new PublicSideEffectTrace(startSideEffectCounter);
     const avmPersistableState = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
       hostStorage,
@@ -65,7 +65,6 @@ export class PublicExecutor {
       executionRequest,
       this.header,
       globalVariables,
-      txContext.gasSettings,
       transactionFee,
     );
 
@@ -75,7 +74,7 @@ export class PublicExecutor {
     const avmResult = await simulator.execute();
     const bytecode = simulator.getBytecode()!;
 
-    // Commit the journals state to the DBs since this is a top-level execution.
+    // Commit the public storage state to the DBs since this is a top-level execution.
     // Observe that this will write all the state changes to the DBs, not only the latest for each slot.
     // However, the underlying DB keep a cache and will only write the latest state to disk.
     // TODO(dbanks12): this should be unnecessary here or should be exposed by state manager
@@ -105,18 +104,34 @@ export class PublicExecutor {
       // (which counts the request itself)
     );
 
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): is this really needed?
-    // should already be handled in simulation.
-    if (executionRequest.callContext.isStaticCall) {
-      checkValidStaticCall(
-        publicExecutionResult.newNoteHashes,
-        publicExecutionResult.newNullifiers,
-        publicExecutionResult.contractStorageUpdateRequests,
-        publicExecutionResult.newL2ToL1Messages,
-        publicExecutionResult.unencryptedLogs,
-      );
-    }
-
     return publicExecutionResult;
   }
 }
+
+/**
+ * Convert a PublicExecutionRequest object to an AvmExecutionEnvironment
+ *
+ * @param executionRequest
+ * @param globalVariables
+ * @returns
+ */
+function createAvmExecutionEnvironment(
+  executionRequest: PublicExecutionRequest,
+  header: Header,
+  globalVariables: GlobalVariables,
+  transactionFee: Fr,
+): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    executionRequest.contractAddress,
+    executionRequest.callContext.storageContractAddress,
+    executionRequest.callContext.msgSender,
+    executionRequest.functionSelector,
+    /*contractCallDepth=*/ Fr.zero(),
+    transactionFee,
+    header,
+    globalVariables,
+    executionRequest.callContext.isStaticCall,
+    executionRequest.callContext.isDelegateCall,
+    executionRequest.args,
+  );
+}

package/src/public/hints_builder.ts

@@ -1,7 +1,7 @@
 import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
-  type MAX_NEW_NULLIFIERS_PER_TX,
+  type MAX_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type MAX_PUBLIC_DATA_HINTS,
@@ -30,7 +30,7 @@ export class HintsBuilder {
 
   async getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
   ) {
     return (
       await buildSiloedNullifierReadRequestHints(
@@ -45,7 +45,7 @@ export class HintsBuilder {
 
   getNullifierNonExistentReadRequestHints(
     nullifierNonExistentReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
   }

package/src/public/index.ts

@@ -1,6 +1,6 @@
 export * from './abstract_phase_manager.js';
 export * from './db_interfaces.js';
-export { isPublicExecutionResult, type PublicExecution, type PublicExecutionResult } from './execution.js';
+export { isPublicExecutionResult, type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
 export { PublicExecutor } from './executor.js';
 export * from './fee_payment.js';
 export { HintsBuilder } from './hints_builder.js';

package/src/public/public_kernel.ts

@@ -21,8 +21,9 @@ import {
   convertSimulatedPublicTeardownInputsToWitnessMap,
   convertSimulatedPublicTeardownOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
-import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
 
+import { WASMSimulator } from '../providers/acvm_wasm.js';
+import { type SimulationProvider } from '../providers/simulation_provider.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 /**

package/src/public/side_effect_trace.ts

@@ -16,19 +16,21 @@ import {
   Nullifier,
   ReadRequest,
 } from '@aztec/circuits.js';
-import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 
+import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
 import { createSimulationError } from '../common/errors.js';
-import { type PublicExecution, type PublicExecutionResult } from './execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
 export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
 
 export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
+  public logger = createDebugLogger('aztec:public_side_effect_trace');
+
   /** The side effect counter increments with every call to the trace. */
   private sideEffectCounter: number; // kept as number until finalized for efficiency
 
@@ -36,11 +38,11 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
 
   private noteHashReadRequests: ReadRequest[] = [];
-  private newNoteHashes: NoteHash[] = [];
+  private noteHashes: NoteHash[] = [];
 
   private nullifierReadRequests: ReadRequest[] = [];
   private nullifierNonExistentReadRequests: ReadRequest[] = [];
-  private newNullifiers: Nullifier[] = [];
+  private nullifiers: Nullifier[] = [];
 
   private l1ToL2MsgReadRequests: ReadRequest[] = [];
   private newL2ToL1Messages: L2ToL1Message[] = [];
@@ -85,6 +87,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.avmCircuitHints.storageValues.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ value),
     );
+    this.logger.debug(`SLOAD cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
   }
 
@@ -94,6 +97,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.contractStorageUpdateRequests.push(
       new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, storageAddress),
     );
+    this.logger.debug(`SSTORE cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
   }
 
@@ -106,6 +110,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.avmCircuitHints.noteHashExists.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
     );
+    this.logger.debug(`NOTE_HASH_CHECK cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -116,7 +121,8 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     // IS there, and the AVM circuit should accept THAT noteHash as a hint. The circuit will then compare
     // the noteHash against the one provided by the user code to determine what to return to the user (exists or not),
     // and will then propagate the actually-present noteHash to its public inputs.
-    this.newNoteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
+    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
+    this.logger.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -133,13 +139,15 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.avmCircuitHints.nullifierExists.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
     );
+    this.logger.debug(`NULLIFIER_EXISTS cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
   public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
-    this.newNullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    this.nullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    this.logger.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -152,6 +160,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.avmCircuitHints.l1ToL2MessageExists.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
     );
+    this.logger.debug(`L1_TO_L2_MSG_CHECK cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -159,21 +168,25 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     // TODO(4805): check if some threshold is reached for max messages
     const recipientAddress = EthAddress.fromField(recipient);
     this.newL2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, this.sideEffectCounter));
+    this.logger.debug(`NEW_L2_TO_L1_MSG cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
-  public traceUnencryptedLog(contractAddress: Fr, event: Fr, log: Fr[]) {
+  public traceUnencryptedLog(contractAddress: Fr, log: Fr[]) {
     // TODO(4805): check if some threshold is reached for max logs
     const ulog = new UnencryptedL2Log(
       AztecAddress.fromField(contractAddress),
-      EventSelector.fromField(event),
       Buffer.concat(log.map(f => f.toBuffer())),
     );
     const basicLogHash = Fr.fromBuffer(ulog.hash());
     this.unencryptedLogs.push(ulog);
     this.allUnencryptedLogs.push(ulog);
-    // TODO(6578): explain magic number 4 here
+    // We want the length of the buffer output from function_l2_logs -> toBuffer to equal the stored log length in the kernels.
+    // The kernels store the length of the processed log as 4 bytes; thus for this length value to match the log length stored in the kernels,
+    // we need to add four to the length here.
+    // https://github.com/AztecProtocol/aztec-packages/issues/6578#issuecomment-2125003435
     this.unencryptedLogsHashes.push(new LogHash(basicLogHash, this.sideEffectCounter, new Fr(ulog.length + 4)));
+    this.logger.debug(`NEW_UNENCRYPTED_LOG cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -191,6 +204,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
         instance.publicKeysHash,
       ),
     );
+    this.logger.debug(`CONTRACT_INSTANCE cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -210,7 +224,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     /** Bytecode used for this execution. */
     bytecode: Buffer,
     /** The call's results */
-    avmCallResults: AvmContractCallResults,
+    avmCallResults: AvmContractCallResult,
     /** Function name for logging */
     functionName: string = 'unknown',
   ) {
@@ -234,7 +248,12 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       result.startGasLeft.l2Gas - result.endGasLeft.l2Gas,
     );
     this.avmCircuitHints.externalCalls.items.push(
-      new AvmExternalCallHint(/*success=*/ new Fr(result.reverted ? 0 : 1), result.returnValues, gasUsed),
+      new AvmExternalCallHint(
+        /*success=*/ new Fr(result.reverted ? 0 : 1),
+        result.returnValues,
+        gasUsed,
+        result.endSideEffectCounter,
+      ),
     );
   }
 
@@ -251,14 +270,14 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     /** Bytecode used for this execution. */
     bytecode: Buffer,
     /** The call's results */
-    avmCallResults: AvmContractCallResults,
+    avmCallResults: AvmContractCallResult,
     /** Function name for logging */
     functionName: string = 'unknown',
     /** The side effect counter of the execution request itself */
     requestSideEffectCounter: number = this.startSideEffectCounter,
   ): PublicExecutionResult {
     return {
-      execution: createPublicExecutionRequest(requestSideEffectCounter, avmEnvironment),
+      executionRequest: createPublicExecutionRequest(requestSideEffectCounter, avmEnvironment),
 
       startSideEffectCounter: new Fr(this.startSideEffectCounter),
       endSideEffectCounter: new Fr(this.sideEffectCounter),
@@ -275,12 +294,12 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       contractStorageReads: this.contractStorageReads,
       contractStorageUpdateRequests: this.contractStorageUpdateRequests,
       noteHashReadRequests: this.noteHashReadRequests,
-      newNoteHashes: this.newNoteHashes,
+      noteHashes: this.noteHashes,
       nullifierReadRequests: this.nullifierReadRequests,
       nullifierNonExistentReadRequests: this.nullifierNonExistentReadRequests,
-      newNullifiers: this.newNullifiers,
+      nullifiers: this.nullifiers,
       l1ToL2MsgReadRequests: this.l1ToL2MsgReadRequests,
-      newL2ToL1Messages: this.newL2ToL1Messages,
+      l2ToL1Messages: this.newL2ToL1Messages,
       // correct the type on these now that they are finalized (lists won't grow)
       unencryptedLogs: new UnencryptedFunctionL2Logs(this.unencryptedLogs),
       allUnencryptedLogs: new UnencryptedFunctionL2Logs(this.allUnencryptedLogs),
@@ -303,21 +322,20 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 function createPublicExecutionRequest(
   requestSideEffectCounter: number,
   avmEnvironment: AvmExecutionEnvironment,
-): PublicExecution {
+): PublicExecutionRequest {
   const callContext = CallContext.from({
     msgSender: avmEnvironment.sender,
     storageContractAddress: avmEnvironment.storageAddress,
-    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    functionSelector: avmEnvironment.functionSelector,
     isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
     sideEffectCounter: requestSideEffectCounter,
   });
-  const execution: PublicExecution = {
+  return {
     contractAddress: avmEnvironment.address,
-    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    functionSelector: avmEnvironment.functionSelector,
     callContext,
     // execution request does not contain AvmContextInputs prefix
     args: avmEnvironment.getCalldataWithoutPrefix(),
   };
-  return execution;
 }

package/src/public/side_effect_trace_interface.ts

@@ -1,8 +1,8 @@
 import { type Gas } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
+import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
 import { type TracedContractInstance } from './side_effect_trace.js';
 
 export interface PublicSideEffectTraceInterface {
@@ -17,7 +17,7 @@ export interface PublicSideEffectTraceInterface {
   traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean): void;
   // TODO(dbanks12): should new message accept contract address as arg?
   traceNewL2ToL1Message(recipient: Fr, content: Fr): void;
-  traceUnencryptedLog(contractAddress: Fr, event: Fr, log: Fr[]): void;
+  traceUnencryptedLog(contractAddress: Fr, log: Fr[]): void;
   // TODO(dbanks12): odd that getContractInstance is a one-off in that it accepts an entire object instead of components
   traceGetContractInstance(instance: TracedContractInstance): void;
   traceNestedCall(
@@ -34,7 +34,7 @@ export interface PublicSideEffectTraceInterface {
     /** Bytecode used for this execution. */
     bytecode: Buffer,
     /** The call's results */
-    avmCallResults: AvmContractCallResults,
+    avmCallResults: AvmContractCallResult,
     /** Function name */
     functionName: string,
   ): void;

package/src/public/tail_phase_manager.ts

@@ -4,7 +4,7 @@ import {
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
-  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   type PublicKernelCircuitPublicInputs,
   PublicKernelTailCircuitPrivateInputs,
@@ -69,9 +69,9 @@ export class TailPhaseManager extends AbstractPhaseManager {
     const { validationRequests, endNonRevertibleData: nonRevertibleData, end: revertibleData } = previousOutput;
 
     const pendingNullifiers = mergeAccumulatedData(
-      nonRevertibleData.newNullifiers,
-      revertibleData.newNullifiers,
-      MAX_NEW_NULLIFIERS_PER_TX,
+      nonRevertibleData.nullifiers,
+      revertibleData.nullifiers,
+      MAX_NULLIFIERS_PER_TX,
     );
 
     const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(