@aztec/simulator 0.64.0 → 0.65.1

package/src/avm/avm_tree.ts

@@ -4,6 +4,7 @@ import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type IndexedTreeLeafPreimage, type TreeLeafPreimage } from '@aztec/foundation/trees';
 
+import { strict as assert } from 'assert';
 import cloneDeep from 'lodash.clonedeep';
 
 /****************************************************/
@@ -147,11 +148,18 @@ export class AvmEphemeralForest {
     // This only works for the public data tree
     const treeId = MerkleTreeId.PUBLIC_DATA_TREE;
     const tree = this.treeMap.get(treeId)!;
-    const { preimage, index, update }: PreimageWitness<PublicDataTreeLeafPreimage> = await this.getLeafOrLowLeafInfo(
-      treeId,
-      slot,
-    );
+    const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._getLeafOrLowLeafInfo<
+      typeof treeId,
+      PublicDataTreeLeafPreimage
+    >(treeId, slot);
+    const { preimage, index, update } = leafOrLowLeafInfo;
     const siblingPath = await this.getSiblingPath(treeId, index);
+
+    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);
+    }
+
     if (update) {
       const updatedPreimage = cloneDeep(preimage);
       const existingPublicDataSiblingPath = siblingPath;
@@ -222,7 +230,7 @@ export class AvmEphemeralForest {
       if (foundIndex === -1) {
         // New element, we splice it into the correct location
         const spliceIndex =
-          this.searchForKey(
+          indexOrNextLowestInArray(
             keys[i],
             existingKeyVector.map(x => x[0]),
           ) + 1;
@@ -242,15 +250,20 @@ export class AvmEphemeralForest {
   async appendNullifier(nullifier: Fr): Promise<IndexedInsertionResult<NullifierLeafPreimage>> {
     const treeId = MerkleTreeId.NULLIFIER_TREE;
     const tree = this.treeMap.get(treeId)!;
-    const { preimage, index, update }: PreimageWitness<NullifierLeafPreimage> = await this.getLeafOrLowLeafInfo(
-      treeId,
-      nullifier,
-    );
+    const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._getLeafOrLowLeafInfo<
+      typeof treeId,
+      NullifierLeafPreimage
+    >(treeId, nullifier);
+    const { preimage, index, update } = leafOrLowLeafInfo;
     const siblingPath = await this.getSiblingPath(treeId, index);
 
-    if (update) {
-      throw new Error('Not allowed to update a nullifier');
+    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);
     }
+
+    assert(!update, 'Nullifier already exists in the tree. Cannot update a nullifier!');
+
     // We are writing a new entry
     const insertionIndex = tree.leafCount;
     const updatedLowNullifier = cloneDeep(preimage);
@@ -311,17 +324,17 @@ export class AvmEphemeralForest {
   }
 
   /**
-   * This is wrapper around treeId to get values in the indexedUpdates map
+   * This is wrapper around treeId to get values in the indexedUpdates map.
+   * Should only be called if we know the value exists.
    */
-  private getIndexedUpdates<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(treeId: ID, index: bigint): T {
+  private getIndexedUpdate<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(treeId: ID, index: bigint): T {
     const updates = this.indexedUpdates.get(treeId);
-    if (updates === undefined) {
-      throw new Error('No updates found');
-    }
+    assert(updates !== undefined, `No updates exist in the ephemeral ${MerkleTreeId[treeId]} tree.`);
     const preimage = updates.get(index);
-    if (preimage === undefined) {
-      throw new Error('No updates found');
-    }
+    assert(
+      updates !== undefined,
+      `No update exists in the ephemeral ${MerkleTreeId[treeId]} tree for leafIndex ${index}.`,
+    );
     return preimage as T;
   }
 
@@ -336,93 +349,165 @@ export class AvmEphemeralForest {
     return updates.has(index);
   }
 
-  private searchForKey(key: Fr, arr: Fr[]): number {
-    // We are looking for the index of the largest element in the array that is less than the key
-    let start = 0;
-    let end = arr.length;
-    // Note that the easiest way is to increment the search key by 1 and then do a binary search
-    const searchKey = key.add(Fr.ONE);
-    while (start < end) {
-      const mid = Math.floor((start + end) / 2);
-      if (arr[mid].cmp(searchKey) < 0) {
-        // The key + 1 is greater than the arr element, so we can continue searching the top half
-        start = mid + 1;
-      } else {
-        // The key + 1 is LT or EQ the arr element, so we can continue searching the bottom half
-        end = mid;
-      }
-    }
-    // We either found key + 1 or start is now at the index of the largest element that we would have inserted key + 1
-    // Therefore start - 1 is the index of the element just below - note it can be -1 if the first element in the array is
-    // greater than the key
-    return start - 1;
-  }
-
   /**
-   * This gets the low leaf preimage and the index of the low leaf in the indexed tree given a value (slot or nullifier value)
-   * If the value is not found in the tree, it does an external lookup to the merkleDB
+   * Get the leaf or low leaf preimage and its index in the indexed tree given a key (slot or nullifier value).
+   * If the key is not found in the tree, it does an external lookup to the underlying merkle DB.
    * @param treeId - The tree we are looking up in
-   * @param key - The key for which we are look up the low leaf for.
+   * @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 The low leaf preimage and the index of the low leaf in the indexed tree
+   * @returns The leaf or low leaf info (preimage & leaf index).
    */
   async getLeafOrLowLeafInfo<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
     treeId: ID,
     key: Fr,
   ): Promise<PreimageWitness<T>> {
+    const [leafOrLowLeafInfo, _] = await this._getLeafOrLowLeafInfo<ID, T>(treeId, key);
+    return leafOrLowLeafInfo;
+  }
+
+  /**
+   * Internal helper to get the leaf or low leaf preimage and its index in the indexed tree given a key (slot or nullifier value).
+   * If the key is not found in the tree, it does an external lookup to the underlying merkle DB.
+   * Indicates whethe the sibling path is absent in the ephemeral tree.
+   * @param treeId - The tree we are looking up in
+   * @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),
+   *     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]> {
+    const bigIntKey = key.toBigInt();
+    // In this function, "min" refers to the leaf with the
+    // largest key <= the specified key in the indexedUpdates.
+    // In other words, the leaf with the "next lowest" key in indexedUpdates.
+
+    // First, search the indexed updates (no DB fallback) to find
+    // the leafIndex of the leaf with the largest key <= the specified key.
+    const minIndexedLeafIndex = this._getLeafIndexOrNextLowestInIndexedUpdates(treeId, key);
+    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(
+        treeId,
+        bigIntKey,
+      );
+      return [leafOrLowLeafPreimage, /*pathAbsentInEphemeralTree=*/ true];
+    } else {
+      // A leaf was found in the indexed updates that is <= the key
+      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 };
+        return [leafInfo, /*pathAbsentInEphemeralTree=*/ false];
+      } else {
+        // We are starting with the leaf with largest key <= the specified key
+        // Starting at that "min leaf", search for specified key in both the indexed updates
+        // and the underlying DB. If not found, return its low leaf.
+        const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._searchForLeafOrLowLeaf<ID, T>(
+          treeId,
+          bigIntKey,
+          minPreimage,
+          minIndexedLeafIndex,
+        );
+        // We did not find it - this is unexpected... the leaf OR low leaf should always be present
+        assert(leafOrLowLeafInfo !== undefined, 'Could not find leaf or low leaf. This should not happen!');
+        return [leafOrLowLeafInfo, pathAbsentInEphemeralTree];
+      }
+    }
+  }
+
+  /**
+   * Helper to search for the leaf with the specified key in the indexedUpdates
+   * and return its leafIndex.
+   * If not present, return the leafIndex of the largest leaf <= the specified key
+   * (the leafIndex of the next lowest key).
+   *
+   * If no entry exists in indexedUpdates <= the specified key, return -1.
+   * @returns - The leafIndex of the leaf with the largest key <= the specified key.
+   */
+  private _getLeafIndexOrNextLowestInIndexedUpdates<ID extends IndexedTreeId>(treeId: ID, key: Fr): bigint {
     const keyOrderedVector = this.indexedSortedKeys.get(treeId)!;
 
-    const vectorIndex = this.searchForKey(
+    const indexInVector = indexOrNextLowestInArray(
       key,
       keyOrderedVector.map(x => x[0]),
     );
-    // We have a match in our local updates
-    let minPreimage = undefined;
-
-    if (vectorIndex !== -1) {
-      const [_, leafIndex] = keyOrderedVector[vectorIndex];
-      minPreimage = {
-        preimage: this.getIndexedUpdates(treeId, leafIndex) as T,
-        index: leafIndex,
-      };
-    }
-    // This can probably be done better, we want to say if the minInfo is undefined (because this is our first operation) we do the external lookup
-    const start = minPreimage?.preimage;
-    const bigIntKey = key.toBigInt();
 
-    // If we don't have a first element or if that first element is already greater than the target key, we need to do an external lookup
-    // The low public data witness is in the previous tree
-    if (start === undefined || start.getKey() > key.toBigInt()) {
-      // This function returns the leaf index to the actual element if it exists or the leaf index to the low leaf otherwise
-      const { index, alreadyPresent } = (await this.treeDb.getPreviousValueIndex(treeId, bigIntKey))!;
-      const preimage = await this.treeDb.getLeafPreimage(treeId, index);
-
-      // Since we have never seen this before - we should insert it into our tree, as we know we will modify this leaf node
-      const siblingPath = await this.getSiblingPath(treeId, index);
-      // const siblingPath = (await this.treeDb.getSiblingPath(treeId, index)).toFields();
+    if (indexInVector !== -1) {
+      const [_, leafIndex] = keyOrderedVector[indexInVector];
+      return leafIndex;
+    } else {
+      // no leaf <= the specified key was found
+      return -1n;
+    }
+  }
 
-      // Is it enough to just insert the sibling path without inserting the leaf? - now probably since we will update this low nullifier index in append
-      this.treeMap.get(treeId)!.insertSiblingPath(index, siblingPath);
+  /**
+   * Query the external DB to get leaf if present, low leaf if absent
+   */
+  private async _getLeafOrLowLeafWitnessInExternalDb<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
+    treeId: ID,
+    key: bigint,
+  ): Promise<PreimageWitness<T>> {
+    // "key" is siloed slot (leafSlot) or siloed nullifier
+    const previousValueIndex = await this.treeDb.getPreviousValueIndex(treeId, key);
+    assert(
+      previousValueIndex !== undefined,
+      `${MerkleTreeId[treeId]} low leaf index should always be found (even if target leaf does not exist)`,
+    );
+    const { index: leafIndex, alreadyPresent } = previousValueIndex;
 
-      const lowPublicDataPreimage = preimage as T;
+    const leafPreimage = await this.treeDb.getLeafPreimage(treeId, leafIndex);
+    assert(
+      leafPreimage !== undefined,
+      `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`,
+    );
 
-      return { preimage: lowPublicDataPreimage, index: index, update: alreadyPresent };
-    }
+    return { preimage: leafPreimage as T, index: leafIndex, update: alreadyPresent };
+  }
 
-    // We look for the low element by bouncing between our local indexedUpdates map or the external DB
-    // The conditions we are looking for are:
-    // (1) Exact Match: curr.nextKey == key (this is only valid for public data tree)
-    // (2) Sandwich Match: curr.nextKey > key and curr.key < key
-    // (3) Max Condition: curr.next_index == 0 and curr.key < key
-    // Note the min condition does not need to be handled since indexed trees are prefilled with at least the 0 element
+  /**
+   * Search for the leaf for the specified key.
+   * Some leaf with key <= the specified key is expected to be present in the ephemeral tree's "indexed updates".
+   * While searching, this function bounces between our local indexedUpdates and the external DB.
+   *
+   * @param key - The key for which we are look up the leaf or low leaf for.
+   * @param minPreimage - The leaf with the largest key <= the specified key. Expected to be present in local indexedUpdates.
+   * @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),
+   *     pathAbsentInEphemeralTree - whether its sibling path is absent in the ephemeral tree (useful during insertions)
+   * ]
+   *
+   * @details We look for the low element by bouncing between our local indexedUpdates map or the external DB
+   * The conditions we are looking for are:
+   * (1) Exact Match: curr.nextKey == key (this is only valid for public data tree)
+   * (2) Sandwich Match: curr.nextKey > key and curr.key < key
+   * (3) Max Condition: curr.next_index == 0 and curr.key < key
+   * Note the min condition does not need to be handled since indexed trees are prefilled with at least the 0 element
+   */
+  private async _searchForLeafOrLowLeaf<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
+    treeId: ID,
+    key: bigint,
+    minPreimage: T,
+    minIndex: bigint,
+  ): Promise<[PreimageWitness<T> | undefined, /*pathAbsentInEphemeralTree=*/ boolean]> {
     let found = false;
-    let curr = minPreimage!.preimage as T;
+    let curr = minPreimage as T;
     let result: PreimageWitness<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;
-    let lowPublicDataIndex = minPreimage!.index;
+    let lowPublicDataIndex = minIndex;
+    let pathAbsentInEphemeralTree = false;
     while (!found && counter < LIMIT) {
+      const bigIntKey = key;
       if (curr.getKey() === bigIntKey) {
         // We found an exact match - therefore this is an update
         found = true;
@@ -436,30 +521,23 @@ export class AvmEphemeralForest {
       else {
         lowPublicDataIndex = curr.getNextIndex();
         if (this.hasLocalUpdates(treeId, lowPublicDataIndex)) {
-          curr = this.getIndexedUpdates(treeId, lowPublicDataIndex)!;
+          curr = this.getIndexedUpdate(treeId, lowPublicDataIndex)!;
+          pathAbsentInEphemeralTree = false;
         } else {
           const preimage: IndexedTreeLeafPreimage = (await this.treeDb.getLeafPreimage(treeId, lowPublicDataIndex))!;
           curr = preimage as T;
+          pathAbsentInEphemeralTree = true;
         }
       }
       counter++;
     }
-    // We did not find it - this is unexpected
-    if (result === undefined) {
-      throw new Error('No previous value found or ran out of iterations');
-    }
-    return result;
+    return [result, pathAbsentInEphemeralTree];
   }
 
   /**
    * This hashes the preimage to a field element
    */
   hashPreimage<T extends TreeLeafPreimage>(preimage: T): Fr {
-    // Watch for this edge-case, we are hashing the key=0 leaf to 0.
-    // This is for backward compatibility with the world state implementation
-    if (preimage.getKey() === 0n) {
-      return Fr.zero();
-    }
     const input = preimage.toHashInputs().map(x => Fr.fromBuffer(x));
     return poseidon2Hash(input);
   }
@@ -807,3 +885,28 @@ export class EphemeralAvmTree {
     }
   }
 }
+
+/**
+ * Return the index of the key in the array, or index-1 if they key is not found.
+ */
+function indexOrNextLowestInArray(key: Fr, arr: Fr[]): number {
+  // We are looking for the index of the largest element in the array that is less than the key
+  let start = 0;
+  let end = arr.length;
+  // Note that the easiest way is to increment the search key by 1 and then do a binary search
+  const keyPlus1 = key.add(Fr.ONE);
+  while (start < end) {
+    const mid = Math.floor((start + end) / 2);
+    if (arr[mid].cmp(keyPlus1) < 0) {
+      // The key + 1 is greater than the midpoint, so we can continue searching the top half
+      start = mid + 1;
+    } else {
+      // The key + 1 is LT or EQ the arr element, so we can continue searching the bottom half
+      end = mid;
+    }
+  }
+  // We either found key + 1 or start is now at the index of the largest element that we would have inserted key + 1
+  // Therefore start - 1 is the index of the element just below - note it can be -1 if the first element in the array is
+  // greater than the key
+  return start - 1;
+}

package/src/avm/errors.ts

@@ -39,6 +39,37 @@ export class InvalidProgramCounterError extends AvmExecutionError {
   }
 }
 
+/**
+ * Error is thrown when the program counter points to a byte
+ * of an invalid opcode.
+ */
+export class InvalidOpcodeError extends AvmExecutionError {
+  constructor(str: string) {
+    super(str);
+    this.name = 'InvalidOpcodeError';
+  }
+}
+
+/**
+ * Error is thrown during parsing.
+ */
+export class AvmParsingError extends AvmExecutionError {
+  constructor(str: string) {
+    super(str);
+    this.name = 'AvmParsingError';
+  }
+}
+
+/**
+ * Error is thrown when the tag has an invalid value.
+ */
+export class InvalidTagValueError extends AvmExecutionError {
+  constructor(tagValue: number) {
+    super(`Tag value ${tagValue} is invalid.`);
+    this.name = 'InvalidTagValueError';
+  }
+}
+
 /**
  * Error thrown during an instruction's execution (during its execute()).
  */

package/src/avm/journal/journal.ts

@@ -6,13 +6,13 @@ import {
   type PublicCallRequest,
   type PublicDataTreeLeafPreimage,
   SerializableContractInstance,
-  computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import assert from 'assert';
+import { strict as assert } from 'assert';
 
 import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { type WorldStateDB } from '../../public/public_db_sources.js';
@@ -50,7 +50,7 @@ export class AvmPersistableStateManager {
     private readonly nullifiers: NullifierManager = new NullifierManager(worldStateDB),
     private readonly doMerkleOperations: boolean = false,
     /** Ephmeral forest for merkle tree operations */
-    public readonly merkleTrees: AvmEphemeralForest,
+    public merkleTrees: AvmEphemeralForest,
   ) {}
 
   /**
@@ -77,14 +77,18 @@ export class AvmPersistableStateManager {
   /**
    * Create a new state manager
    */
-  public static async create(worldStateDB: WorldStateDB, trace: PublicSideEffectTraceInterface) {
+  public static async create(
+    worldStateDB: WorldStateDB,
+    trace: PublicSideEffectTraceInterface,
+    doMerkleOperations: boolean = false,
+  ) {
     const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
     return new AvmPersistableStateManager(
       worldStateDB,
       trace,
       /*publicStorage=*/ new PublicStorage(worldStateDB),
       /*nullifiers=*/ new NullifierManager(worldStateDB),
-      /*doMerkleOperations=*/ true,
+      /*doMerkleOperations=*/ doMerkleOperations,
       ephemeralForest,
     );
   }
@@ -117,14 +121,6 @@ export class AvmPersistableStateManager {
     this._merge(forkedState, /*reverted=*/ true);
   }
 
-  /**
-   * Commit cached storage writes to the DB.
-   * Keeps public storage up to date from tx to tx within a block.
-   */
-  public async commitStorageWritesToDB() {
-    await this.publicStorage.commitToDB();
-  }
-
   private _merge(forkedState: AvmPersistableStateManager, reverted: boolean) {
     // sanity check to avoid merging the same forked trace twice
     assert(
@@ -135,6 +131,14 @@ export class AvmPersistableStateManager {
     this.publicStorage.acceptAndMerge(forkedState.publicStorage);
     this.nullifiers.acceptAndMerge(forkedState.nullifiers);
     this.trace.merge(forkedState.trace, reverted);
+    if (!reverted) {
+      this.merkleTrees = forkedState.merkleTrees;
+      if (this.doMerkleOperations) {
+        this.log.debug(
+          `Rolled back nullifier tree to root ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
+        );
+      }
+    }
   }
 
   /**
@@ -293,9 +297,10 @@ export class AvmPersistableStateManager {
    * @returns exists - whether the nullifier exists in the nullifier set
    */
   public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
-    const [exists, isPending, _] = await this.nullifiers.checkExists(contractAddress, nullifier);
-
+    this.log.debug(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
     const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    const [exists, isPending, _] = await this.nullifiers.checkExists(siloedNullifier);
+    this.log.debug(`Checked siloed nullifier ${siloedNullifier} (exists=${exists}, pending=${isPending})`);
 
     if (this.doMerkleOperations) {
       // Get leaf if present, low leaf if absent
@@ -310,11 +315,9 @@ export class AvmPersistableStateManager {
 
       assert(update == exists, 'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!');
 
-      this.log.debug(
-        `nullifiers(${contractAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
-      );
-
-      if (!exists) {
+      if (exists) {
+        this.log.debug(`Siloed nullifier ${siloedNullifier} exists at leafIndex=${leafIndex}`);
+      } else {
         // Sanity check that the leaf value is skipped by low leaf when it doesn't exist
         assert(
           siloedNullifier.toBigInt() > leafPreimage.nullifier.toBigInt() &&
@@ -323,20 +326,9 @@ export class AvmPersistableStateManager {
         );
       }
 
-      this.trace.traceNullifierCheck(
-        contractAddress,
-        nullifier, // FIXME: Should this be siloed?
-        exists,
-        leafPreimage,
-        new Fr(leafIndex),
-        leafPath,
-      );
+      this.trace.traceNullifierCheck(siloedNullifier, exists, leafPreimage, new Fr(leafIndex), leafPath);
     } else {
-      this.trace.traceNullifierCheck(
-        contractAddress,
-        nullifier, // FIXME: Should this be siloed?
-        exists,
-      );
+      this.trace.traceNullifierCheck(siloedNullifier, exists);
     }
     return Promise.resolve(exists);
   }
@@ -347,9 +339,17 @@ export class AvmPersistableStateManager {
    * @param nullifier - the unsiloed nullifier to write
    */
   public async writeNullifier(contractAddress: AztecAddress, nullifier: Fr) {
-    this.log.debug(`nullifiers(${contractAddress}) += ${nullifier}.`);
-
+    this.log.debug(`Inserting new nullifier (address=${nullifier}, nullifier=${contractAddress})`);
     const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    await this.writeSiloedNullifier(siloedNullifier);
+  }
+
+  /**
+   * Write a nullifier to the nullifier set, trace the write.
+   * @param siloedNullifier - the siloed nullifier to write
+   */
+  public async writeSiloedNullifier(siloedNullifier: Fr) {
+    this.log.debug(`Inserting siloed nullifier=${siloedNullifier}`);
 
     if (this.doMerkleOperations) {
       // Maybe overkill, but we should check if the nullifier is already present in the tree before attempting to insert
@@ -360,34 +360,35 @@ export class AvmPersistableStateManager {
         siloedNullifier,
       );
       if (update) {
-        this.log.verbose(`Nullifier already present in tree: ${nullifier} at index ${index}.`);
+        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
         const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, index);
         // This just becomes a nullifier read hint
         this.trace.traceNullifierCheck(
-          contractAddress,
-          nullifier,
+          siloedNullifier,
           /*exists=*/ update,
           preimage as NullifierLeafPreimage,
           new Fr(index),
           path,
         );
         throw new NullifierCollisionError(
-          `Nullifier ${nullifier} at contract ${contractAddress} already exists in parent cache or host.`,
+          `Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`,
         );
       } else {
         // Cache pending nullifiers for later access
-        await this.nullifiers.append(contractAddress, nullifier);
+        await this.nullifiers.append(siloedNullifier);
         // We append the new nullifier
         const appendResult = await this.merkleTrees.appendNullifier(siloedNullifier);
+        this.log.debug(
+          `Nullifier tree root after insertion ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
+        );
         const lowLeafPreimage = appendResult.lowWitness.preimage as NullifierLeafPreimage;
         const lowLeafIndex = appendResult.lowWitness.index;
         const lowLeafPath = appendResult.lowWitness.siblingPath;
         const insertionPath = appendResult.insertionPath;
         this.trace.traceNewNullifier(
-          contractAddress,
-          nullifier,
+          siloedNullifier,
           lowLeafPreimage,
           new Fr(lowLeafIndex),
           lowLeafPath,
@@ -396,8 +397,14 @@ export class AvmPersistableStateManager {
       }
     } else {
       // Cache pending nullifiers for later access
-      await this.nullifiers.append(contractAddress, nullifier);
-      this.trace.traceNewNullifier(contractAddress, nullifier);
+      await this.nullifiers.append(siloedNullifier);
+      this.trace.traceNewNullifier(siloedNullifier);
+    }
+  }
+
+  public async writeSiloedNullifiersFromPrivate(siloedNullifiers: Fr[]) {
+    for (const siloedNullifier of siloedNullifiers.filter(n => !n.isEmpty())) {
+      await this.writeSiloedNullifier(siloedNullifier);
     }
   }
 
@@ -469,7 +476,7 @@ export class AvmPersistableStateManager {
     if (exists) {
       const instance = new SerializableContractInstance(instanceWithAddress);
       this.log.debug(
-        `Got contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
+        `Got contract instance (address=${contractAddress}): exists=${exists}, instance=${jsonStringify(instance)}`,
       );
       this.trace.traceGetContractInstance(contractAddress, exists, instance);
 
@@ -491,17 +498,23 @@ export class AvmPersistableStateManager {
 
     if (exists) {
       const instance = new SerializableContractInstance(instanceWithAddress);
-
       const contractClass = await this.worldStateDB.getContractClass(instance.contractClassId);
+      const bytecodeCommitment = await this.worldStateDB.getBytecodeCommitment(instance.contractClassId);
+
       assert(
         contractClass,
         `Contract class not found in DB, but a contract instance was found with this class ID (${instance.contractClassId}). This should not happen!`,
       );
 
+      assert(
+        bytecodeCommitment,
+        `Bytecode commitment was not found in DB for contract class (${instance.contractClassId}). This should not happen!`,
+      );
+
       const contractClassPreimage = {
         artifactHash: contractClass.artifactHash,
         privateFunctionsRoot: contractClass.privateFunctionsRoot,
-        publicBytecodeCommitment: computePublicBytecodeCommitment(contractClass.packedBytecode),
+        publicBytecodeCommitment: bytecodeCommitment,
       };
 
       this.trace.traceGetBytecode(
@@ -511,6 +524,7 @@ export class AvmPersistableStateManager {
         instance,
         contractClassPreimage,
       );
+
       return contractClass.packedBytecode;
     } else {
       // If the contract instance is not found, we assume it has not been deployed.