@aztec/simulator 0.65.2 → 0.67.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/errors.ts

@@ -1,5 +1,5 @@
 import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
-import { type AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
+import { type AztecAddress, type Fr } from '@aztec/circuits.js';
 
 import { ExecutionError } from '../common/errors.js';
 import { type AvmContext } from './avm_context.js';
@@ -138,16 +138,9 @@ export class AvmRevertReason extends ExecutionError {
   }
 }
 
-function createRevertReason(message: string, revertData: Fr[], context: AvmContext): AvmRevertReason {
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
-  // If the function selector is the public dispatch selector, we need to extract the actual function selector from the calldata.
-  // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
-  let functionSelector = context.environment.functionSelector;
+async function createRevertReason(message: string, revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
   // We drop the returnPc information.
   const internalCallStack = context.machineState.internalCallStack.map(entry => entry.callPc);
-  if (functionSelector.toField().equals(new Fr(PUBLIC_DISPATCH_SELECTOR)) && context.environment.calldata.length > 0) {
-    functionSelector = FunctionSelector.fromField(context.environment.calldata[0]);
-  }
 
   // If we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
   let nestedError = undefined;
@@ -160,11 +153,13 @@ function createRevertReason(message: string, revertData: Fr[], context: AvmConte
     message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
   }
 
+  const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
+
   return new AvmRevertReason(
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionSelector: functionSelector,
+      functionName: fnName,
     },
     /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },
@@ -177,8 +172,11 @@ function createRevertReason(message: string, revertData: Fr[], context: AvmConte
  * @param haltingError - the lower-level error causing the exceptional halt
  * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
  */
-export function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError, context: AvmContext): AvmRevertReason {
-  return createRevertReason(haltingError.message, [], context);
+export async function revertReasonFromExceptionalHalt(
+  haltingError: AvmExecutionError,
+  context: AvmContext,
+): Promise<AvmRevertReason> {
+  return await createRevertReason(haltingError.message, [], context);
 }
 
 /**
@@ -187,6 +185,6 @@ export function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError,
  * @param revertData - output data of the explicit REVERT instruction
  * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
  */
-export function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): AvmRevertReason {
-  return createRevertReason('Assertion failed: ', revertData, context);
+export async function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
+  return await createRevertReason('Assertion failed: ', revertData, context);
 }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
-import { GasFees, GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
+import { GasFees, GlobalVariables, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/circuits.js';
 import { type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -64,7 +64,6 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
   return new AvmExecutionEnvironment(
     overrides?.address ?? AztecAddress.zero(),
     overrides?.sender ?? AztecAddress.zero(),
-    overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
     overrides?.transactionFee ?? Fr.zero(),
     overrides?.globals ?? GlobalVariables.empty(),
@@ -94,7 +93,7 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
  */
 export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
   return AvmMachineState.fromState({
-    l2GasLeft: overrides?.l2GasLeft ?? MAX_L2_GAS_PER_ENQUEUED_CALL,
+    l2GasLeft: overrides?.l2GasLeft ?? MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
     daGasLeft: overrides?.daGasLeft ?? 1e8,
   });
 }