@aztec/simulator 0.43.0 → 0.45.0

package/src/avm/opcodes/environment_getters.ts

@@ -1,6 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue, Uint64 } from '../avm_memory_types.js';
+import { Field, type MemoryValue, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { GetterInstruction } from './instruction_impl.js';
 
@@ -39,21 +39,12 @@ export class Sender extends EnvironmentGetterInstruction {
   }
 }
 
-export class FeePerL2Gas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERL2GAS';
-  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerL2Gas);
-  }
-}
-
-export class FeePerDAGas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERDAGAS';
-  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+export class FunctionSelector extends EnvironmentGetterInstruction {
+  static type: string = 'FUNCTIONSELECTOR';
+  static readonly opcode: Opcode = Opcode.FUNCTIONSELECTOR;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerDaGas);
+    return new Uint32(env.functionSelector.value);
   }
 }
 
@@ -101,3 +92,21 @@ export class Timestamp extends EnvironmentGetterInstruction {
     return new Uint64(env.globals.timestamp.toBigInt());
   }
 }
+
+export class FeePerL2Gas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERL2GAS';
+  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerL2Gas);
+  }
+}
+
+export class FeePerDAGas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERDAGAS';
+  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerDaGas);
+  }
+}

package/src/avm/opcodes/external_calls.ts

@@ -1,11 +1,10 @@
 import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { gasLeftToGas } from '../avm_gas.js';
 import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
-import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -24,7 +23,6 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
-    /* temporary function selector */
     OperandType.UINT32,
   ];
 
@@ -37,8 +35,8 @@ abstract class ExternalCall extends Instruction {
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
-    // Function selector is temporary since eventually public contract bytecode will be one blob
-    // containing all functions, and function selector will become an application-level mechanism
+    // NOTE: Function selector is likely temporary since eventually public contract bytecode will be one
+    // blob containing all functions, and function selector will become an application-level mechanism
     // (e.g. first few bytes of calldata + compiler-generated jump table)
     private functionSelectorOffset: number,
   ) {
@@ -81,7 +79,6 @@ abstract class ExternalCall extends Instruction {
     const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
     context.machineState.consumeGas(allocatedGas);
 
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -89,32 +86,9 @@ abstract class ExternalCall extends Instruction {
       callType,
       FunctionSelector.fromField(functionSelector),
     );
-    const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
-    const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
     const simulator = new AvmSimulator(nestedContext);
-    const nestedCallResults: AvmContractCallResults = await simulator.execute();
-    const pxResults = convertAvmResultsToPxResult(
-      nestedCallResults,
-      startSideEffectCounter,
-      oldStyleExecution,
-      Gas.from(allocatedGas),
-      nestedContext,
-      simulator.getBytecode(),
-    );
-    // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
-    context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);
-    // END TRANSITIONAL
-
-    // const nestedContext = context.createNestedContractCallContext(
-    //   callAddress.toFr(),
-    //   calldata,
-    //   allocatedGas,
-    //   this.type,
-    //   FunctionSelector.fromField(functionSelector),
-    // );
-    // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
-
+    const nestedCallResults: AvmContractCallResult = await simulator.execute();
     const success = !nestedCallResults.reverted;
 
     // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
@@ -143,12 +117,15 @@ abstract class ExternalCall extends Instruction {
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
 
-    // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
-    if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
-    } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
-    }
+    // Accept the nested call's state and trace the nested call
+    await context.persistableState.processNestedCall(
+      /*nestedState=*/ nestedContext.persistableState,
+      /*nestedEnvironment=*/ nestedContext.environment,
+      /*startGasLeft=*/ Gas.from(allocatedGas),
+      /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),
+      /*bytecode=*/ simulator.getBytecode()!,
+      /*avmCallResults=*/ nestedCallResults,
+    );
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/serialization/bytecode_serialization.ts

@@ -21,6 +21,7 @@ import {
   FeePerDAGas,
   FeePerL2Gas,
   FieldDiv,
+  FunctionSelector,
   GetContractInstance,
   InternalCall,
   InternalReturn,
@@ -85,16 +86,16 @@ const INSTRUCTION_SET = () =>
     [Address.opcode, Address],
     [StorageAddress.opcode, StorageAddress],
     [Sender.opcode, Sender],
-    [FeePerL2Gas.opcode, FeePerL2Gas],
-    [FeePerDAGas.opcode, FeePerDAGas],
+    [FunctionSelector.opcode, FunctionSelector],
     [TransactionFee.opcode, TransactionFee],
-    //[Contractcalldepth.opcode, Contractcalldepth],
     // Execution Environment - Globals
     [ChainId.opcode, ChainId],
     [Version.opcode, Version],
     [BlockNumber.opcode, BlockNumber],
     [Timestamp.opcode, Timestamp],
     //[Coinbase.opcode, Coinbase],
+    [FeePerL2Gas.opcode, FeePerL2Gas],
+    [FeePerDAGas.opcode, FeePerDAGas],
     //[Blockl2gaslimit.opcode, Blockl2gaslimit],
     //[Blockdagaslimit.opcode, Blockdagaslimit],
     // Execution Environment - Calldata

package/src/avm/serialization/instruction_serialization.ts

@@ -27,15 +27,15 @@ export enum Opcode {
   ADDRESS,
   STORAGEADDRESS,
   SENDER,
-  FEEPERL2GAS,
-  FEEPERDAGAS,
+  FUNCTIONSELECTOR,
   TRANSACTIONFEE,
-  CONTRACTCALLDEPTH,
   CHAINID,
   VERSION,
   BLOCKNUMBER,
   TIMESTAMP,
   COINBASE,
+  FEEPERL2GAS,
+  FEEPERDAGAS,
   BLOCKL2GASLIMIT,
   BLOCKDAGASLIMIT,
   CALLDATACOPY,

package/src/avm/test_utils.ts

@@ -0,0 +1,53 @@
+import { Fr } from '@aztec/circuits.js';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { type jest } from '@jest/globals';
+import { mock } from 'jest-mock-extended';
+
+import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../public/db_interfaces.js';
+import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
+import { type HostStorage } from './journal/host_storage.js';
+
+export function mockGetBytecode(hs: HostStorage, bytecode: Buffer) {
+  (hs as jest.Mocked<HostStorage>).contractsDb.getBytecode.mockResolvedValue(bytecode);
+}
+
+export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
+  (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
+    nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
+  );
+}
+
+export function mockStorageRead(hs: HostStorage, value: Fr) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockResolvedValue(value);
+}
+
+export function mockStorageReadWithMap(hs: HostStorage, mockedStorage: Map<bigint, Fr>) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockImplementation((_address, slot) =>
+    Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
+  );
+}
+
+export function mockNoteHashExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockNullifierExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockL1ToL2MessageExists(hs: HostStorage, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+    if (index == leafIndex.toBigInt()) {
+      return Promise.resolve(value);
+    } else {
+      // any indices other than mockAtLeafIndex will return a different value
+      // (or undefined if no value is specified for other indices)
+      return Promise.resolve(valueAtOtherIndices!);
+    }
+  });
+}
+
+export function mockGetContractInstance(hs: HostStorage, contractInstance: ContractInstanceWithAddress) {
+  (hs.contractsDb as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+}

package/src/client/client_execution_context.ts

@@ -22,7 +22,13 @@ import {
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
 import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
-import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
+import {
+  EventSelector,
+  type FunctionAbi,
+  type FunctionArtifact,
+  type NoteSelector,
+  countArgumentsSize,
+} from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
@@ -288,7 +294,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override notifyCreatedNote(
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     noteItems: Fr[],
     innerNoteHash: Fr,
     counter: number,
@@ -382,7 +388,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     preimage: Fr[],
   ) {
     const event = new Event(preimage);
-    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, eventTypeId);
+    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, EventSelector.fromField(eventTypeId));
     const taggedEvent = new TaggedLog(l1EventPayload);
 
     const ephSk = GrumpkinScalar.random();
@@ -404,7 +410,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public override computeEncryptedNoteLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     ovKeys: KeyValidationRequest,
     ivpkM: Point,
     preimage: Fr[],
@@ -672,16 +678,25 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ): Promise<Fr[]> {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
 
-      const value = await this.aztecNode.getPublicStorageAt(this.callContext.storageContractAddress, storageSlot);
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
 
       values.push(value);
     }

package/src/client/execution_note_cache.ts

@@ -63,7 +63,6 @@ export class ExecutionNoteCache {
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
     }
-
     return nullifiedNoteHashCounter;
   }
 

package/src/client/execution_result.ts

@@ -8,6 +8,7 @@ import {
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type NoteSelector } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -21,7 +22,7 @@ export interface NoteAndSlot {
   /** The storage slot of the note. */
   storageSlot: Fr;
   /** The note type identifier. */
-  noteTypeId: Fr;
+  noteTypeId: NoteSelector;
 }
 
 export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2NoteLog | EncryptedL2Log> implements IsEmpty {

package/src/client/index.ts

@@ -1,3 +1,5 @@
 export * from './simulator.js';
 export * from './db_oracle.js';
 export * from './execution_result.js';
+export * from './pick_notes.js';
+export * from './execution_note_cache.js';

package/src/client/simulator.ts

@@ -5,6 +5,7 @@ import {
   type FunctionArtifact,
   FunctionSelector,
   FunctionType,
+  type NoteSelector,
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -140,7 +141,7 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
     nonce: Fr,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     computeNullifier: boolean,
     note: Note,
   ) {
@@ -210,7 +211,12 @@ export class AcirSimulator {
    * @param note - The note.
    * @returns The note hash.
    */
-  public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
+  public async computeInnerNoteHash(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    noteTypeId: NoteSelector,
+    note: Note,
+  ) {
     const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,

package/src/client/view_data_oracle.ts

@@ -42,6 +42,14 @@ export class ViewDataOracle extends TypedOracle {
     return Promise.resolve(this.contractAddress);
   }
 
+  public override getChainId(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getChainId().then(id => new Fr(id)));
+  }
+
+  public override getVersion(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getVersion().then(v => new Fr(v)));
+  }
+
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.
@@ -252,16 +260,25 @@ export class ViewDataOracle extends TypedOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number) {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ) {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const value = await this.aztecNode.getPublicStorageAt(this.contractAddress, storageSlot);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
 
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
       values.push(value);
     }
     return values;

package/src/mocks/fixtures.ts

@@ -14,10 +14,10 @@ import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from '../public/execution.js';
 
 export class PublicExecutionResultBuilder {
-  private _execution: PublicExecution;
+  private _executionRequest: PublicExecutionRequest;
   private _nestedExecutions: PublicExecutionResult[] = [];
   private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
   private _contractStorageReads: ContractStorageRead[] = [];
@@ -25,8 +25,8 @@ export class PublicExecutionResultBuilder {
   private _reverted = false;
   private _revertReason: SimulationError | undefined = undefined;
 
-  constructor(execution: PublicExecution) {
-    this._execution = execution;
+  constructor(executionRequest: PublicExecutionRequest) {
+    this._executionRequest = executionRequest;
   }
 
   static fromPublicCallRequest({
@@ -120,7 +120,7 @@ export class PublicExecutionResultBuilder {
 
   build(overrides: Partial<PublicExecutionResult> = {}): PublicExecutionResult {
     return {
-      execution: this._execution,
+      executionRequest: this._executionRequest,
       nestedExecutions: this._nestedExecutions,
       noteHashReadRequests: [],
       nullifierReadRequests: [],
@@ -143,7 +143,8 @@ export class PublicExecutionResultBuilder {
       endGasLeft: Gas.test(),
       transactionFee: Fr.ZERO,
       calldata: [],
-      avmHints: AvmExecutionHints.empty(),
+      avmCircuitHints: AvmExecutionHints.empty(),
+      functionName: 'unknown',
       ...overrides,
     };
   }

package/src/public/abstract_phase_manager.ts

@@ -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,
@@ -77,6 +77,7 @@ export const PhaseIsRevertible: Record<PublicKernelType, boolean> = {
 };
 
 export type PublicProvingInformation = {
+  functionName: string; // informational only
   calldata: Fr[];
   bytecode: Buffer;
   inputs: PublicKernelCircuitPrivateInputs;
@@ -89,6 +90,7 @@ export function makeAvmProvingRequest(
 ): AvmProvingRequest {
   return {
     type: AVM_REQUEST,
+    functionName: info.functionName,
     bytecode: info.bytecode,
     calldata: info.calldata,
     avmHints: info.avmHints,
@@ -174,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]: [],
       };
     }
@@ -189,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]: [],
@@ -254,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;
@@ -264,13 +266,15 @@ export abstract class AbstractPhaseManager {
         const isExecutionRequest = !isPublicExecutionResult(current);
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
-              current,
+              /*executionRequest=*/ current,
               this.globalVariables,
               /*availableGas=*/ this.getAvailableGas(tx, kernelPublicOutput),
               tx.data.constants.txContext,
               /*pendingNullifiers=*/ this.getSiloedPendingNullifiers(kernelPublicOutput),
               transactionFee,
               /*startSideEffectCounter=*/ AbstractPhaseManager.getMaxSideEffectCounter(kernelPublicOutput) + 1,
+              // NOTE: startSideEffectCounter is not the same as the executionRequest's sideEffectCounter
+              // (which counts the request itself)
             )
           : current;
 
@@ -279,18 +283,20 @@ 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} reverted with no reason.`,
+            `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }) reverted with no reason.`,
           );
         }
 
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
-            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
-              result.revertReason
-            }`,
+            `Simulation error on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }) with reason: ${result.revertReason}`,
           );
           throw result.revertReason;
         }
@@ -302,7 +308,9 @@ 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
+          })`,
         );
         const callData = await this.getPublicCallData(result, isExecutionRequest);
         const [privateInputs, publicInputs] = await this.runKernelCircuit(kernelPublicOutput, callData);
@@ -310,10 +318,11 @@ export abstract class AbstractPhaseManager {
 
         // Capture the inputs for later proving in the AVM and kernel.
         const publicProvingInformation: PublicProvingInformation = {
+          functionName: result.functionName,
           calldata: result.calldata,
           bytecode: result.bytecode!,
           inputs: privateInputs,
-          avmHints: result.avmHints,
+          avmHints: result.avmCircuitHints,
         };
         provingInformationList.push(publicProvingInformation);
 
@@ -322,7 +331,9 @@ 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}, but simulator did.`,
+            `Public kernel circuit did not revert on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }), but simulator did.`,
           );
         }
 
@@ -330,9 +341,9 @@ 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} with reason: ${
-              result.revertReason
-            }`,
+            `Reverting on ${result.executionRequest.contractAddress.toString()}:${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.
           return {
@@ -419,9 +430,9 @@ export abstract class AbstractPhaseManager {
     );
 
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
-      callContext: result.execution.callContext,
+      callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
-      argsHash: computeVarArgsHash(result.execution.args),
+      argsHash: computeVarArgsHash(result.executionRequest.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),
@@ -470,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,
     );

package/src/public/app_logic_phase_manager.ts

@@ -47,6 +47,7 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
       // if so, this is removing contracts deployed in private setup
       await this.publicContractsDB.removeNewContracts(tx);
       await this.publicStateDB.rollbackToCheckpoint();
+      tx.filterRevertedLogs(kernelOutput);
     } else {
       tx.unencryptedLogs.addFunctionLogs(newUnencryptedLogs);
       // TODO(#6470): we should be adding contracts deployed in those logs to the publicContractsDB