@aztec/simulator 0.67.1 → 0.68.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.67.1",
+  "version": "0.68.1",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -22,7 +22,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests"
+    "test": "HARDWARE_CONCURRENCY=${HARDWARE_CONCURRENCY:-16} RAYON_NUM_THREADS=${RAYON_NUM_THREADS:-4} NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
     "../package.common.json"
@@ -54,9 +54,9 @@
     ],
     "reporters": [
       [
-        "default",
+        "jest-silent-reporter",
         {
-          "summaryThreshold": 9999
+          "useDots": true
         }
       ]
     ],
@@ -66,14 +66,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.67.1",
-    "@aztec/circuits.js": "0.67.1",
-    "@aztec/foundation": "0.67.1",
-    "@aztec/noir-protocol-circuits-types": "0.67.1",
-    "@aztec/protocol-contracts": "0.67.1",
-    "@aztec/telemetry-client": "0.67.1",
-    "@aztec/types": "0.67.1",
-    "@aztec/world-state": "0.67.1",
+    "@aztec/circuit-types": "0.68.1",
+    "@aztec/circuits.js": "0.68.1",
+    "@aztec/foundation": "0.68.1",
+    "@aztec/noir-protocol-circuits-types": "0.68.1",
+    "@aztec/protocol-contracts": "0.68.1",
+    "@aztec/telemetry-client": "0.68.1",
+    "@aztec/types": "0.68.1",
+    "@aztec/world-state": "0.68.1",
     "@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/acvm/oracle/oracle.ts

@@ -375,8 +375,8 @@ export class Oracle {
     this.typedOracle.notifySetMinRevertibleSideEffectCounter(frToNumber(fromACVMField(minRevertibleSideEffectCounter)));
   }
 
-  async getAppTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
-    const taggingSecret = await this.typedOracle.getAppTaggingSecretAsSender(
+  async getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
+    const taggingSecret = await this.typedOracle.getIndexedTaggingSecretAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );

package/src/acvm/oracle/typed_oracle.ts

@@ -237,8 +237,8 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('debugLog');
   }
 
-  getAppTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
-    throw new OracleMethodNotAvailableError('getAppTaggingSecretAsSender');
+  getIndexedTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
+    throw new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender');
   }
 
   incrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {

package/src/avm/avm_memory_types.ts

@@ -15,7 +15,12 @@ import { type FunctionsOf } from '@aztec/foundation/types';
 
 import { strict as assert } from 'assert';
 
-import { InstructionExecutionError, InvalidTagValueError, TagCheckError } from './errors.js';
+import {
+  InstructionExecutionError,
+  InvalidTagValueError,
+  MemorySliceOutOfRangeError,
+  TagCheckError,
+} from './errors.js';
 import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 
 /** MemoryValue gathers the common operations for all memory types. */
@@ -232,13 +237,14 @@ 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 max array size is: 2^32 - 1
-  static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 1n);
-  private _mem: MemoryValue[];
+  // Memory is modelled by a map with key type being number.
+  // We however restrict the keys to be non-negative integers smaller than
+  // MAX_MEMORY_SIZE.
+  static readonly MAX_MEMORY_SIZE = Number(1n << 32n);
+  private _mem: Map<number, MemoryValue>;
 
   constructor() {
-    // We do not initialize memory size here because otherwise tests blow up when diffing.
-    this._mem = [];
+    this._mem = new Map<number, MemoryValue>();
   }
 
   public getMaxMemorySize(): number {
@@ -257,8 +263,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public getAs<T>(offset: number): T {
+    assert(Number.isInteger(offset));
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    const word = this._mem[offset];
+    const word = this._mem.get(offset);
     TaggedMemory.log.trace(`get(${offset}) = ${word}`);
     if (word === undefined) {
       TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
@@ -268,54 +275,63 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public getSlice(offset: number, size: number): MemoryValue[] {
-    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
-    const value = this._mem.slice(offset, offset + size);
-    TaggedMemory.log.trace(`getSlice(${offset}, ${size}) = ${value}`);
-    for (let i = 0; i < value.length; i++) {
-      if (value[i] === undefined) {
-        value[i] = new Field(0);
-      }
+    assert(Number.isInteger(offset) && Number.isInteger(size));
+
+    if (offset + size > TaggedMemory.MAX_MEMORY_SIZE) {
+      throw new MemorySliceOutOfRangeError(offset, size);
     }
-    assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
-    return value;
+
+    const slice = new Array<MemoryValue>(size);
+
+    for (let i = 0; i < size; i++) {
+      slice[i] = this._mem.get(offset + i) ?? new Field(0);
+    }
+
+    TaggedMemory.log.trace(`getSlice(${offset}, ${size}) = ${slice}`);
+    return slice;
   }
 
   public getSliceAs<T>(offset: number, size: number): T[] {
-    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
     return this.getSlice(offset, size) as T[];
   }
 
   public getSliceTags(offset: number, size: number): TypeTag[] {
-    assert(offset + size <= TaggedMemory.MAX_MEMORY_SIZE);
-    return this._mem.slice(offset, offset + size).map(TaggedMemory.getTag);
+    return this.getSlice(offset, size).map(TaggedMemory.getTag);
   }
 
   public set(offset: number, v: MemoryValue) {
+    assert(Number.isInteger(offset));
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    this._mem[offset] = v;
+    this._mem.set(offset, v);
     TaggedMemory.log.trace(`set(${offset}, ${v})`);
   }
 
-  public setSlice(offset: number, vs: MemoryValue[]) {
-    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;
+  public setSlice(offset: number, slice: MemoryValue[]) {
+    assert(Number.isInteger(offset));
+
+    if (offset + slice.length > TaggedMemory.MAX_MEMORY_SIZE) {
+      throw new MemorySliceOutOfRangeError(offset, slice.length);
     }
-    this._mem.splice(offset, vs.length, ...vs);
-    TaggedMemory.log.trace(`setSlice(${offset}, ${vs})`);
+
+    slice.forEach((element, idx) => {
+      this._mem.set(offset + idx, element);
+    });
+    TaggedMemory.log.trace(`setSlice(${offset}, ${slice})`);
   }
 
   public getTag(offset: number): TypeTag {
-    return TaggedMemory.getTag(this._mem[offset]);
+    assert(Number.isInteger(offset));
+    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
+    return TaggedMemory.getTag(this._mem.get(offset));
   }
 
   /**
    * Check that the memory at the given offset matches the specified tag.
    */
   public checkTag(tag: TypeTag, offset: number) {
-    if (this.getTag(offset) !== tag) {
-      throw TagCheckError.forOffset(offset, TypeTag[this.getTag(offset)], TypeTag[tag]);
+    const gotTag = this.getTag(offset);
+    if (gotTag !== tag) {
+      throw TagCheckError.forOffset(offset, TypeTag[gotTag], TypeTag[tag]);
     }
   }
 
@@ -334,13 +350,13 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public static checkIsValidTag(tagNumber: number) {
     if (
       ![
+        TypeTag.FIELD,
         TypeTag.UINT1,
         TypeTag.UINT8,
         TypeTag.UINT16,
         TypeTag.UINT32,
         TypeTag.UINT64,
         TypeTag.UINT128,
-        TypeTag.FIELD,
       ].includes(tagNumber)
     ) {
       throw new InvalidTagValueError(tagNumber);
@@ -380,21 +396,23 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public static getTag(v: MemoryValue | undefined): TypeTag {
     let tag = TypeTag.INVALID;
 
+    // Not sure why, but using instanceof here doesn't work and leads odd behavior,
+    // but using constructor.name does the job...
     if (v === undefined) {
       tag = TypeTag.FIELD; // uninitialized memory is Field(0)
-    } else if (v instanceof Field) {
+    } else if (v.constructor.name == 'Field') {
       tag = TypeTag.FIELD;
-    } else if (v instanceof Uint1) {
+    } else if (v.constructor.name == 'Uint1') {
       tag = TypeTag.UINT1;
-    } else if (v instanceof Uint8) {
+    } else if (v.constructor.name == 'Uint8') {
       tag = TypeTag.UINT8;
-    } else if (v instanceof Uint16) {
+    } else if (v.constructor.name == 'Uint16') {
       tag = TypeTag.UINT16;
-    } else if (v instanceof Uint32) {
+    } else if (v.constructor.name == 'Uint32') {
       tag = TypeTag.UINT32;
-    } else if (v instanceof Uint64) {
+    } else if (v.constructor.name == 'Uint64') {
       tag = TypeTag.UINT64;
-    } else if (v instanceof Uint128) {
+    } else if (v.constructor.name == 'Uint128') {
       tag = TypeTag.UINT128;
     }
 

package/src/avm/avm_simulator.ts

@@ -97,25 +97,22 @@ export class AvmSimulator {
    * 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);
-    if (!bytecode) {
-      // revert, consuming all gas
-      const message = `No bytecode found at: ${this.context.environment.address}. Reverting...`;
-      const fnName = await this.context.persistableState.getPublicFunctionDebugName(this.context.environment);
-      const revertReason = new AvmRevertReason(
-        message,
-        /*failingFunction=*/ {
-          contractAddress: this.context.environment.address,
-          functionName: fnName,
-        },
-        /*noirCallStack=*/ [],
+    let bytecode: Buffer | undefined;
+    try {
+      bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
+    } catch (err: any) {
+      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
+        this.log.error(`Unknown error thrown by AVM during bytecode retrieval: ${err}`);
+        throw err;
+      }
+      return await this.handleFailureToRetrieveBytecode(
+        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`,
       );
-      this.log.warn(message);
-      return new AvmContractCallResult(
-        /*reverted=*/ true,
-        /*output=*/ [],
-        /*gasLeft=*/ { l2Gas: 0, daGas: 0 },
-        revertReason,
+    }
+
+    if (!bytecode) {
+      return await this.handleFailureToRetrieveBytecode(
+        `No bytecode found at: ${this.context.environment.address}. Reverting...`,
       );
     }
 
@@ -189,14 +186,25 @@ export class AvmSimulator {
       return results;
     } catch (err: any) {
       this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
-      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
+      // FIXME: weird that we have to do this OutOfGasError check because:
+      // 1. OutOfGasError is an AvmExecutionError, so that check should cover both
+      // 2. We should at least be able to do instanceof OutOfGasError instead of checking the constructor name
+      if (
+        !(
+          err.constructor.name == 'OutOfGasError' ||
+          err instanceof AvmExecutionError ||
+          err instanceof SideEffectLimitReachedError
+        )
+      ) {
         this.log.error(`Unknown error thrown by AVM: ${err}`);
         throw err;
       }
 
       const revertReason = await revertReasonFromExceptionalHalt(err, this.context);
+      // Exceptional halts consume all allocated gas
+      const noGasLeft = { l2Gas: 0, daGas: 0 };
       // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], machineState.gasLeft, revertReason);
+      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], noGasLeft, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.tallyPrintFunction();
@@ -205,6 +213,26 @@ export class AvmSimulator {
     }
   }
 
+  private async handleFailureToRetrieveBytecode(message: string): Promise<AvmContractCallResult> {
+    // revert, consuming all gas
+    const fnName = await this.context.persistableState.getPublicFunctionDebugName(this.context.environment);
+    const revertReason = new AvmRevertReason(
+      message,
+      /*failingFunction=*/ {
+        contractAddress: this.context.environment.address,
+        functionName: fnName,
+      },
+      /*noirCallStack=*/ [],
+    );
+    this.log.warn(message);
+    return new AvmContractCallResult(
+      /*reverted=*/ true,
+      /*output=*/ [],
+      /*gasLeft=*/ { l2Gas: 0, daGas: 0 }, // consumes all allocated gas
+      revertReason,
+    );
+  }
+
   private tallyInstruction(pc: number, opcode: string, gasUsed: Gas) {
     const opcodeTally = this.opcodeTallies.get(opcode) || ({ count: 0, gas: { l2Gas: 0, daGas: 0 } } as OpcodeTally);
     opcodeTally.count++;

package/src/avm/avm_tree.ts

@@ -1,5 +1,5 @@
-import { type IndexedTreeId, MerkleTreeId, type MerkleTreeReadOperations, getTreeHeight } from '@aztec/circuit-types';
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/circuits.js';
+import { type IndexedTreeId, MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/circuits.js';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type IndexedTreeLeafPreimage, type TreeLeafPreimage } from '@aztec/foundation/trees';
@@ -398,35 +398,36 @@ export class AvmEphemeralForest {
     // 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);
+
+    // Then we search on the external DB
+    const leafOrLowLeafWitnessFromExternalDb: GetLeafResult<T> = await this._getLeafOrLowLeafWitnessInExternalDb(
+      treeId,
+      bigIntKey,
+    );
+
+    // If the indexed updates are empty, we can return the leaf from the DB
     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: GetLeafResult<T> = await this._getLeafOrLowLeafWitnessInExternalDb(
-        treeId,
-        bigIntKey,
-      );
-      return [leafOrLowLeafPreimage, /*pathAbsentInEphemeralTree=*/ true];
+      return [leafOrLowLeafWitnessFromExternalDb, /*pathAbsentInEphemeralTree=*/ true];
+    }
+
+    // Otherwise, we return the closest one. First fetch the leaf from the indexed updates.
+    const minIndexedUpdate: T = this.getIndexedUpdate(treeId, minIndexedLeafIndex);
+
+    // And get both keys
+    const keyFromIndexed = minIndexedUpdate.getKey();
+    const keyFromExternal = leafOrLowLeafWitnessFromExternalDb.preimage.getKey();
+
+    if (keyFromExternal > keyFromIndexed) {
+      // this.log.debug(`Using leaf from external DB for ${MerkleTreeId[treeId]}`);
+      return [leafOrLowLeafWitnessFromExternalDb, /*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, alreadyPresent: 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];
-      }
+      // this.log.debug(`Using leaf from indexed DB for ${MerkleTreeId[treeId]}`);
+      const leafInfo = {
+        preimage: minIndexedUpdate,
+        index: minIndexedLeafIndex,
+        alreadyPresent: keyFromIndexed === bigIntKey,
+      };
+      return [leafInfo, /*pathAbsentInEphemeralTree=*/ false];
     }
   }
 
@@ -480,69 +481,6 @@ export class AvmEphemeralForest {
     return { preimage: leafPreimage as T, index: leafIndex, alreadyPresent };
   }
 
-  /**
-   * 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 [
-   *     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)
-   * ]
-   *
-   * @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<[GetLeafResult<T> | undefined, /*pathAbsentInEphemeralTree=*/ boolean]> {
-    let found = false;
-    let curr = minPreimage as T;
-    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;
-    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;
-        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, alreadyPresent: false };
-      }
-      // Update the the values for the next iteration
-      else {
-        lowPublicDataIndex = curr.getNextIndex();
-        if (this.hasLocalUpdates(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++;
-    }
-    return [result, pathAbsentInEphemeralTree];
-  }
-
   /**
    * This hashes the preimage to a field element
    */
@@ -550,6 +488,11 @@ export class AvmEphemeralForest {
     const input = preimage.toHashInputs().map(x => Fr.fromBuffer(x));
     return poseidon2Hash(input);
   }
+
+  getTreeSnapshot(id: MerkleTreeId): AppendOnlyTreeSnapshot {
+    const tree = this.treeMap.get(id)!;
+    return new AppendOnlyTreeSnapshot(tree.getRoot(), Number(tree.leafCount));
+  }
 }
 
 /****************************************************/

package/src/avm/errors.ts

@@ -102,10 +102,21 @@ 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 {
+export class RelativeAddressOutOfRangeError extends AvmExecutionError {
   constructor(baseAddr: number, relOffset: number) {
     super(`Address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
-    this.name = 'AddressOutOfRangeError';
+    this.name = 'RelativeAddressOutOfRangeError';
+  }
+}
+
+/**
+ * Error is thrown when a memory slice contains addresses which are
+ * out of range, i.e, greater than maxUint32.
+ */
+export class MemorySliceOutOfRangeError extends AvmExecutionError {
+  constructor(baseAddr: number, size: number) {
+    super(`Memory slice is out of range. Base address ${baseAddr}, size ${size}`);
+    this.name = 'MemorySliceOutOfRangeError';
   }
 }
 

package/src/avm/fixtures/index.ts

@@ -1,10 +1,10 @@
-import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
+import { TxHash, isNoirCallStackUnresolved } from '@aztec/circuit-types';
 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';
 import { Fr } from '@aztec/foundation/fields';
-import { AvmTestContractArtifact } from '@aztec/noir-contracts.js';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
 
 import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
@@ -45,6 +45,7 @@ export function initPersistableStateManager(overrides?: {
   nullifiers?: NullifierManager;
   doMerkleOperations?: boolean;
   merkleTrees?: AvmEphemeralForest;
+  txHash?: TxHash;
 }): AvmPersistableStateManager {
   const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
   return new AvmPersistableStateManager(
@@ -54,6 +55,7 @@ export function initPersistableStateManager(overrides?: {
     overrides?.nullifiers || new NullifierManager(worldStateDB),
     overrides?.doMerkleOperations || false,
     overrides?.merkleTrees || mock<AvmEphemeralForest>(),
+    overrides?.txHash || new TxHash(new Fr(27).toBuffer()),
   );
 }