@aztec/simulator 0.41.0 → 0.43.0

package/src/avm/opcodes/memory.ts

@@ -1,6 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations, TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -115,12 +114,17 @@ export class CMov extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = memory.get(this.aOffset);
-    const b = memory.get(this.bOffset);
-    const cond = memory.get(this.condOffset);
+    const [aOffset, bOffset, condOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.condOffset, this.dstOffset],
+      memory,
+    );
+
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
+    const cond = memory.get(condOffset);
 
     // TODO: reconsider toBigInt() here
-    memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
+    memory.set(dstOffset, cond.toBigInt() > 0 ? a : b);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -131,8 +135,8 @@ export class Cast extends TwoOperandInstruction {
   static readonly type: string = 'CAST';
   static readonly opcode = Opcode.CAST;
 
-  constructor(indirect: number, dstTag: number, aOffset: number, dstOffset: number) {
-    super(indirect, dstTag, aOffset, dstOffset);
+  constructor(indirect: number, dstTag: number, srcOffset: number, dstOffset: number) {
+    super(indirect, dstTag, srcOffset, dstOffset);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -140,13 +144,14 @@ export class Cast extends TwoOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = memory.get(this.aOffset);
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
+
+    const a = memory.get(srcOffset);
 
-    // TODO: consider not using toBigInt()
     const casted =
       this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
 
-    memory.set(this.dstOffset, casted);
+    memory.set(dstOffset, casted);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -205,10 +210,11 @@ export class CalldataCopy extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
+    // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
+    const [cdOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.cdOffset, this.dstOffset], memory);
 
     const transformedData = context.environment.calldata
-      .slice(this.cdOffset, this.cdOffset + this.copySize)
+      .slice(cdOffset, cdOffset + this.copySize)
       .map(f => new Field(f));
 
     memory.setSlice(dstOffset, transformedData);
@@ -216,10 +222,4 @@ export class CalldataCopy extends Instruction {
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -0,0 +1,114 @@
+import { Fq, Point } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+
+import { strict as assert } from 'assert';
+
+import { type AvmContext } from '../avm_context.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class MultiScalarMul extends Instruction {
+  static type: string = 'MultiScalarMul';
+  static readonly opcode: Opcode = Opcode.MSM;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8 /* opcode */,
+    OperandType.UINT8 /* indirect */,
+    OperandType.UINT32 /* points vector offset */,
+    OperandType.UINT32 /* scalars vector offset */,
+    OperandType.UINT32 /* output offset (fixed triplet) */,
+    OperandType.UINT32 /* points length offset */,
+  ];
+
+  constructor(
+    private indirect: number,
+    private pointsOffset: number,
+    private scalarsOffset: number,
+    private outputOffset: number,
+    private pointsLengthOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    // Resolve indirects
+    const [pointsOffset, scalarsOffset, outputOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.pointsOffset, this.scalarsOffset, this.outputOffset],
+      memory,
+    );
+
+    // Length of the points vector should be U32
+    memory.checkTag(TypeTag.UINT32, this.pointsLengthOffset);
+    // Get the size of the unrolled (x, y , inf) points vector
+    const pointsReadLength = memory.get(this.pointsLengthOffset).toNumber();
+    assert(pointsReadLength % 3 === 0, 'Points vector offset should be a multiple of 3');
+    // Divide by 3 since each point is represented as a triplet to get the number of points
+    const numPoints = pointsReadLength / 3;
+    // The tag for each triplet will be (Field, Field, Uint8)
+    for (let i = 0; i < numPoints; i++) {
+      const offset = pointsOffset + i * 3;
+      // Check (Field, Field)
+      memory.checkTagsRange(TypeTag.FIELD, offset, 2);
+      // Check Uint8 (inf flag)
+      memory.checkTag(TypeTag.UINT8, offset + 2);
+    }
+    // Get the unrolled (x, y, inf) representing the points
+    const pointsVector = memory.getSlice(pointsOffset, pointsReadLength);
+
+    // The size of the scalars vector is twice the NUMBER of points because of the scalar limb decomposition
+    const scalarReadLength = numPoints * 2;
+    // Consume gas prior to performing work
+    const memoryOperations = {
+      reads: 1 + pointsReadLength + scalarReadLength /* points and scalars */,
+      writes: 3 /* output triplet */,
+      indirect: this.indirect,
+    };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    // Get the unrolled scalar (lo & hi) representing the scalars
+    const scalarsVector = memory.getSlice(scalarsOffset, scalarReadLength);
+    memory.checkTagsRange(TypeTag.FIELD, scalarsOffset, scalarReadLength);
+
+    // Now we need to reconstruct the points and scalars into something we can operate on.
+    const grumpkinPoints: Point[] = [];
+    for (let i = 0; i < numPoints; i++) {
+      const p: Point = new Point(pointsVector[3 * i].toFr(), pointsVector[3 * i + 1].toFr());
+      // Include this later when we have a standard for representing infinity
+      // const isInf = pointsVector[i + 2].toBoolean();
+
+      if (!p.isOnGrumpkin()) {
+        throw new InstructionExecutionError(`Point ${p.toString()} is not on the curve.`);
+      }
+      grumpkinPoints.push(p);
+    }
+    // The scalars are read from memory as Fr elements, which are limbs of Fq elements
+    // So we need to reconstruct them before performing the scalar multiplications
+    const scalarFqVector: Fq[] = [];
+    for (let i = 0; i < numPoints; i++) {
+      const scalarLo = scalarsVector[2 * i].toFr();
+      const scalarHi = scalarsVector[2 * i + 1].toFr();
+      const fqScalar = Fq.fromHighLow(scalarHi, scalarLo);
+      scalarFqVector.push(fqScalar);
+    }
+    // TODO: Is there an efficient MSM implementation in ts that we can replace this by?
+    const grumpkin = new Grumpkin();
+    // Zip the points and scalars into pairs
+    const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
+    // Fold the points and scalars into a single point
+    // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
+    const outputPoint = rest.reduce(
+      (acc, curr) => grumpkin.add(acc, grumpkin.mul(curr[0], curr[1])),
+      grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]),
+    );
+    const output = outputPoint.toFieldsWithInf().map(f => new Field(f));
+
+    memory.setSlice(outputOffset, output);
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/storage.ts

@@ -1,8 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations } from '../avm_memory_types.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
 import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -26,20 +25,14 @@ abstract class BaseStorageInstruction extends Instruction {
   ) {
     super();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>): Gas {
-    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.size);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }
 
 export class SStore extends BaseStorageInstruction {
   static readonly type: string = 'SSTORE';
   static readonly opcode = Opcode.SSTORE;
 
-  constructor(indirect: number, srcOffset: number, /*temporary*/ srcSize: number, slotOffset: number) {
-    super(indirect, srcOffset, srcSize, slotOffset);
+  constructor(indirect: number, srcOffset: number, /*temporary*/ size: number, slotOffset: number) {
+    super(indirect, srcOffset, size, slotOffset);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -52,6 +45,8 @@ export class SStore extends BaseStorageInstruction {
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+    memory.checkTag(TypeTag.FIELD, slotOffset);
+    memory.checkTagsRange(TypeTag.FIELD, srcOffset, this.size);
 
     const slot = memory.get(slotOffset).toFr();
     const data = memory.getSlice(srcOffset, this.size).map(field => field.toFr());
@@ -79,21 +74,19 @@ export class SLoad extends BaseStorageInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [aOffset, size, bOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.size, this.bOffset],
-      memory,
-    );
+    const [slotOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+    memory.checkTag(TypeTag.FIELD, slotOffset);
 
-    const slot = memory.get(aOffset);
+    const slot = memory.get(slotOffset);
 
     // Write each read value from storage into memory
-    for (let i = 0; i < size; i++) {
+    for (let i = 0; i < this.size; i++) {
       const data: Fr = await context.persistableState.readStorage(
         context.environment.storageAddress,
         new Fr(slot.toBigInt() + BigInt(i)),
       );
 
-      memory.set(bOffset + i, new Field(data));
+      memory.set(dstOffset + i, new Field(data));
     }
 
     context.machineState.incrementPc();

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,4 +1,5 @@
 import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
+import { EcAdd } from '../opcodes/ec_add.js';
 import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import type { Instruction } from '../opcodes/index.js';
 import {
@@ -52,6 +53,7 @@ import {
   Version,
   Xor,
 } from '../opcodes/index.js';
+import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
 import { BufferCursor } from './buffer_cursor.js';
 import { Opcode } from './instruction_serialization.js';
 
@@ -136,11 +138,13 @@ const INSTRUCTION_SET = () =>
     // Misc
     [DebugLog.opcode, DebugLog],
 
-    // //// Gadgets
+    // Gadgets
+    [EcAdd.opcode, EcAdd],
     [Keccak.opcode, Keccak],
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],
     [Pedersen.opcode, Pedersen],
+    [MultiScalarMul.opcode, MultiScalarMul],
     // Conversions
     [ToRadixLE.opcode, ToRadixLE],
   ]);

package/src/avm/serialization/instruction_serialization.ts

@@ -76,6 +76,8 @@ export enum Opcode {
   POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+  ECADD,
+  MSM,
   // Conversion
   TORADIXLE,
 }

package/src/client/client_execution_context.ts

@@ -2,25 +2,29 @@ import {
   type AuthWitness,
   type AztecNode,
   EncryptedL2Log,
+  EncryptedL2NoteLog,
+  Event,
+  L1EventPayload,
   L1NotePayload,
   Note,
   type NoteStatus,
-  TaggedNote,
+  TaggedLog,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
   CallContext,
-  FunctionData,
   FunctionSelector,
   type Header,
+  type KeyValidationRequest,
   PrivateContextInputs,
   PublicCallRequest,
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
-import { computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
+import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { type FunctionAbi, type FunctionArtifact, 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';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
@@ -28,7 +32,7 @@ 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 { CountedLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { CountedLog, CountedNoteLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -56,7 +60,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
   private nullifiedNoteHashCounters: Map<number, number> = new Map();
-  private noteEncryptedLogs: CountedLog<EncryptedL2Log>[] = [];
+  private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
@@ -136,33 +140,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.noteEncryptedLogs;
   }
 
-  /**
-   * Sometimes notes can be chopped after a nested execution is complete.
-   * This means finished nested executions still hold transient logs. This method removes them.
-   * TODO(Miranda): is there a cleaner solution?
-   */
-  public chopNoteEncryptedLogs() {
-    // Do not return logs that have been chopped in the cache
-    const allNoteLogs = this.noteCache.getLogs();
-    this.noteEncryptedLogs = this.noteEncryptedLogs.filter(l => allNoteLogs.includes(l));
-    const chop = (thing: any) =>
-      thing.nestedExecutions.forEach((result: ExecutionResult) => {
-        if (!result.noteEncryptedLogs[0]?.isEmpty()) {
-          // The execution has note logs
-          result.noteEncryptedLogs = result.noteEncryptedLogs.filter(l => allNoteLogs.includes(l));
-        }
-        chop(result);
-      });
-    chop(this);
-  }
-
-  /**
-   * Return the note encrypted logs emitted during this execution and nested executions.
-   */
-  public getAllNoteEncryptedLogs() {
-    return this.noteCache.getLogs();
-  }
-
   /**
    * Return the encrypted logs emitted during this execution.
    */
@@ -355,24 +332,64 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Emit encrypted data
-   * @param encryptedNote - The encrypted data.
+   * @param contractAddress - The contract emitting the encrypted event.
+   * @param randomness - A value used to mask the contract address we are siloing with.
+   * @param encryptedEvent - The encrypted event data.
    * @param counter - The effects counter.
    */
-  public override emitEncryptedLog(encryptedData: Buffer, counter: number) {
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedData), counter);
+  public override emitEncryptedEventLog(
+    contractAddress: AztecAddress,
+    randomness: Fr,
+    encryptedEvent: Buffer,
+    counter: number,
+  ) {
+    // In some cases, we actually want to reveal the contract address we are siloing with:
+    // e.g. 'handshaking' contract w/ known address
+    // An app providing randomness = 0 signals to not mask the address.
+    const maskedContractAddress = randomness.isZero()
+      ? contractAddress.toField()
+      : pedersenHash([contractAddress, randomness], 0);
+    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedEvent, maskedContractAddress), counter);
     this.encryptedLogs.push(encryptedLog);
   }
 
   /**
    * Emit encrypted note data
-   * @param noteHash - The note hash.
+   * @param noteHashCounter - The note hash counter.
    * @param encryptedNote - The encrypted note data.
-   * @param counter - The effects counter.
+   * @param counter - The log counter.
    */
-  public override emitEncryptedNoteLog(noteHash: Fr, encryptedNote: Buffer, counter: number) {
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedNote), counter);
+  public override emitEncryptedNoteLog(noteHashCounter: number, encryptedNote: Buffer, counter: number) {
+    const encryptedLog = new CountedNoteLog(new EncryptedL2NoteLog(encryptedNote), counter, noteHashCounter);
     this.noteEncryptedLogs.push(encryptedLog);
-    this.noteCache.addNewLog(encryptedLog, noteHash);
+  }
+
+  /**
+   * Encrypt an event
+   * @param contractAddress - The contract emitting the encrypted event.
+   * @param randomness - A value used to mask the contract address we are siloing with.
+   * @param eventTypeId - The type ID of the event (function selector).
+   * @param ovKeys - The outgoing viewing keys to use to encrypt.
+   * @param ivpkM - The master incoming viewing public key.
+   * @param preimage - The event preimage.
+   */
+  public override computeEncryptedEventLog(
+    contractAddress: AztecAddress,
+    randomness: Fr,
+    eventTypeId: Fr,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
+    preimage: Fr[],
+  ) {
+    const event = new Event(preimage);
+    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, eventTypeId);
+    const taggedEvent = new TaggedLog(l1EventPayload);
+
+    const ephSk = GrumpkinScalar.random();
+
+    const recipient = AztecAddress.random();
+
+    return taggedEvent.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
   /**
@@ -380,27 +397,30 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param contractAddress - The contract address of the note.
    * @param storageSlot - The storage slot the note is at.
    * @param noteTypeId - The type ID of the note.
-   * @param ivpk - The master incoming viewing public key.
+   * @param ovKeys - The outgoing viewing keys to use to encrypt.
+   * @param ivpkM - The master incoming viewing public key.
    * @param preimage - The note preimage.
    */
-  public override computeEncryptedLog(
+  public override computeEncryptedNoteLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
     noteTypeId: Fr,
-    ivpk: Point,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
     preimage: Fr[],
   ) {
     const note = new Note(preimage);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
-    const taggedNote = new TaggedNote(l1NotePayload);
+    const taggedNote = new TaggedLog(l1NotePayload);
 
     const ephSk = GrumpkinScalar.random();
 
-    // @todo Issue(#6410) Right now we are completely ignoring the outgoing log. Just drawing random data.
-    const ovsk = GrumpkinScalar.random();
+    // @todo This should be populated properly.
+    // Note that this encryption function SHOULD not be used, but is currently used
+    // as oracle for encrypted event logs.
     const recipient = AztecAddress.random();
 
-    return taggedNote.encrypt(ephSk, recipient, ivpk, ovsk);
+    return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
   /**
@@ -468,7 +488,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall = isStaticCall || this.callContext.isStaticCall;
 
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
-    const targetFunctionData = FunctionData.fromAbi(targetArtifact);
 
     const derivedTxContext = this.txContext.clone();
 
@@ -498,7 +517,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       context,
       targetArtifact,
       targetContractAddress,
-      targetFunctionData,
+      functionSelector,
     );
 
     if (isStaticCall) {
@@ -552,7 +571,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       args,
       callContext: derivedCallContext,
       parentCallContext: this.callContext,
-      functionData: FunctionData.fromAbi(targetArtifact),
+      functionSelector,
       contractAddress: targetContractAddress,
     });
   }
@@ -657,20 +676,13 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
   public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
-    // TODO(#4320): This is a hack to work around not having directly access to the public data tree but
-    // still having access to the witnesses
-    const bn = await this.db.getBlockNumber();
-
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const leafSlot = computePublicDataTreeLeafSlot(this.callContext.storageContractAddress, storageSlot);
-      const witness = await this.db.getPublicDataTreeWitness(bn, leafSlot);
-      if (!witness) {
-        throw new Error(`No witness for slot ${storageSlot.toString()}`);
-      }
-      const value = witness.leafPreimage.value;
+
+      const value = await this.aztecNode.getPublicStorageAt(this.callContext.storageContractAddress, storageSlot);
       this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+
       values.push(value);
     }
     return values;
@@ -684,4 +696,8 @@ export class ClientExecutionContext extends ViewDataOracle {
   public override debugLog(message: string, fields: Fr[]) {
     this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
   }
+
+  public getDebugFunctionName() {
+    return this.db.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+  }
 }

package/src/client/db_oracle.ts

@@ -12,7 +12,7 @@ import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData } from '../acvm/index.js';
-import { type CommitmentsDB } from '../public/db.js';
+import { type CommitmentsDB } from '../public/db_interfaces.js';
 
 /**
  * Error thrown when a contract is not found in the database.
@@ -95,6 +95,13 @@ export interface DBOracle extends CommitmentsDB {
    */
   getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
 
+  /**
+   * Generates a stable function name for debug purposes.
+   * @param contractAddress - The contract address.
+   * @param selector - The corresponding function selector.
+   */
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
+
   /**
    * Retrieves the artifact of a specified function within a given contract.
    * The function is identified by its name, which is unique within a contract.

package/src/client/execution_note_cache.ts

@@ -1,10 +1,8 @@
-import { type EncryptedL2Log } from '@aztec/circuit-types';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
-import { type CountedLog } from './execution_result.js';
 
 export interface PendingNote {
   note: NoteData;
@@ -29,13 +27,6 @@ export class ExecutionNoteCache {
    */
   private nullifiers: Map<bigint, Set<bigint>> = new Map();
 
-  /**
-   * The list of encrypted logs linked to note hashes created in this transaction.
-   * This mapping maps from inner note hash to log(s) emitted for that note hash.
-   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
-   */
-  private logs: Map<bigint, CountedLog<EncryptedL2Log>[]> = new Map();
-
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -46,16 +37,6 @@ export class ExecutionNoteCache {
     this.newNotes.set(note.contractAddress.toBigInt(), notes);
   }
 
-  /**
-   * Add a new note to cache.
-   * @param note - New note created during execution.
-   */
-  public addNewLog(log: CountedLog<EncryptedL2Log>, innerNoteHash: Fr) {
-    const logs = this.logs.get(innerNoteHash.toBigInt()) ?? [];
-    logs.push(log);
-    this.logs.set(innerNoteHash.toBigInt(), logs);
-  }
-
   /**
    * Add a nullifier to cache. It could be for a db note or a new note created during execution.
    * @param contractAddress - Contract address of the note.
@@ -81,8 +62,6 @@ export class ExecutionNoteCache {
       const note = notes.splice(noteIndexToRemove, 1)[0];
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
-      // If a log linked to the note hash does not exist, this method just does nothing
-      this.logs.delete(innerNoteHash.toBigInt());
     }
 
     return nullifiedNoteHashCounter;
@@ -117,11 +96,4 @@ export class ExecutionNoteCache {
   public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
     return this.nullifiers.get(contractAddress.toBigInt()) ?? new Set();
   }
-
-  /**
-   * Return all note logs emitted from a contract.
-   */
-  public getLogs(): CountedLog<EncryptedL2Log>[] {
-    return Array.from(this.logs.values()).flat();
-  }
 }