@aztec/simulator 0.65.1 → 0.66.0

package/src/avm/avm_tree.ts

@@ -17,7 +17,14 @@ import cloneDeep from 'lodash.clonedeep';
 type PreimageWitness<T extends IndexedTreeLeafPreimage> = {
   preimage: T;
   index: bigint;
-  update: boolean;
+};
+
+/**
+ * The result of fetching a leaf from an indexed tree. Contains the preimage and wether the leaf was already present
+ * or it's a low leaf.
+ */
+type GetLeafResult<T extends IndexedTreeLeafPreimage> = PreimageWitness<T> & {
+  alreadyPresent: boolean;
 };
 
 /**
@@ -29,16 +36,30 @@ type LeafWitness<T extends IndexedTreeLeafPreimage> = PreimageWitness<T> & {
 };
 
 /**
- * The result of an indexed insertion in an indexed merkle tree.
+ * The result of an update in an indexed merkle tree (no new leaf inserted)
+ */
+type IndexedUpdateResult<T extends IndexedTreeLeafPreimage> = {
+  element: T;
+  lowWitness: LeafWitness<T>;
+};
+
+/**
+ * The result of an insertion in an indexed merkle tree.
  * This will be used to hint the circuit
  */
-export type IndexedInsertionResult<T extends IndexedTreeLeafPreimage> = {
+export type IndexedInsertResult<T extends IndexedTreeLeafPreimage> = IndexedUpdateResult<T> & {
   leafIndex: bigint;
   insertionPath: Fr[];
-  newOrElementToUpdate: { update: boolean; element: T };
-  lowWitness: LeafWitness<T>;
 };
 
+/**
+ * The result of an indexed upsert in an indexed merkle tree.
+ * This will be used to hint the circuit
+ */
+export type IndexedUpsertResult<T extends IndexedTreeLeafPreimage> =
+  | (IndexedUpdateResult<T> & { update: true })
+  | (IndexedInsertResult<T> & { update: false });
+
 /****************************************************/
 /****** The AvmEphemeralForest Class ****************/
 /****************************************************/
@@ -144,7 +165,7 @@ export class AvmEphemeralForest {
    * @param newValue - The value to be written or updated to
    * @returns The insertion result which contains the insertion path, low leaf and the new leaf index
    */
-  async writePublicStorage(slot: Fr, newValue: Fr): Promise<IndexedInsertionResult<PublicDataTreeLeafPreimage>> {
+  async writePublicStorage(slot: Fr, newValue: Fr): Promise<IndexedUpsertResult<PublicDataTreeLeafPreimage>> {
     // This only works for the public data tree
     const treeId = MerkleTreeId.PUBLIC_DATA_TREE;
     const tree = this.treeMap.get(treeId)!;
@@ -152,12 +173,12 @@ export class AvmEphemeralForest {
       typeof treeId,
       PublicDataTreeLeafPreimage
     >(treeId, slot);
-    const { preimage, index, update } = leafOrLowLeafInfo;
-    const siblingPath = await this.getSiblingPath(treeId, index);
+    const { preimage, index: lowLeafIndex, alreadyPresent: update } = leafOrLowLeafInfo;
+    const siblingPath = await this.getSiblingPath(treeId, lowLeafIndex);
 
     if (pathAbsentInEphemeralTree) {
       // Since we have never seen this before - we should insert it into our tree as it is about to be updated.
-      this.treeMap.get(treeId)!.insertSiblingPath(index, siblingPath);
+      this.treeMap.get(treeId)!.insertSiblingPath(lowLeafIndex, siblingPath);
     }
 
     if (update) {
@@ -165,29 +186,18 @@ export class AvmEphemeralForest {
       const existingPublicDataSiblingPath = siblingPath;
       updatedPreimage.value = newValue;
 
-      // It is really unintuitive that by updating, we are also appending a Zero Leaf to the tree
-      // Additionally, this leaf preimage does not seem to factor into further appends
-      const emptyLeaf = new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
-      const insertionIndex = tree.leafCount;
-      tree.updateLeaf(this.hashPreimage(updatedPreimage), index);
-      tree.appendLeaf(Fr.ZERO);
-      this.setIndexedUpdates(treeId, index, updatedPreimage);
-      this.setIndexedUpdates(treeId, insertionIndex, emptyLeaf);
-      const insertionPath = tree.getSiblingPath(insertionIndex)!;
-
-      // Even though we append an empty leaf into the tree as a part of update - it doesnt seem to impact future inserts...
-      this._updateSortedKeys(treeId, [updatedPreimage.slot], [index]);
+      tree.updateLeaf(this.hashPreimage(updatedPreimage), lowLeafIndex);
+      this.setIndexedUpdates(treeId, lowLeafIndex, updatedPreimage);
+      this._updateSortedKeys(treeId, [updatedPreimage.slot], [lowLeafIndex]);
 
       return {
-        leafIndex: insertionIndex,
-        insertionPath,
-        newOrElementToUpdate: { update: true, element: updatedPreimage },
+        element: updatedPreimage,
         lowWitness: {
           preimage: preimage,
-          index: index,
-          update: true,
+          index: lowLeafIndex,
           siblingPath: existingPublicDataSiblingPath,
         },
+        update: true,
       };
     }
     // We are writing to a new slot, so our preimage is a lowNullifier
@@ -202,22 +212,22 @@ export class AvmEphemeralForest {
       new Fr(preimage.getNextKey()),
       preimage.getNextIndex(),
     );
-    const insertionPath = this.appendIndexedTree(treeId, index, updatedLowLeaf, newPublicDataLeaf);
+    const insertionPath = this.appendIndexedTree(treeId, lowLeafIndex, updatedLowLeaf, newPublicDataLeaf);
 
     // Even though the low leaf key is not updated, we still need to update the sorted keys in case we have
     // not seen the low leaf before
-    this._updateSortedKeys(treeId, [newPublicDataLeaf.slot, updatedLowLeaf.slot], [insertionIndex, index]);
+    this._updateSortedKeys(treeId, [newPublicDataLeaf.slot, updatedLowLeaf.slot], [insertionIndex, lowLeafIndex]);
 
     return {
-      leafIndex: insertionIndex,
-      insertionPath: insertionPath,
-      newOrElementToUpdate: { update: false, element: newPublicDataLeaf },
+      element: newPublicDataLeaf,
       lowWitness: {
         preimage,
-        index: index,
-        update: false,
+        index: lowLeafIndex,
         siblingPath,
       },
+      update: false,
+      leafIndex: insertionIndex,
+      insertionPath: insertionPath,
     };
   }
 
@@ -247,14 +257,14 @@ export class AvmEphemeralForest {
    * @param value - The nullifier to be appended
    * @returns The insertion result which contains the insertion path, low leaf and the new leaf index
    */
-  async appendNullifier(nullifier: Fr): Promise<IndexedInsertionResult<NullifierLeafPreimage>> {
+  async appendNullifier(nullifier: Fr): Promise<IndexedInsertResult<NullifierLeafPreimage>> {
     const treeId = MerkleTreeId.NULLIFIER_TREE;
     const tree = this.treeMap.get(treeId)!;
     const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._getLeafOrLowLeafInfo<
       typeof treeId,
       NullifierLeafPreimage
     >(treeId, nullifier);
-    const { preimage, index, update } = leafOrLowLeafInfo;
+    const { preimage, index, alreadyPresent } = leafOrLowLeafInfo;
     const siblingPath = await this.getSiblingPath(treeId, index);
 
     if (pathAbsentInEphemeralTree) {
@@ -262,7 +272,7 @@ export class AvmEphemeralForest {
       this.treeMap.get(treeId)!.insertSiblingPath(index, siblingPath);
     }
 
-    assert(!update, 'Nullifier already exists in the tree. Cannot update a nullifier!');
+    assert(!alreadyPresent, 'Nullifier already exists in the tree. Cannot update a nullifier!');
 
     // We are writing a new entry
     const insertionIndex = tree.leafCount;
@@ -282,15 +292,14 @@ export class AvmEphemeralForest {
     );
 
     return {
-      leafIndex: insertionIndex,
-      insertionPath: insertionPath,
-      newOrElementToUpdate: { update: false, element: newNullifierLeaf },
+      element: newNullifierLeaf,
       lowWitness: {
         preimage,
         index,
-        update,
         siblingPath,
       },
+      leafIndex: insertionIndex,
+      insertionPath: insertionPath,
     };
   }
 
@@ -360,7 +369,7 @@ export class AvmEphemeralForest {
   async getLeafOrLowLeafInfo<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
     treeId: ID,
     key: Fr,
-  ): Promise<PreimageWitness<T>> {
+  ): Promise<GetLeafResult<T>> {
     const [leafOrLowLeafInfo, _] = await this._getLeafOrLowLeafInfo<ID, T>(treeId, key);
     return leafOrLowLeafInfo;
   }
@@ -373,14 +382,14 @@ export class AvmEphemeralForest {
    * @param key - The key for which we are look up the leaf or low leaf for.
    * @param T - The type of the preimage (PublicData or Nullifier)
    * @returns [
-   *     preimageWitness - The leaf or low leaf info (preimage & leaf index),
+   *     getLeafResult - The leaf or low leaf info (preimage & leaf index),
    *     pathAbsentInEphemeralTree - whether its sibling path is absent in the ephemeral tree (useful during insertions)
    * ]
    */
   async _getLeafOrLowLeafInfo<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
     treeId: ID,
     key: Fr,
-  ): Promise<[PreimageWitness<T>, /*pathAbsentInEphemeralTree=*/ boolean]> {
+  ): Promise<[GetLeafResult<T>, /*pathAbsentInEphemeralTree=*/ boolean]> {
     const bigIntKey = key.toBigInt();
     // In this function, "min" refers to the leaf with the
     // largest key <= the specified key in the indexedUpdates.
@@ -392,7 +401,7 @@ export class AvmEphemeralForest {
     if (minIndexedLeafIndex === -1n) {
       // No leaf is present in the indexed updates that is <= the key,
       // so retrieve the leaf or low leaf from the underlying DB.
-      const leafOrLowLeafPreimage: PreimageWitness<T> = await this._getLeafOrLowLeafWitnessInExternalDb(
+      const leafOrLowLeafPreimage: GetLeafResult<T> = await this._getLeafOrLowLeafWitnessInExternalDb(
         treeId,
         bigIntKey,
       );
@@ -402,7 +411,7 @@ export class AvmEphemeralForest {
       const minPreimage: T = this.getIndexedUpdate(treeId, minIndexedLeafIndex);
       if (minPreimage.getKey() === bigIntKey) {
         // the index found is an exact match, no need to search further
-        const leafInfo = { preimage: minPreimage, index: minIndexedLeafIndex, update: true };
+        const leafInfo = { preimage: minPreimage, index: minIndexedLeafIndex, alreadyPresent: true };
         return [leafInfo, /*pathAbsentInEphemeralTree=*/ false];
       } else {
         // We are starting with the leaf with largest key <= the specified key
@@ -453,7 +462,7 @@ export class AvmEphemeralForest {
   private async _getLeafOrLowLeafWitnessInExternalDb<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
     treeId: ID,
     key: bigint,
-  ): Promise<PreimageWitness<T>> {
+  ): Promise<GetLeafResult<T>> {
     // "key" is siloed slot (leafSlot) or siloed nullifier
     const previousValueIndex = await this.treeDb.getPreviousValueIndex(treeId, key);
     assert(
@@ -468,7 +477,7 @@ export class AvmEphemeralForest {
       `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`,
     );
 
-    return { preimage: leafPreimage as T, index: leafIndex, update: alreadyPresent };
+    return { preimage: leafPreimage as T, index: leafIndex, alreadyPresent };
   }
 
   /**
@@ -481,7 +490,7 @@ export class AvmEphemeralForest {
    * @param minIndex - The index of the leaf with the largest key <= the specified key.
    * @param T - The type of the preimage (PublicData or Nullifier)
    * @returns [
-   *     preimageWitness | undefined - The leaf or low leaf info (preimage & leaf index),
+   *     GetLeafResult | undefined - The leaf or low leaf info (preimage & leaf index),
    *     pathAbsentInEphemeralTree - whether its sibling path is absent in the ephemeral tree (useful during insertions)
    * ]
    *
@@ -497,10 +506,10 @@ export class AvmEphemeralForest {
     key: bigint,
     minPreimage: T,
     minIndex: bigint,
-  ): Promise<[PreimageWitness<T> | undefined, /*pathAbsentInEphemeralTree=*/ boolean]> {
+  ): Promise<[GetLeafResult<T> | undefined, /*pathAbsentInEphemeralTree=*/ boolean]> {
     let found = false;
     let curr = minPreimage as T;
-    let result: PreimageWitness<T> | undefined = undefined;
+    let result: GetLeafResult<T> | undefined = undefined;
     // Temp to avoid infinite loops - the limit is the number of leaves we may have to read
     const LIMIT = 2n ** BigInt(getTreeHeight(treeId)) - 1n;
     let counter = 0n;
@@ -511,11 +520,11 @@ export class AvmEphemeralForest {
       if (curr.getKey() === bigIntKey) {
         // We found an exact match - therefore this is an update
         found = true;
-        result = { preimage: curr, index: lowPublicDataIndex, update: true };
+        result = { preimage: curr, index: lowPublicDataIndex, alreadyPresent: true };
       } else if (curr.getKey() < bigIntKey && (curr.getNextIndex() === 0n || curr.getNextKey() > bigIntKey)) {
         // We found it via sandwich or max condition, this is a low nullifier
         found = true;
-        result = { preimage: curr, index: lowPublicDataIndex, update: false };
+        result = { preimage: curr, index: lowPublicDataIndex, alreadyPresent: false };
       }
       // Update the the values for the next iteration
       else {
@@ -671,7 +680,12 @@ export class EphemeralAvmTree {
     for (let i = 0; i < siblingPath.length; i++) {
       // Flip(XOR) the last bit because we are inserting siblings of the leaf
       const sibIndex = index ^ 1n;
-      this.updateLeaf(siblingPath[i], sibIndex, this.depth - i);
+      const node = this.getNode(sibIndex, this.depth - i);
+      // If we are inserting a sibling path and we already have a branch at that index in our
+      // ephemeral tree, we should not overwrite it
+      if (node === undefined || node.tag === TreeType.LEAF) {
+        this.updateLeaf(siblingPath[i], sibIndex, this.depth - i);
+      }
       index >>= 1n;
     }
   }

package/src/avm/journal/journal.ts

@@ -163,8 +163,12 @@ export class AvmPersistableStateManager {
       const lowLeafIndex = lowLeafInfo.index;
       const lowLeafPath = lowLeafInfo.siblingPath;
 
-      const insertionPath = result.insertionPath;
-      const newLeafPreimage = result.newOrElementToUpdate.element as PublicDataTreeLeafPreimage;
+      const newLeafPreimage = result.element as PublicDataTreeLeafPreimage;
+      let insertionPath;
+
+      if (!result.update) {
+        insertionPath = result.insertionPath;
+      }
 
       this.trace.tracePublicStorageWrite(
         contractAddress,
@@ -200,7 +204,7 @@ export class AvmPersistableStateManager {
       const {
         preimage,
         index: leafIndex,
-        update: exists,
+        alreadyPresent,
       } = await this.merkleTrees.getLeafOrLowLeafInfo(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
       // The index and preimage here is either the low leaf or the leaf itself (depending on the value of update flag)
       // In either case, we just want the sibling path to this leaf - it's up to the avm to distinguish if it's a low leaf or not
@@ -212,7 +216,7 @@ export class AvmPersistableStateManager {
       );
       this.log.debug(`leafPreimage.slot: ${leafPreimage.slot}, leafPreimage.value: ${leafPreimage.value}`);
 
-      if (!exists) {
+      if (!alreadyPresent) {
         // Sanity check that the leaf slot is skipped by low leaf when it doesn't exist
         assert(
           leafPreimage.slot.toBigInt() < leafSlot.toBigInt() &&
@@ -308,12 +312,15 @@ export class AvmPersistableStateManager {
       const {
         preimage,
         index: leafIndex,
-        update,
+        alreadyPresent,
       } = await this.merkleTrees.getLeafOrLowLeafInfo(MerkleTreeId.NULLIFIER_TREE, siloedNullifier);
       const leafPreimage = preimage as NullifierLeafPreimage;
       const leafPath = await this.merkleTrees.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, leafIndex);
 
-      assert(update == exists, 'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!');
+      assert(
+        alreadyPresent == exists,
+        'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!',
+      );
 
       if (exists) {
         this.log.debug(`Siloed nullifier ${siloedNullifier} exists at leafIndex=${leafIndex}`);
@@ -355,11 +362,11 @@ export class AvmPersistableStateManager {
       // Maybe overkill, but we should check if the nullifier is already present in the tree before attempting to insert
       // It might be better to catch the error from the insert operation
       // Trace all nullifier creations, even duplicate insertions that fail
-      const { preimage, index, update } = await this.merkleTrees.getLeafOrLowLeafInfo(
+      const { preimage, index, alreadyPresent } = await this.merkleTrees.getLeafOrLowLeafInfo(
         MerkleTreeId.NULLIFIER_TREE,
         siloedNullifier,
       );
-      if (update) {
+      if (alreadyPresent) {
         this.log.verbose(`Siloed nullifier ${siloedNullifier} already present in tree at index ${index}!`);
         // If the nullifier is already present, we should not insert it again
         // instead we provide the direct membership path
@@ -367,7 +374,7 @@ export class AvmPersistableStateManager {
         // This just becomes a nullifier read hint
         this.trace.traceNullifierCheck(
           siloedNullifier,
-          /*exists=*/ update,
+          /*exists=*/ alreadyPresent,
           preimage as NullifierLeafPreimage,
           new Fr(index),
           path,
@@ -379,6 +386,11 @@ export class AvmPersistableStateManager {
         // Cache pending nullifiers for later access
         await this.nullifiers.append(siloedNullifier);
         // We append the new nullifier
+        this.log.debug(
+          `Nullifier tree root before insertion ${this.merkleTrees.treeMap
+            .get(MerkleTreeId.NULLIFIER_TREE)!
+            .getRoot()}`,
+        );
         const appendResult = await this.merkleTrees.appendNullifier(siloedNullifier);
         this.log.debug(
           `Nullifier tree root after insertion ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,

package/src/avm/opcodes/environment_getters.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, Uint32, Uint64 } from '../avm_memory_types.js';
+import { Field, Uint64 } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -8,7 +8,6 @@ import { Instruction } from './instruction.js';
 export enum EnvironmentVariable {
   ADDRESS,
   SENDER,
-  FUNCTIONSELECTOR,
   TRANSACTIONFEE,
   CHAINID,
   VERSION,
@@ -27,8 +26,6 @@ function getValue(e: EnvironmentVariable, ctx: AvmContext) {
       return new Field(ctx.environment.address.toField());
     case EnvironmentVariable.SENDER:
       return new Field(ctx.environment.sender.toField());
-    case EnvironmentVariable.FUNCTIONSELECTOR:
-      return new Uint32(ctx.environment.functionSelector.value);
     case EnvironmentVariable.TRANSACTIONFEE:
       return new Field(ctx.environment.transactionFee);
     case EnvironmentVariable.CHAINID:

package/src/client/client_execution_context.ts

@@ -1,11 +1,8 @@
 import {
   type AuthWitness,
   type AztecNode,
-  CountedLog,
-  CountedNoteLog,
+  CountedContractClassLog,
   CountedPublicExecutionRequest,
-  EncryptedL2Log,
-  EncryptedL2NoteLog,
   Note,
   NoteAndSlot,
   type NoteStatus,
@@ -25,7 +22,6 @@ import {
 import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { type FunctionAbi, type FunctionArtifact, type NoteSelector, countArgumentsSize } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
@@ -60,9 +56,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
   private noteHashNullifierCounterMap: Map<number, number> = new Map();
-  private noteEncryptedLogs: CountedNoteLog[] = [];
-  private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
-  private contractClassLogs: CountedLog<UnencryptedL2Log>[] = [];
+  private contractClassLogs: CountedContractClassLog[] = [];
   private nestedExecutions: PrivateExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[] = [];
   private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
@@ -136,20 +130,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.noteHashNullifierCounterMap;
   }
 
-  /**
-   * Return the note encrypted logs emitted during this execution.
-   */
-  public getNoteEncryptedLogs() {
-    return this.noteEncryptedLogs;
-  }
-
-  /**
-   * Return the encrypted logs emitted during this execution.
-   */
-  public getEncryptedLogs() {
-    return this.encryptedLogs;
-  }
-
   /**
    * Return the contract class logs emitted during this execution.
    */
@@ -326,49 +306,15 @@ export class ClientExecutionContext extends ViewDataOracle {
     return Promise.resolve();
   }
 
-  /**
-   * Emit 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 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()
-      : poseidon2HashWithSeparator([contractAddress, randomness], 0);
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedEvent, maskedContractAddress), counter);
-    this.encryptedLogs.push(encryptedLog);
-  }
-
-  /**
-   * Emit encrypted note data
-   * @param noteHashCounter - The note hash counter.
-   * @param encryptedNote - The encrypted note data.
-   * @param counter - The log counter.
-   */
-  public override emitEncryptedNoteLog(noteHashCounter: number, encryptedNote: Buffer, counter: number) {
-    const encryptedLog = new CountedNoteLog(new EncryptedL2NoteLog(encryptedNote), counter, noteHashCounter);
-    this.noteEncryptedLogs.push(encryptedLog);
-  }
-
   /**
    * Emit a contract class unencrypted log.
-   * This fn exists separately from emitUnencryptedLog because sha hashing the preimage
+   * This fn exists 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 emitContractClassLog(log: UnencryptedL2Log, counter: number) {
-    this.contractClassLogs.push(new CountedLog(log, counter));
+    this.contractClassLogs.push(new CountedContractClassLog(log, counter));
     const text = log.toHumanReadable();
     this.log.verbose(
       `Emitted log from ContractClassRegisterer: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`,
@@ -381,7 +327,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       childExecutionResult.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
       childExecutionResult.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
       childExecutionResult.publicInputs.l2ToL1Msgs.some(item => !item.isEmpty()) ||
-      childExecutionResult.publicInputs.encryptedLogsHashes.some(item => !item.isEmpty()) ||
+      childExecutionResult.publicInputs.privateLogs.some(item => !item.isEmpty()) ||
       childExecutionResult.publicInputs.contractClassLogsHashes.some(item => !item.isEmpty())
     ) {
       throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);

package/src/client/private_execution.ts

@@ -59,8 +59,6 @@ export async function executePrivateFunction(
     appCircuitName: functionName,
   } satisfies CircuitWitnessGenerationStats);
 
-  const noteEncryptedLogs = context.getNoteEncryptedLogs();
-  const encryptedLogs = context.getEncryptedLogs();
   const contractClassLogs = context.getContractClassLogs();
 
   const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
@@ -86,8 +84,6 @@ export async function executePrivateFunction(
     nestedExecutions,
     enqueuedPublicFunctionCalls,
     publicTeardownFunctionCall,
-    noteEncryptedLogs,
-    encryptedLogs,
     contractClassLogs,
   );
 }

package/src/public/enqueued_call_side_effect_trace.ts

@@ -179,15 +179,13 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.avmCircuitHints.contractInstances.items.push(...forkedTrace.avmCircuitHints.contractInstances.items);
     this.avmCircuitHints.contractBytecodeHints.items.push(...forkedTrace.avmCircuitHints.contractBytecodeHints.items);
 
-    this.avmCircuitHints.storageReadRequest.items.push(...forkedTrace.avmCircuitHints.storageReadRequest.items);
-    this.avmCircuitHints.storageUpdateRequest.items.push(...forkedTrace.avmCircuitHints.storageUpdateRequest.items);
-    this.avmCircuitHints.nullifierReadRequest.items.push(...forkedTrace.avmCircuitHints.nullifierReadRequest.items);
-    this.avmCircuitHints.nullifierWriteHints.items.push(...forkedTrace.avmCircuitHints.nullifierWriteHints.items);
-    this.avmCircuitHints.noteHashReadRequest.items.push(...forkedTrace.avmCircuitHints.noteHashReadRequest.items);
-    this.avmCircuitHints.noteHashWriteRequest.items.push(...forkedTrace.avmCircuitHints.noteHashWriteRequest.items);
-    this.avmCircuitHints.l1ToL2MessageReadRequest.items.push(
-      ...forkedTrace.avmCircuitHints.l1ToL2MessageReadRequest.items,
-    );
+    this.avmCircuitHints.publicDataReads.items.push(...forkedTrace.avmCircuitHints.publicDataReads.items);
+    this.avmCircuitHints.publicDataWrites.items.push(...forkedTrace.avmCircuitHints.publicDataWrites.items);
+    this.avmCircuitHints.nullifierReads.items.push(...forkedTrace.avmCircuitHints.nullifierReads.items);
+    this.avmCircuitHints.nullifierWrites.items.push(...forkedTrace.avmCircuitHints.nullifierWrites.items);
+    this.avmCircuitHints.noteHashReads.items.push(...forkedTrace.avmCircuitHints.noteHashReads.items);
+    this.avmCircuitHints.noteHashWrites.items.push(...forkedTrace.avmCircuitHints.noteHashWrites.items);
+    this.avmCircuitHints.l1ToL2MessageReads.items.push(...forkedTrace.avmCircuitHints.l1ToL2MessageReads.items);
   }
 
   public getCounter() {
@@ -211,7 +209,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       assert(leafPreimage.value.equals(value), 'Value mismatch when tracing in public data write');
     }
 
-    this.avmCircuitHints.storageReadRequest.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
+    this.avmCircuitHints.publicDataReads.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
     this.log.debug(`SLOAD cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
   }
@@ -245,7 +243,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
 
     // New hinting
     const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.storageUpdateRequest.items.push(
+    this.avmCircuitHints.publicDataWrites.items.push(
       new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath),
     );
 
@@ -264,7 +262,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     path: Fr[] = emptyNoteHashPath(),
   ) {
     // New Hinting
-    this.avmCircuitHints.noteHashReadRequest.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    this.avmCircuitHints.noteHashReads.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
@@ -282,7 +280,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     //const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(contractAddress));
     this.log.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
-    this.avmCircuitHints.noteHashWriteRequest.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    this.avmCircuitHints.noteHashWrites.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.incrementSideEffectCounter();
   }
 
@@ -293,7 +291,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     lowLeafIndex: Fr = Fr.zero(),
     lowLeafPath: Fr[] = emptyNullifierPath(),
   ) {
-    this.avmCircuitHints.nullifierReadRequest.items.push(
+    this.avmCircuitHints.nullifierReads.items.push(
       new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath),
     );
     this.log.debug(`NULLIFIER_EXISTS cnt: ${this.sideEffectCounter}`);
@@ -314,7 +312,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
 
     const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.nullifierWriteHints.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
+    this.avmCircuitHints.nullifierWrites.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
@@ -327,7 +325,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     _exists: boolean,
     path: Fr[] = emptyL1ToL2MessagePath(),
   ) {
-    this.avmCircuitHints.l1ToL2MessageReadRequest.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
+    this.avmCircuitHints.l1ToL2MessageReads.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
   }
 
   public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {