@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/public/avm/fixtures/account_proof_fetcher.ts

@@ -0,0 +1,166 @@
+/**
+ * Fetches an account proof from the Ethereum mainnet and saves it as account_proof.json.
+ * This script is not using any Aztec library code, so it's easily portable.
+ */
+import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, fromRlp, hexToBytes, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RPC_URL = process.env.RPC_URL;
+const ADDRESS = (process.env.ADDRESS || '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045') as `0x${string}`;
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+
+function padTo(arr: number[], len: number) {
+  return [...arr, ...Array(len - arr.length).fill(0)].slice(0, len);
+}
+
+function toBytes(hex: `0x${string}`) {
+  return Array.from(hexToBytes(hex));
+}
+
+function bytesToU64s(bytes: number[]) {
+  const paddedBytes = padTo(bytes, 32);
+  return Array.from({ length: 4 }, (_, i) => {
+    let val = 0n;
+    for (let j = 0; j < 8; j++) {
+      val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+    }
+    return val.toString();
+  });
+}
+
+function toBytesAndLen(val: bigint | number) {
+  if (val === 0n || val === 0) {
+    return { bytes: [0], length: 0 };
+  }
+  let hex = val.toString(16);
+  if (hex.length % 2) {
+    hex = '0' + hex;
+  }
+  const bytes = toBytes(`0x${hex}`);
+  return { bytes, length: bytes.length };
+}
+
+function parseNode(rlp: `0x${string}`) {
+  // Should be safe when working with branches and extensions without embedded children.
+  const decoded = fromRlp(rlp) as `0x${string}`[];
+  const node = {
+    rows: Array(16)
+      .fill(0)
+      .map(() => Array(32).fill(0)),
+    row_exist: Array(16).fill(false),
+    node_type: 0,
+  };
+
+  if (decoded.length === 17) {
+    for (let i = 0; i < 16; i++) {
+      if (decoded[i] !== '0x') {
+        node.row_exist[i] = true;
+        node.rows[i] = padTo(toBytes(decoded[i]), 32);
+      }
+    }
+  } else if (decoded.length === 2) {
+    const keyBytes = toBytes(decoded[0]);
+    const prefix = keyBytes[0];
+    if (prefix >> 4 >= 2) {
+      throw new Error('Unsupported: leaf node in proof path');
+    }
+    node.node_type = 1;
+    // Extension header format expected by the noir code: check out storage_proof types.nr.
+    node.rows[0][0] = prefix >> 4;
+    node.rows[0][8] = prefix & 0x0f;
+    node.rows[0][16] = keyBytes.length - 1;
+
+    for (let i = 1; i < keyBytes.length && i < 32; i++) {
+      node.rows[1][i - 1] = keyBytes[i];
+    }
+    node.rows[2] = padTo(toBytes(decoded[1]), 32);
+    node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+  }
+  return node;
+}
+
+function parseProof(proof: `0x${string}`[], maxLen: number) {
+  const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+  while (nodes.length < maxLen) {
+    nodes.push({
+      rows: Array(16)
+        .fill(0)
+        .map(() => Array(32).fill(0)),
+      row_exist: Array(16).fill(false),
+      node_type: 0,
+    });
+  }
+  return nodes;
+}
+
+function nodeToLibFormat(node: { rows: number[][]; row_exist: boolean[]; node_type: number }) {
+  return {
+    rows: node.rows.map(bytesToU64s),
+    row_exist: node.row_exist,
+    node_type: String(node.node_type),
+  };
+}
+
+async function main() {
+  if (!RPC_URL) {
+    throw new Error('RPC_URL is not set');
+  }
+  console.log(`Fetching account proof for ${ADDRESS}`);
+
+  const client = createPublicClient({
+    chain: mainnet,
+    transport: http(RPC_URL),
+  });
+
+  const [blockNumber, proof, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getProof({
+      address: ADDRESS,
+      storageKeys: [],
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+    client.getBlock({
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+  ]);
+
+  console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}`);
+
+  // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+  const accountPathLen = proof.accountProof.length - 1;
+  if (accountPathLen > MAX_ACCOUNT_PATH) {
+    throw new Error(
+      `Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`,
+    );
+  }
+
+  const nonce = toBytesAndLen(proof.nonce);
+  const balance = toBytesAndLen(proof.balance);
+
+  const data = {
+    block_number: String(blockNumber),
+    node_length: String(accountPathLen),
+    root: bytesToU64s(toBytes(block.stateRoot)),
+    nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+    account: {
+      address: toBytes(ADDRESS).map(String),
+      balance: padTo(balance.bytes, 32).map(String),
+      balance_length: String(balance.length),
+      code_hash: bytesToU64s(toBytes(proof.codeHash)),
+      nonce: padTo(nonce.bytes, 8).map(String),
+      nonce_length: String(nonce.length),
+      storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+    },
+  };
+
+  fs.writeFileSync(join(__dirname, 'account_proof.json'), JSON.stringify(data, null, 2));
+  console.log('account_proof.json generated');
+}
+
+main().catch(console.error);

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -1,5 +1,6 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { encodeArguments } from '@aztec/stdlib/abi';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
@@ -8,20 +9,20 @@ import { NativeWorldStateService } from '@aztec/world-state';
 
 import { SideEffectTrace } from '../../../public/side_effect_trace.js';
 import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
+import { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
+import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
+import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
+import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
+import { initContext, initExecutionEnvironment } from './initializers.js';
 import {
-  getContractFunctionArtifact,
+  DEFAULT_TIMESTAMP,
+  getContractFunctionAbi,
   getFunctionSelector,
-  initContext,
-  initExecutionEnvironment,
   resolveContractAssertionMessage,
-} from '../../avm/fixtures/index.js';
-import { AvmPersistableStateManager } from '../../avm/journal/journal.js';
-import { WorldStateDB } from '../../public_db_sources.js';
-import { AvmSimulator } from '../avm_simulator.js';
-import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
-import { SimpleContractDataSource } from './simple_contract_data_source.js';
+} from './utils.js';
 
-const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
 
 /**
@@ -33,24 +34,27 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
   constructor(
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
-    private stateManager: AvmPersistableStateManager,
+    private stateManager: PublicPersistableStateManager,
   ) {
     super(contractDataSource, merkleTrees);
   }
 
-  static async create(): Promise<AvmSimulationTester> {
+  static async create(
+    worldStateService: NativeWorldStateService, // make sure to close this later
+  ): Promise<AvmSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+    const merkleTrees = await worldStateService.fork();
+    const treesDB = new PublicTreesDB(merkleTrees);
+    const contractsDB = new PublicContractsDB(contractDataSource);
     const trace = new SideEffectTrace();
     const firstNullifier = new Fr(420000);
-    // FIXME: merkle ops should work, but I'm seeing frequent (but inconsistent) bytecode retrieval
-    // failures on 2nd call to simulateCall with merkle ops on
-    const stateManager = AvmPersistableStateManager.create(
-      worldStateDB,
+
+    const stateManager = PublicPersistableStateManager.create(
+      treesDB,
+      contractsDB,
       trace,
-      /*doMerkleOperations=*/ false,
       firstNullifier,
+      DEFAULT_TIMESTAMP,
     );
     return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
   }
@@ -70,20 +74,28 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       throw new Error(`Contract not found at address: ${address}`);
     }
     const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
+    const fnAbi = getContractFunctionAbi(fnName, contractArtifact);
     const encodedArgs = encodeArguments(fnAbi!, args);
     const calldata = [fnSelector.toField(), ...encodedArgs];
 
     const globals = GlobalVariables.empty();
-    globals.timestamp = TIMESTAMP;
+    globals.timestamp = DEFAULT_TIMESTAMP;
     globals.gasFees = DEFAULT_GAS_FEES;
 
+    const config = PublicSimulatorConfig.from({
+      skipFeeEnforcement: false,
+      collectDebugLogs: true,
+      collectHints: false,
+      collectStatistics: false,
+      collectCallMetadata: true,
+    });
     const environment = initExecutionEnvironment({
-      calldata,
+      calldata: new CallDataArray(calldata),
       globals,
       address,
       sender,
       isStaticCall,
+      config,
     });
     const persistableState = await this.stateManager.fork();
     const context = initContext({ env: environment, persistableState });
@@ -94,7 +106,12 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
     if (result.reverted) {
       this.logger.error(`Error in ${fnName}:`);
       this.logger.error(
-        resolveContractAssertionMessage(fnName, result.revertReason!, result.output, contractArtifact)!,
+        resolveContractAssertionMessage(
+          fnName,
+          result.revertReason!,
+          result.output.bestEffortReadAll(),
+          contractArtifact,
+        )!,
       );
     } else {
       this.logger.info(`Simulation of function ${fnName} succeeded!`);

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -1,18 +1,20 @@
-import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
 import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { getCanonicalInstanceRegistry } from '@aztec/protocol-contracts/instance-registry';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
-import { createContractClassAndInstance } from './index.js';
-import type { SimpleContractDataSource } from './simple_contract_data_source.js';
+import type { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
+import { createContractClassAndInstance } from './utils.js';
 
 /**
  * An abstract test class that enables tests of real apps in the AVM without requiring e2e tests.
@@ -44,7 +46,7 @@ export abstract class BaseAvmSimulationTester {
     const leafSlot = await computePublicDataTreeLeafSlot(address, slot);
     // get existing preimage
     const publicDataWrite = new PublicDataWrite(leafSlot, value);
-    await this.merkleTrees.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()], 0);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
   }
 
   /**
@@ -57,6 +59,7 @@ export abstract class BaseAvmSimulationTester {
     contractArtifact: ContractArtifact,
     skipNullifierInsertion = false,
     seed = 0,
+    contractClassSeed = seed,
     originalContractClassId?: Fr, // if previously upgraded
   ): Promise<ContractInstanceWithAddress> {
     const { contractClass, contractInstance } = await createContractClassAndInstance(
@@ -64,6 +67,7 @@ export abstract class BaseAvmSimulationTester {
       deployer,
       contractArtifact,
       seed,
+      contractClassSeed,
       originalContractClassId,
     );
 
@@ -80,16 +84,40 @@ export abstract class BaseAvmSimulationTester {
     const feeJuiceContractClassPublic = {
       ...feeJuice.contractClass,
       privateFunctions: [],
-      unconstrainedFunctions: [],
+      utilityFunctions: [],
     };
     await this.contractDataSource.addNewContract(feeJuice.artifact, feeJuiceContractClassPublic, feeJuice.instance);
     return feeJuice.instance;
   }
 
-  addContractClass(contractClass: ContractClassPublic, contractArtifact: ContractArtifact): Promise<void> {
-    this.logger.debug(`Adding contract class with Id ${contractClass.id}`);
-    this.contractDataSource.addContractArtifact(contractClass.id, contractArtifact);
-    return this.contractDataSource.addContractClass(contractClass);
+  async registerAuthContract(): Promise<ContractInstanceWithAddress> {
+    const authRegistry = await getCanonicalAuthRegistry();
+    const authRegistryContractClassPublic = {
+      ...authRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      authRegistry.artifact,
+      authRegistryContractClassPublic,
+      authRegistry.instance,
+    );
+    return authRegistry.instance;
+  }
+
+  async registerInstanceRegistryContract(): Promise<ContractInstanceWithAddress> {
+    const instanceRegistry = await getCanonicalInstanceRegistry();
+    const instanceRegistryContractClassPublic = {
+      ...instanceRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      instanceRegistry.artifact,
+      instanceRegistryContractClassPublic,
+      instanceRegistry.instance,
+    );
+    return instanceRegistry.instance;
   }
 
   async addContractInstance(contractInstance: ContractInstanceWithAddress, skipNullifierInsertion = false) {
@@ -101,9 +129,14 @@ export abstract class BaseAvmSimulationTester {
 
   private async insertContractAddressNullifier(contractAddress: AztecAddress) {
     const contractAddressNullifier = await siloNullifier(
-      AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+      AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
       contractAddress.toField(),
     );
-    await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);
+  }
+
+  async insertNullifier(contractThatEmitted: AztecAddress, nullifier: Fr) {
+    const siloedNullifier = await siloNullifier(contractThatEmitted, nullifier);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
   }
 }

package/src/public/avm/fixtures/initializers.ts

@@ -0,0 +1,103 @@
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import { mock } from 'jest-mock-extended';
+
+import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
+import { NullifierManager } from '../../state_manager/nullifiers.js';
+import { PublicStorage } from '../../state_manager/public_storage.js';
+import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
+import { AvmContext } from '../avm_context.js';
+import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmMachineState } from '../avm_machine_state.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
+import { DEFAULT_TIMESTAMP } from './utils.js';
+
+/**
+ * Create a new AVM context with default values.
+ */
+export function initContext(overrides?: {
+  persistableState?: PublicPersistableStateManager;
+  env?: AvmExecutionEnvironment;
+  machineState?: AvmMachineState;
+}): AvmContext {
+  const ctx = new AvmContext(
+    overrides?.persistableState || initPersistableStateManager(),
+    overrides?.env || initExecutionEnvironment(),
+    overrides?.machineState || initMachineState(),
+  );
+  ctx.provideSimulator = AvmSimulator.build;
+  return ctx;
+}
+
+/** Creates an empty state manager with mocked host storage. */
+export function initPersistableStateManager(overrides?: {
+  treesDB?: PublicTreesDB;
+  contractsDB?: PublicContractsDB;
+  trace?: PublicSideEffectTraceInterface;
+  publicStorage?: PublicStorage;
+  nullifiers?: NullifierManager;
+  firstNullifier?: Fr;
+  timestamp?: UInt64;
+}): PublicPersistableStateManager {
+  const treesDB = overrides?.treesDB || mock<PublicTreesDB>();
+  return new PublicPersistableStateManager(
+    treesDB,
+    overrides?.contractsDB || mock<PublicContractsDB>(),
+    overrides?.trace || mock<PublicSideEffectTraceInterface>(),
+    overrides?.firstNullifier || new Fr(27),
+    overrides?.timestamp || DEFAULT_TIMESTAMP,
+    /*doMerkleOperations=*/ false,
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnvironment>): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    overrides?.address ?? AztecAddress.zero(),
+    overrides?.sender ?? AztecAddress.zero(),
+    overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.transactionFee ?? Fr.zero(),
+    overrides?.globals ?? GlobalVariables.empty(),
+    overrides?.isStaticCall ?? false,
+    overrides?.calldata ?? new CallDataArray([]),
+    overrides?.config ?? PublicSimulatorConfig.empty(),
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initGlobalVariables(overrides?: Partial<GlobalVariables>): GlobalVariables {
+  return new GlobalVariables(
+    overrides?.chainId ?? Fr.zero(),
+    overrides?.version ?? Fr.zero(),
+    overrides?.blockNumber ?? BlockNumber.ZERO,
+    overrides?.slotNumber ?? SlotNumber.ZERO,
+    overrides?.timestamp ?? 0n,
+    overrides?.coinbase ?? EthAddress.ZERO,
+    overrides?.feeRecipient ?? AztecAddress.zero(),
+    overrides?.gasFees ?? GasFees.empty(),
+  );
+}
+
+/**
+ * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
+ */
+export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
+  return AvmMachineState.fromState({
+    l2GasLeft: overrides?.l2GasLeft ?? AVM_MAX_PROCESSABLE_L2_GAS,
+    daGasLeft: overrides?.daGasLeft ?? 1e8,
+  });
+}

package/src/public/avm/fixtures/utils.ts

@@ -0,0 +1,151 @@
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  type FunctionArtifact,
+  FunctionSelector,
+  getAllFunctionAbis,
+} from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  computeInitializationHash,
+} from '@aztec/stdlib/contract';
+import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import { deriveKeys } from '@aztec/stdlib/keys';
+import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import { strict as assert } from 'assert';
+import merge from 'lodash.merge';
+
+import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
+import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import type { AvmRevertReason } from '../errors.js';
+
+export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+export const DEFAULT_TIMESTAMP: UInt64 = 99833n;
+export const DEFAULT_BLOCK_NUMBER = BlockNumber(42);
+
+/**
+ * Create a new object with all the same properties as the original, except for the ones in the overrides object.
+ */
+export function allSameExcept(original: any, overrides: any): any {
+  return merge({}, original, overrides);
+}
+
+export function randomMemoryBytes(length: number): Uint8[] {
+  return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryUint32s(length: number): Uint32[] {
+  return [...Array(length)].map(_ => new Uint32(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryUint64s(length: number): Uint64[] {
+  return [...Array(length)].map(_ => new Uint64(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryFields(length: number): Field[] {
+  return [...Array(length)].map(_ => new Field(Fr.random()));
+}
+
+export function getFunctionSelector(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): Promise<FunctionSelector> {
+  const fnArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName)!;
+  assert(!!fnArtifact, `Function ${functionName} not found in ${contractArtifact.name}`);
+  const params = fnArtifact.parameters;
+  return FunctionSelector.fromNameAndParameters(fnArtifact.name, params);
+}
+
+export function getContractFunctionArtifact(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): FunctionArtifact | undefined {
+  return contractArtifact.functions.find(f => f.name === functionName);
+}
+
+export function getContractFunctionAbi(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): FunctionAbi | undefined {
+  return (
+    contractArtifact.functions.find(f => f.name === functionName) ??
+    contractArtifact.nonDispatchPublicFunctions.find(f => f.name === functionName)
+  );
+}
+
+export function resolveContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+  contractArtifact: ContractArtifact,
+): string | undefined {
+  traverseCauseChain(revertReason, cause => {
+    revertReason = cause as AvmRevertReason;
+  });
+
+  const functionArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName);
+  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
+    return undefined;
+  }
+
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
+}
+
+/**
+ * Create a contract class and instance given constructor args, artifact, etc.
+ * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
+ * @param constructorArgs - The constructor arguments for the contract.
+ * @param deployer - The deployer of the contract.
+ * @param contractArtifact - The contract artifact for the contract.
+ * @param seed - The seed for the contract.
+ * @param originalContractClassId - The original contract class ID (if upgraded)
+ * @returns The contract class, instance, and contract address nullifier.
+ */
+export async function createContractClassAndInstance(
+  constructorArgs: any[],
+  deployer: AztecAddress,
+  contractArtifact: ContractArtifact,
+  seed = 0,
+  contractClassSeed = seed,
+  originalContractClassId?: Fr, // if previously upgraded
+): Promise<{
+  contractClass: ContractClassPublic;
+  contractInstance: ContractInstanceWithAddress;
+  contractAddressNullifier: Fr;
+}> {
+  const bytecode = (getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact) as FunctionArtifact)!
+    .bytecode;
+  const contractClass = await makeContractClassPublic(contractClassSeed, bytecode);
+
+  const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
+  const { publicKeys } = await deriveKeys(new Fr(seed));
+  const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+  const contractInstance =
+    originalContractClassId === undefined
+      ? await makeContractInstanceFromClassId(contractClass.id, seed, {
+          deployer,
+          initializationHash,
+          publicKeys,
+        })
+      : await makeContractInstanceFromClassId(originalContractClassId, seed, {
+          deployer,
+          initializationHash,
+          currentClassId: contractClass.id,
+          publicKeys,
+        });
+
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    contractInstance.address.toField(),
+  );
+
+  return { contractClass, contractInstance, contractAddressNullifier };
+}

package/src/public/avm/index.ts

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