@aztec/simulator 0.63.0 → 0.64.0

package/dest/public/transitional_adapters.js

@@ -3,9 +3,8 @@ import { AvmCircuitInputs, AvmCircuitPublicInputs, AztecAddress, ContractStorage
 import { computeNoteHashNonce, computeUniqueNoteHash, computeVarArgsHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { assertLength } from '@aztec/foundation/serialize';
-import { AvmContractCallResult } from '../avm/avm_contract_call_result.js';
-import { getPublicFunctionDebugName } from '../common/debug_fn_name.js';
-import { createAvmExecutionEnvironment } from './executor.js';
+import { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 export function generateAvmCircuitPublicInputs(trace, globalVariables, startStateReference, startGasUsed, gasSettings, setupCallRequests, appLogicCallRequests, teardownCallRequests, nonRevertibleAccumulatedDataFromPrivate, revertibleAccumulatedDataFromPrivate, endStateReference, endGasUsed, transactionFee, revertCode) {
     const startTreeSnapshots = new TreeSnapshots(startStateReference.l1ToL2MessageTree, startStateReference.partial.noteHashTree, startStateReference.partial.nullifierTree, startStateReference.partial.publicDataTree);
     const endTreeSnapshots = new TreeSnapshots(endStateReference.l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
@@ -64,16 +63,15 @@ export function generateAvmCircuitPublicInputs(trace, globalVariables, startStat
     //console.log(`AvmCircuitPublicInputs:\n${inspect(avmCircuitPublicInputs)}`);
     return avmCircuitPublicInputs;
 }
-export async function generateAvmProvingRequest(real, worldStateDB, stateManager, historicalHeader, globalVariables, executionRequest, result, allocatedGas, transactionFee) {
-    const fnName = await getPublicFunctionDebugName(worldStateDB, executionRequest.callContext.contractAddress, executionRequest.callContext.functionSelector, executionRequest.args);
-    const avmExecutionEnv = createAvmExecutionEnvironment(executionRequest, globalVariables, transactionFee);
-    const avmCallResult = new AvmContractCallResult(result.reverted, result.returnValues);
+export function generateAvmProvingRequest(real, fnName, stateManager, historicalHeader, globalVariables, executionRequest, result, allocatedGas, transactionFee) {
+    const avmExecutionEnv = new AvmExecutionEnvironment(executionRequest.callContext.contractAddress, executionRequest.callContext.msgSender, executionRequest.callContext.functionSelector, 
+    /*contractCallDepth=*/ Fr.zero(), transactionFee, globalVariables, executionRequest.callContext.isStaticCall, executionRequest.args);
+    const avmCallResult = new AvmFinalizedCallResult(result.reverted, result.returnValues, result.endGasLeft);
     // Generate an AVM proving request
     let avmProvingRequest;
     if (real) {
         const deprecatedFunctionCallResult = stateManager.trace.toPublicFunctionCallResult(avmExecutionEnv, 
-        /*startGasLeft=*/ allocatedGas, 
-        /*endGasLeft=*/ Gas.from(result.endGasLeft), Buffer.alloc(0), avmCallResult, fnName);
+        /*startGasLeft=*/ allocatedGas, Buffer.alloc(0), avmCallResult, fnName);
         const publicInputs = getPublicCircuitPublicInputs(historicalHeader, globalVariables, deprecatedFunctionCallResult);
         avmProvingRequest = makeAvmProvingRequest(publicInputs, deprecatedFunctionCallResult);
     }
@@ -124,4 +122,4 @@ function getPublicCircuitPublicInputs(historicalHeader, globalVariables, result)
         revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transitional_adapters.js","sourceRoot":"","sources":["../../src/public/transitional_adapters.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transitional_adapters.js","sourceRoot":"","sources":["../../src/public/transitional_adapters.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./avm/fixtures": "./dest/avm/fixtures/index.js"
+    "./public/fixtures": "./dest/public/fixtures/index.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -59,14 +59,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.63.0",
-    "@aztec/circuits.js": "0.63.0",
-    "@aztec/foundation": "0.63.0",
-    "@aztec/noir-protocol-circuits-types": "0.63.0",
-    "@aztec/protocol-contracts": "0.63.0",
-    "@aztec/telemetry-client": "0.63.0",
-    "@aztec/types": "0.63.0",
-    "@aztec/world-state": "0.63.0",
+    "@aztec/circuit-types": "0.64.0",
+    "@aztec/circuits.js": "0.64.0",
+    "@aztec/foundation": "0.64.0",
+    "@aztec/noir-protocol-circuits-types": "0.64.0",
+    "@aztec/protocol-contracts": "0.64.0",
+    "@aztec/telemetry-client": "0.64.0",
+    "@aztec/types": "0.64.0",
+    "@aztec/world-state": "0.64.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
     "@noir-lang/types": "portal:../../noir/packages/types",

package/src/avm/avm_contract_call_result.ts

@@ -1,15 +1,52 @@
+import { type SimulationError } from '@aztec/circuit-types';
+import { Gas } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
+import { inspect } from 'util';
+
+import { createSimulationError } from '../common/errors.js';
+import { type Gas as AvmGas } from './avm_gas.js';
 import { type AvmRevertReason } from './errors.js';
 
 /**
  * Results of an contract call's execution in the AVM.
  */
 export class AvmContractCallResult {
-  constructor(public reverted: boolean, public output: Fr[], public revertReason?: AvmRevertReason) {}
+  constructor(
+    public reverted: boolean,
+    public output: Fr[],
+    public gasLeft: AvmGas,
+    public revertReason?: AvmRevertReason,
+  ) {}
+
+  toString(): string {
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    if (this.revertReason) {
+      resultsStr += `, revertReason: ${this.revertReason}`;
+    }
+    return resultsStr;
+  }
+
+  finalize(): AvmFinalizedCallResult {
+    const revertReason = this.revertReason ? createSimulationError(this.revertReason, this.output) : undefined;
+    return new AvmFinalizedCallResult(this.reverted, this.output, Gas.from(this.gasLeft), revertReason);
+  }
+}
+
+/**
+ * Similar to AvmContractCallResult, but with a SimulationError and standard Gas
+ * which are useful for consumption external to core AVM simulation.
+ */
+export class AvmFinalizedCallResult {
+  constructor(
+    public reverted: boolean,
+    public output: Fr[],
+    public gasLeft: Gas,
+    public revertReason?: SimulationError,
+  ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
     if (this.revertReason) {
       resultsStr += `, revertReason: ${this.revertReason}`;
     }

package/src/avm/avm_memory_types.ts

@@ -232,8 +232,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   // Whether to track and validate memory accesses for each instruction.
   static readonly TRACK_MEMORY_ACCESSES = process.env.NODE_ENV === 'test';
 
-  // FIXME: memory should be 2^32, but TS doesn't allow for arrays that big.
-  static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 2n);
+  // FIXME: memory should be 2^32, but TS max array size is: 2^32 - 1
+  static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 1n);
   private _mem: MemoryValue[];
 
   constructor() {
@@ -264,8 +264,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public getSlice(offset: number, size: number): MemoryValue[] {
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
     TaggedMemory.log.debug(`getSlice(${offset}, ${size}) = ${value}`);
     for (let i = 0; i < value.length; i++) {
@@ -278,14 +277,12 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public getSliceAs<T>(offset: number, size: number): T[] {
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
     return this.getSlice(offset, size) as T[];
   }
 
   public getSliceTags(offset: number, size: number): TypeTag[] {
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
     return this._mem.slice(offset, offset + size).map(TaggedMemory.getTag);
   }
 
@@ -296,8 +293,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    assert(offset + vs.length < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(offset + vs.length <= TaggedMemory.MAX_MEMORY_SIZE);
     // We may need to extend the memory size, otherwise splice doesn't insert.
     if (offset + vs.length > this._mem.length) {
       this._mem.length = offset + vs.length;

package/src/avm/avm_simulator.ts

@@ -1,20 +1,29 @@
-import { MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
+import {
+  type AztecAddress,
+  Fr,
+  type FunctionSelector,
+  type GlobalVariables,
+  MAX_L2_GAS_PER_ENQUEUED_CALL,
+} from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
 import { SideEffectLimitReachedError } from '../public/side_effect_errors.js';
-import type { AvmContext } from './avm_context.js';
+import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas } from './avm_gas.js';
+import { AvmMachineState } from './avm_machine_state.js';
 import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
+  AvmRevertReason,
   InvalidProgramCounterError,
-  NoBytecodeForContractError,
   revertReasonFromExceptionalHalt,
   revertReasonFromExplicitRevert,
 } from './errors.js';
+import { type AvmPersistableStateManager } from './journal/journal.js';
 import { decodeInstructionFromBytecode } from './serialization/bytecode_serialization.js';
 
 type OpcodeTally = {
@@ -41,16 +50,57 @@ export class AvmSimulator {
     this.log = createDebugLogger(`aztec:avm_simulator:core(f:${context.environment.functionSelector.toString()})`);
   }
 
+  public static create(
+    stateManager: AvmPersistableStateManager,
+    address: AztecAddress,
+    sender: AztecAddress,
+    functionSelector: FunctionSelector, // may be temporary (#7224)
+    transactionFee: Fr,
+    globals: GlobalVariables,
+    isStaticCall: boolean,
+    calldata: Fr[],
+    allocatedGas: Gas,
+  ) {
+    const avmExecutionEnv = new AvmExecutionEnvironment(
+      address,
+      sender,
+      functionSelector,
+      /*contractCallDepth=*/ Fr.zero(),
+      transactionFee,
+      globals,
+      isStaticCall,
+      calldata,
+    );
+
+    const avmMachineState = new AvmMachineState(allocatedGas);
+    const avmContext = new AvmContext(stateManager, avmExecutionEnv, avmMachineState);
+    return new AvmSimulator(avmContext);
+  }
+
   /**
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
     const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
 
-    // This assumes that we will not be able to send messages to accounts without code
-    // Pending classes and instances impl details
     if (!bytecode) {
-      throw new NoBytecodeForContractError(this.context.environment.address);
+      // revert, consuming all gas
+      const message = `No bytecode found at: ${this.context.environment.address}. Reverting...`;
+      const revertReason = new AvmRevertReason(
+        message,
+        /*failingFunction=*/ {
+          contractAddress: this.context.environment.address,
+          functionSelector: this.context.environment.functionSelector,
+        },
+        /*noirCallStack=*/ [],
+      );
+      this.log.warn(message);
+      return new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ [],
+        /*gasLeft=*/ { l2Gas: 0, daGas: 0 },
+        revertReason,
+      );
     }
 
     return await this.executeBytecode(bytecode);
@@ -119,7 +169,7 @@ export class AvmSimulator {
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
       const revertReason = reverted ? revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResult(reverted, output, revertReason);
+      const results = new AvmContractCallResult(reverted, output, machineState.gasLeft, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.printOpcodeTallies();
@@ -134,7 +184,7 @@ export class AvmSimulator {
 
       const revertReason = revertReasonFromExceptionalHalt(err, this.context);
       // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
+      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], machineState.gasLeft, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.printOpcodeTallies();

package/src/avm/avm_tree.ts

@@ -51,11 +51,10 @@ export class AvmEphemeralForest {
   constructor(
     public treeDb: MerkleTreeReadOperations,
     public treeMap: Map<MerkleTreeId, EphemeralAvmTree>,
-    // This contains the preimage and the leaf index of leaf in the ephemeral tree that contains the lowest key (i.e. nullifier value or public data tree slot)
-    public indexedTreeMin: Map<IndexedTreeId, [IndexedTreeLeafPreimage, bigint]>,
     // This contains the [leaf index,indexed leaf preimages] tuple that were updated or inserted in the ephemeral tree
     // This is needed since we have a sparse collection of keys sorted leaves in the ephemeral tree
     public indexedUpdates: Map<IndexedTreeId, Map<bigint, IndexedTreeLeafPreimage>>,
+    public indexedSortedKeys: Map<IndexedTreeId, [Fr, bigint][]>,
   ) {}
 
   static async create(treeDb: MerkleTreeReadOperations): Promise<AvmEphemeralForest> {
@@ -65,15 +64,18 @@ export class AvmEphemeralForest {
       const tree = await EphemeralAvmTree.create(treeInfo.size, treeInfo.depth, treeDb, treeType);
       treeMap.set(treeType, tree);
     }
-    return new AvmEphemeralForest(treeDb, treeMap, new Map(), new Map());
+    const indexedSortedKeys = new Map<IndexedTreeId, [Fr, bigint][]>();
+    indexedSortedKeys.set(MerkleTreeId.NULLIFIER_TREE as IndexedTreeId, []);
+    indexedSortedKeys.set(MerkleTreeId.PUBLIC_DATA_TREE as IndexedTreeId, []);
+    return new AvmEphemeralForest(treeDb, treeMap, new Map(), indexedSortedKeys);
   }
 
   fork(): AvmEphemeralForest {
     return new AvmEphemeralForest(
       this.treeDb,
       cloneDeep(this.treeMap),
-      cloneDeep(this.indexedTreeMin),
       cloneDeep(this.indexedUpdates),
+      cloneDeep(this.indexedSortedKeys),
     );
   }
 
@@ -166,7 +168,8 @@ export class AvmEphemeralForest {
       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._updateMinInfo(MerkleTreeId.PUBLIC_DATA_TREE, [updatedPreimage], [index]);
+      this._updateSortedKeys(treeId, [updatedPreimage.slot], [index]);
+
       return {
         leafIndex: insertionIndex,
         insertionPath,
@@ -193,8 +196,10 @@ export class AvmEphemeralForest {
     );
     const insertionPath = this.appendIndexedTree(treeId, index, updatedLowLeaf, newPublicDataLeaf);
 
-    // Since we are appending, we might have a new minimum public data leaf
-    this._updateMinInfo(MerkleTreeId.PUBLIC_DATA_TREE, [newPublicDataLeaf, updatedLowLeaf], [insertionIndex, index]);
+    // 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]);
+
     return {
       leafIndex: insertionIndex,
       insertionPath: insertionPath,
@@ -208,28 +213,25 @@ export class AvmEphemeralForest {
     };
   }
 
-  /**
-   * This is just a helper to compare the preimages and update the minimum public data leaf
-   * @param treeId - The tree to be queried for a sibling path.
-   * @param T - The type of the preimage (PublicData or Nullifier)
-   * @param preimages - The preimages to be compared
-   * @param indices - The indices of the preimages
-   */
-  private _updateMinInfo<T extends IndexedTreeLeafPreimage>(
-    treeId: IndexedTreeId,
-    preimages: T[],
-    indices: bigint[],
-  ): void {
-    let currentMin = this.getMinInfo(treeId);
-    if (currentMin === undefined) {
-      currentMin = { preimage: preimages[0], index: indices[0] };
-    }
-    for (let i = 0; i < preimages.length; i++) {
-      if (preimages[i].getKey() <= currentMin.preimage.getKey()) {
-        currentMin = { preimage: preimages[i], index: indices[i] };
+  private _updateSortedKeys(treeId: IndexedTreeId, keys: Fr[], index: bigint[]): void {
+    // This is a reference
+    const existingKeyVector = this.indexedSortedKeys.get(treeId)!;
+    // Should already be sorted so not need to re-sort if we just update or splice
+    for (let i = 0; i < keys.length; i++) {
+      const foundIndex = existingKeyVector.findIndex(x => x[1] === index[i]);
+      if (foundIndex === -1) {
+        // New element, we splice it into the correct location
+        const spliceIndex =
+          this.searchForKey(
+            keys[i],
+            existingKeyVector.map(x => x[0]),
+          ) + 1;
+        existingKeyVector.splice(spliceIndex, 0, [keys[i], index[i]]);
+      } else {
+        // Update the existing element
+        existingKeyVector[foundIndex][0] = keys[i];
       }
     }
-    this.setMinInfo(treeId, currentMin.preimage, currentMin.index);
   }
 
   /**
@@ -258,8 +260,14 @@ export class AvmEphemeralForest {
     const newNullifierLeaf = new NullifierLeafPreimage(nullifier, preimage.nextNullifier, preimage.nextIndex);
     const insertionPath = this.appendIndexedTree(treeId, index, updatedLowNullifier, newNullifierLeaf);
 
-    // Since we are appending, we might have a new minimum nullifier leaf
-    this._updateMinInfo(MerkleTreeId.NULLIFIER_TREE, [newNullifierLeaf, updatedLowNullifier], [insertionIndex, index]);
+    // Even though the low nullifier key is not updated, we still need to update the sorted keys in case we have
+    // not seen the low nullifier before
+    this._updateSortedKeys(
+      treeId,
+      [newNullifierLeaf.nullifier, updatedLowNullifier.nullifier],
+      [insertionIndex, index],
+    );
+
     return {
       leafIndex: insertionIndex,
       insertionPath: insertionPath,
@@ -286,31 +294,6 @@ export class AvmEphemeralForest {
     return insertionPath!;
   }
 
-  /**
-   * This is wrapper around treeId to get the correct minimum leaf preimage
-   */
-  private getMinInfo<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
-    treeId: ID,
-  ): { preimage: T; index: bigint } | undefined {
-    const start = this.indexedTreeMin.get(treeId);
-    if (start === undefined) {
-      return undefined;
-    }
-    const [preimage, index] = start;
-    return { preimage: preimage as T, index };
-  }
-
-  /**
-   * This is wrapper around treeId to set the correct minimum leaf preimage
-   */
-  private setMinInfo<ID extends IndexedTreeId, T extends IndexedTreeLeafPreimage>(
-    treeId: ID,
-    preimage: T,
-    index: bigint,
-  ): void {
-    this.indexedTreeMin.set(treeId, [preimage, index]);
-  }
-
   /**
    * This is wrapper around treeId to set values in the indexedUpdates map
    */
@@ -353,6 +336,28 @@ 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
@@ -365,23 +370,42 @@ export class AvmEphemeralForest {
     treeId: ID,
     key: Fr,
   ): Promise<PreimageWitness<T>> {
+    const keyOrderedVector = this.indexedSortedKeys.get(treeId)!;
+
+    const vectorIndex = this.searchForKey(
+      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 minPreimage = this.getMinInfo(treeId);
     const start = minPreimage?.preimage;
     const bigIntKey = key.toBigInt();
-    // If the first element we have is already greater than the value, we need to do an external lookup
-    if (minPreimage === undefined || (start?.getKey() ?? 0n) >= key.toBigInt()) {
-      // The low public data witness is in the previous tree
+
+    // 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
-      const siblingPath = (await this.treeDb.getSiblingPath(treeId, index)).toFields();
+      // 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();
 
-      // Is it enough to just insert the sibling path without inserting the leaf? - right now probably since we will update this low nullifier index in append
+      // 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);
 
       const lowPublicDataPreimage = preimage as T;
+
       return { preimage: lowPublicDataPreimage, index: index, update: alreadyPresent };
     }
 
@@ -392,18 +416,18 @@ export class AvmEphemeralForest {
     // (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
     let found = false;
-    let curr = minPreimage.preimage as T;
+    let curr = minPreimage!.preimage 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 = minPreimage!.index;
     while (!found && counter < LIMIT) {
       if (curr.getKey() === bigIntKey) {
         // We found an exact match - therefore this is an update
         found = true;
         result = { preimage: curr, index: lowPublicDataIndex, update: true };
-      } else if (curr.getKey() < bigIntKey && (curr.getNextKey() === 0n || curr.getNextKey() > bigIntKey)) {
+      } 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 };

package/src/avm/errors.ts

@@ -67,6 +67,17 @@ export class TagCheckError extends AvmExecutionError {
   }
 }
 
+/**
+ * Error is thrown when a relative memory address resolved to an offset which
+ * is out of range, i.e, greater than maxUint32.
+ */
+export class AddressOutOfRangeError extends AvmExecutionError {
+  constructor(baseAddr: number, relOffset: number) {
+    super(`Address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
+    this.name = 'AddressOutOfRangeError';
+  }
+}
+
 /** Error thrown when out of gas. */
 export class OutOfGasError extends AvmExecutionError {
   constructor(dimensions: string[]) {

package/src/avm/fixtures/index.ts

@@ -1,4 +1,4 @@
-import { type MerkleTreeWriteOperations, isNoirCallStackUnresolved } from '@aztec/circuit-types';
+import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
 import { GasFees, GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
 import { type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -16,6 +16,7 @@ import { AvmContext } from '../avm_context.js';
 import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
 import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import { type AvmEphemeralForest } from '../avm_tree.js';
 import { type AvmRevertReason } from '../errors.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
 import { NullifierManager } from '../journal/nullifiers.js';
@@ -43,7 +44,7 @@ export function initPersistableStateManager(overrides?: {
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
   doMerkleOperations?: boolean;
-  merkleTrees?: MerkleTreeWriteOperations;
+  merkleTrees?: AvmEphemeralForest;
 }): AvmPersistableStateManager {
   const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
   return new AvmPersistableStateManager(
@@ -52,7 +53,7 @@ export function initPersistableStateManager(overrides?: {
     overrides?.publicStorage || new PublicStorage(worldStateDB),
     overrides?.nullifiers || new NullifierManager(worldStateDB),
     overrides?.doMerkleOperations || false,
-    overrides?.merkleTrees || mock<MerkleTreeWriteOperations>(),
+    overrides?.merkleTrees || mock<AvmEphemeralForest>(),
   );
 }
 

package/src/avm/index.ts

@@ -1,2 +1,3 @@
 export * from './avm_simulator.js';
 export * from './journal/index.js';
+export * from './avm_tree.js';