@aztec/simulator 0.37.0 → 0.38.0

package/src/avm/journal/nullifiers.ts

@@ -1,3 +1,4 @@
+import { AztecAddress } from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -10,7 +11,7 @@ import type { CommitmentsDB } from '../../index.js';
  */
 export class Nullifiers {
   /** Cached nullifiers. */
-  private cache: NullifierCache;
+  public cache: NullifierCache;
   /** Parent's nullifier cache. Checked on cache-miss. */
   private readonly parentCache: NullifierCache | undefined;
   /** Reference to node storage. Checked on parent cache-miss. */
@@ -95,6 +96,7 @@ export class NullifierCache {
    * each entry being a nullifier.
    */
   private cachePerContract: Map<bigint, Set<bigint>> = new Map();
+  private siloedNullifiers: Set<bigint> = new Set();
 
   /**
    * Check whether a nullifier exists in the cache.
@@ -104,8 +106,10 @@ export class NullifierCache {
    * @returns whether the nullifier is found in the cache
    */
   public exists(storageAddress: Fr, nullifier: Fr): boolean {
-    const exists = this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt());
-    return exists ? true : false;
+    const exists =
+      this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt()) ||
+      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(storageAddress), nullifier).toBigInt());
+    return !!exists;
   }
 
   /**
@@ -115,20 +119,25 @@ export class NullifierCache {
    * @param nullifier - the nullifier to stage
    */
   public append(storageAddress: Fr, nullifier: Fr) {
+    if (this.exists(storageAddress, nullifier)) {
+      throw new NullifierCollisionError(
+        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
+      );
+    }
+
     let nullifiersForContract = this.cachePerContract.get(storageAddress.toBigInt());
     // If this contract's nullifier set has no cached nullifiers, create a new Set to store them
     if (!nullifiersForContract) {
       nullifiersForContract = new Set();
       this.cachePerContract.set(storageAddress.toBigInt(), nullifiersForContract);
     }
-    if (nullifiersForContract.has(nullifier.toBigInt())) {
-      throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
-      );
-    }
     nullifiersForContract.add(nullifier.toBigInt());
   }
 
+  public appendSiloed(siloedNullifier: Fr) {
+    this.siloedNullifiers.add(siloedNullifier.toBigInt());
+  }
+
   /**
    * Merge another cache's nullifiers into this instance's.
    *
@@ -139,6 +148,8 @@ export class NullifierCache {
    * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
    */
   public acceptAndMerge(incomingNullifiers: NullifierCache) {
+    // Merge siloed nullifiers.
+    this.siloedNullifiers = new Set([...this.siloedNullifiers, ...incomingNullifiers.siloedNullifiers]);
     // Iterate over all contracts with staged writes in the child.
     for (const [incomingAddress, incomingCacheAtContract] of incomingNullifiers.cachePerContract) {
       const thisCacheAtContract = this.cachePerContract.get(incomingAddress);

package/src/avm/journal/public_storage.ts

@@ -1,7 +1,14 @@
+import { AztecAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { PublicStateDB } from '../../index.js';
 
+type PublicStorageReadResult = {
+  value: Fr;
+  exists: boolean;
+  cached: boolean;
+};
+
 /**
  * A class to manage public storage reads and writes during a contract call's AVM simulation.
  * Maintains a storage write cache, and ensures that reads fall back to the correct source.
@@ -39,7 +46,8 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being read from
    * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
    */
-  public async read(storageAddress: Fr, slot: Fr): Promise<[/*exists=*/ boolean, /*value=*/ Fr]> {
+  public async read(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
+    let cached = false;
     // First try check this storage cache
     let value = this.cache.read(storageAddress, slot);
     // Then try parent's storage cache (if it exists / written to earlier in this TX)
@@ -49,11 +57,13 @@ export class PublicStorage {
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
       value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+    } else {
+      cached = true;
     }
     // if value is undefined, that means this slot has never been written to!
     const exists = value !== undefined;
     const valueOrZero = exists ? value : Fr.ZERO;
-    return Promise.resolve([exists, valueOrZero]);
+    return Promise.resolve({ value: valueOrZero, exists, cached });
   }
 
   /**
@@ -75,6 +85,17 @@ export class PublicStorage {
   public acceptAndMerge(incomingPublicStorage: PublicStorage) {
     this.cache.acceptAndMerge(incomingPublicStorage.cache);
   }
+
+  /**
+   * Commits ALL staged writes to the host's state.
+   */
+  public async commitToDB() {
+    for (const [storageAddress, cacheAtContract] of this.cache.cachePerContract) {
+      for (const [slot, value] of cacheAtContract) {
+        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(storageAddress), new Fr(slot), value);
+      }
+    }
+  }
 }
 
 /**

package/src/avm/journal/trace.ts

@@ -29,13 +29,14 @@ export class WorldStateAccessTrace {
 
   constructor(parentTrace?: WorldStateAccessTrace) {
     this.accessCounter = parentTrace ? parentTrace.accessCounter : 0;
+    // TODO(4805): consider tracking the parent's trace vector lengths so we can enforce limits
   }
 
   public getAccessCounter() {
     return this.accessCounter;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean) {
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
     // TODO(4805): check if some threshold is reached for max storage reads
     // (need access to parent length, or trace needs to be initialized with parent's contents)
     const traced: TracedPublicStorageRead = {
@@ -44,6 +45,7 @@ export class WorldStateAccessTrace {
       slot,
       value,
       exists,
+      cached,
       counter: new Fr(this.accessCounter),
       //  endLifetime: Fr.ZERO,
     };
@@ -151,9 +153,6 @@ export class WorldStateAccessTrace {
   /**
    * Merges another trace into this one
    *
-   * - Public state journals (r/w logs), with the accessing being appended in chronological order
-   * - Utxo objects are concatenated
-   *
    * @param incomingTrace - the incoming trace to merge into this instance
    */
   public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {

package/src/avm/journal/trace_types.ts

@@ -11,6 +11,7 @@ export type TracedPublicStorageRead = {
   //  callPointer: Fr;
   storageAddress: Fr;
   exists: boolean;
+  cached: boolean;
   slot: Fr;
   value: Fr;
   counter: Fr;

package/src/avm/opcodes/bitwise.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { type IntegralValue } from '../avm_memory_types.js';
+import { type IntegralValue, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
 
@@ -9,7 +9,7 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    this.checkTags(memory, this.inTag, this.aOffset, this.bOffset);
 
     const a = memory.getAs<IntegralValue>(this.aOffset);
     const b = memory.getAs<IntegralValue>(this.bOffset);
@@ -22,13 +22,16 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   }
 
   protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+  protected checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTags(inTag, aOffset, bOffset);
+  }
 }
 
 export class And extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'AND';
   static readonly opcode = Opcode.AND;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.and(b);
   }
 }
@@ -37,7 +40,7 @@ export class Or extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'OR';
   static readonly opcode = Opcode.OR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.or(b);
   }
 }
@@ -46,7 +49,7 @@ export class Xor extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'XOR';
   static readonly opcode = Opcode.XOR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.xor(b);
   }
 }
@@ -55,18 +58,26 @@ export class Shl extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHL';
   static readonly opcode = Opcode.SHL;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shl(b);
   }
+  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTag(inTag, aOffset);
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
 }
 
 export class Shr extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHR';
   static readonly opcode = Opcode.SHR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shr(b);
   }
+  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTag(inTag, aOffset);
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
 }
 
 export class Not extends TwoOperandInstruction {

package/src/avm/opcodes/environment_getters.ts

@@ -59,6 +59,15 @@ export class FeePerDAGas extends EnvironmentGetterInstruction {
   }
 }
 
+export class TransactionFee extends EnvironmentGetterInstruction {
+  static type: string = 'TRANSACTIONFEE';
+  static readonly opcode: Opcode = Opcode.TRANSACTIONFEE;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return env.transactionFee;
+  }
+}
+
 export class ChainId extends EnvironmentGetterInstruction {
   static type: string = 'CHAINID';
   static readonly opcode: Opcode = Opcode.CHAINID;

package/src/avm/opcodes/external_calls.ts

@@ -1,16 +1,12 @@
-import { FunctionSelector } from '@aztec/circuits.js';
+import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { executePublicFunction } from '../../public/executor.js';
-import {
-  convertPublicExecutionResult,
-  createPublicExecutionContext,
-  updateAvmContextFromPublicExecutionResult,
-} from '../../public/transitional_adaptors.js';
+import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
 import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
+import { AvmSimulator } from '../avm_simulator.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -69,7 +65,7 @@ abstract class ExternalCall extends Instruction {
     const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
     context.machineState.consumeGas(totalGas);
 
-    // TRANSITIONAL: This should be removed once the AVM is fully operational and the public executor is gone.
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -77,11 +73,21 @@ abstract class ExternalCall extends Instruction {
       this.type,
       FunctionSelector.fromField(functionSelector),
     );
-    const pxContext = createPublicExecutionContext(nestedContext, calldata);
-    const pxResults = await executePublicFunction(pxContext, /*nested=*/ true);
-    const nestedCallResults: AvmContractCallResults = convertPublicExecutionResult(pxResults);
-    updateAvmContextFromPublicExecutionResult(nestedContext, pxResults);
-    const nestedPersistableState = nestedContext.persistableState;
+    const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
+
+    const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
+    const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    const pxResults = convertAvmResultsToPxResult(
+      nestedCallResults,
+      startSideEffectCounter,
+      oldStyleExecution,
+      Gas.from(allocatedGas),
+      nestedContext,
+    );
+    // 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,
@@ -90,7 +96,6 @@ abstract class ExternalCall extends Instruction {
     //   FunctionSelector.fromField(functionSelector),
     // );
     // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
-    // const nestedPersistableState = nestedContext.persistableState;
 
     const success = !nestedCallResults.reverted;
 
@@ -112,9 +117,9 @@ abstract class ExternalCall extends Instruction {
 
     // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
     if (success) {
-      context.persistableState.acceptNestedCallState(nestedPersistableState);
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
     } else {
-      context.persistableState.rejectNestedCallState(nestedPersistableState);
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
     }
 
     memory.assert(memoryOperations);

package/src/avm/serialization/bytecode_serialization.ts

@@ -46,6 +46,7 @@ import {
   StorageAddress,
   Sub,
   Timestamp,
+  TransactionFee,
   Version,
   Xor,
 } from '../opcodes/index.js';
@@ -82,6 +83,7 @@ const INSTRUCTION_SET = () =>
     [Sender.opcode, Sender],
     [FeePerL2Gas.opcode, FeePerL2Gas],
     [FeePerDAGas.opcode, FeePerDAGas],
+    [TransactionFee.opcode, TransactionFee],
     //[Contractcalldepth.opcode, Contractcalldepth],
     // Execution Environment - Globals
     [ChainId.opcode, ChainId],

package/src/avm/serialization/instruction_serialization.ts

@@ -29,6 +29,7 @@ export enum Opcode {
   SENDER,
   FEEPERL2GAS,
   FEEPERDAGAS,
+  TRANSACTIONFEE,
   CONTRACTCALLDEPTH,
   CHAINID,
   VERSION,

package/src/client/client_execution_context.ts

@@ -15,10 +15,8 @@ import {
   FunctionData,
   FunctionSelector,
   type Header,
-  NoteHashReadRequestMembershipWitness,
   PrivateContextInputs,
   PublicCallRequest,
-  type SideEffect,
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
@@ -32,7 +30,8 @@ import { type NoteData, toACVMWitness } from '../acvm/index.js';
 import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
-import { type ExecutionResult, type NoteAndSlot, type NullifiedNoteHashCounter } from './execution_result.js';
+import { CountedLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { type LogsCache } from './logs_cache.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -58,10 +57,10 @@ export class ClientExecutionContext extends ViewDataOracle {
    * because these notes are meant to be maintained on a per-call basis
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
-  private gotNotes: Map<bigint, bigint> = new Map();
-  private nullifiedNoteHashCounters: NullifiedNoteHashCounter[] = [];
-  private encryptedLogs: EncryptedL2Log[] = [];
-  private unencryptedLogs: UnencryptedL2Log[] = [];
+  private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
+  private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
+  private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
 
@@ -76,6 +75,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     authWitnesses: AuthWitness[],
     private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
+    private readonly logsCache: LogsCache,
     db: DBOracle,
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
@@ -112,23 +112,11 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * This function will populate readRequestPartialWitnesses which
-   * here is just used to flag reads as "transient" for new notes created during this execution
-   * or to flag non-transient reads with their leafIndex.
-   * The KernelProver will use this to fully populate witnesses and provide hints to
-   * the kernel regarding which commitments each transient read request corresponds to.
-   * @param noteHashReadRequests - SideEffect containing Note hashed of the notes being read and counter.
-   * @returns An array of partially filled in read request membership witnesses.
+   * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
+   * regarding which note hash each settled read request corresponds to.
    */
-  public getNoteHashReadRequestPartialWitnesses(noteHashReadRequests: SideEffect[]) {
-    return noteHashReadRequests
-      .filter(r => !r.isEmpty())
-      .map(r => {
-        const index = this.gotNotes.get(r.value.toBigInt());
-        return index !== undefined
-          ? NoteHashReadRequestMembershipWitness.empty(index)
-          : NoteHashReadRequestMembershipWitness.emptyTransient();
-      });
+  public getNoteHashLeafIndexMap() {
+    return this.noteHashLeafIndexMap;
   }
 
   /**
@@ -147,14 +135,28 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Return the encrypted logs emitted during this execution.
    */
   public getEncryptedLogs() {
-    return new EncryptedFunctionL2Logs(this.encryptedLogs);
+    return this.encryptedLogs;
+  }
+
+  /**
+   * Return the encrypted logs emitted during this execution and nested executions.
+   */
+  public getAllEncryptedLogs() {
+    return new EncryptedFunctionL2Logs(this.logsCache.getEncryptedLogs());
   }
 
   /**
    * Return the encrypted logs emitted during this execution.
    */
   public getUnencryptedLogs() {
-    return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
+    return this.unencryptedLogs;
+  }
+
+  /**
+   * Return the unencrypted logs emitted during this execution and nested executions.
+   */
+  public getAllUnencryptedLogs() {
+    return new UnencryptedFunctionL2Logs(this.logsCache.getUnencryptedLogs());
   }
 
   /**
@@ -265,7 +267,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
         // Should always be uniqueSiloedNoteHash when publicly created notes include nonces.
         const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash;
-        this.gotNotes.set(noteHashForReadRequest.value, n.index);
+        this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
       }
     });
 
@@ -321,7 +323,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       innerNoteHash,
     );
     if (nullifiedNoteHashCounter !== undefined) {
-      this.nullifiedNoteHashCounters.push({ noteHashCounter: nullifiedNoteHashCounter, nullifierCounter: counter });
+      this.nullifiedNoteHashCounters.set(nullifiedNoteHashCounter, counter);
     }
     return Promise.resolve();
   }
@@ -340,24 +342,45 @@ export class ClientExecutionContext extends ViewDataOracle {
     noteTypeId: Fr,
     publicKey: Point,
     log: Fr[],
+    counter: number,
   ) {
     const note = new Note(log);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
     const encryptedNote = taggedNote.toEncryptedBuffer(publicKey);
     const encryptedLog = new EncryptedL2Log(encryptedNote);
-    this.encryptedLogs.push(encryptedLog);
-    return Fr.fromBuffer(encryptedLog.hash());
+    this.encryptedLogs.push(new CountedLog(encryptedLog, counter));
+    this.logsCache.addEncryptedLog(encryptedLog);
+    return encryptedNote;
   }
 
   /**
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public override emitUnencryptedLog(log: UnencryptedL2Log) {
-    this.unencryptedLogs.push(log);
+  public override emitUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
     const text = log.toHumanReadable();
     this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+  }
+
+  /**
+   * Emit a contract class unencrypted log.
+   * This fn exists separately from emitUnencryptedLog because sha hashing the preimage
+   * is too large to compile (16,200 fields, 518,400 bytes) => the oracle hashes it.
+   * See private_context.nr
+   * @param log - The unencrypted log to be emitted.
+   */
+  public override emitContractClassUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
+    const text = log.toHumanReadable();
+    this.log.verbose(
+      `Emitted unencrypted log from ContractClassRegisterer: "${
+        text.length > 100 ? text.slice(0, 100) + '...' : text
+      }"`,
+    );
     return Fr.fromBuffer(log.hash());
   }
 
@@ -419,6 +442,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.authWitnesses,
       this.packedValuesCache,
       this.noteCache,
+      this.logsCache,
       this.db,
       this.node,
       sideEffectCounter,

package/src/client/db_oracle.ts

@@ -6,7 +6,7 @@ import {
   type PublicDataWitness,
 } from '@aztec/circuit-types';
 import { type CompleteAddress, type Header } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata, type FunctionSelector } from '@aztec/foundation/abi';
+import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr, type Point } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
@@ -102,10 +102,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param selector - The corresponding function selector.
    * @returns A Promise that resolves to a FunctionArtifact object.
    */
-  getFunctionArtifact(
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-  ): Promise<FunctionArtifactWithDebugMetadata>;
+  getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
 
   /**
    * Retrieves the artifact of a specified function within a given contract.
@@ -115,10 +112,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param functionName - The name of the function.
    * @returns The corresponding function's artifact as an object.
    */
-  getFunctionArtifactByName(
-    contractAddress: AztecAddress,
-    functionName: string,
-  ): Promise<FunctionArtifactWithDebugMetadata | undefined>;
+  getFunctionArtifactByName(contractAddress: AztecAddress, functionName: string): Promise<FunctionArtifact | undefined>;
 
   /**
    * Gets the index of a nullifier in the nullifier tree.