@aztec/simulator 0.85.0 → 0.86.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
@@ -19,8 +19,6 @@
     "build": "yarn clean && tsc -b",
     "build:dev": "tsc -b --watch",
     "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 --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -60,24 +58,24 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.85.0",
-    "@aztec/foundation": "0.85.0",
-    "@aztec/noir-acvm_js": "0.85.0",
-    "@aztec/noir-noirc_abi": "0.85.0",
-    "@aztec/noir-protocol-circuits-types": "0.85.0",
-    "@aztec/noir-types": "0.85.0",
-    "@aztec/protocol-contracts": "0.85.0",
-    "@aztec/stdlib": "0.85.0",
-    "@aztec/telemetry-client": "0.85.0",
-    "@aztec/world-state": "0.85.0",
+    "@aztec/constants": "0.86.0",
+    "@aztec/foundation": "0.86.0",
+    "@aztec/noir-acvm_js": "0.86.0",
+    "@aztec/noir-noirc_abi": "0.86.0",
+    "@aztec/noir-protocol-circuits-types": "0.86.0",
+    "@aztec/noir-types": "0.86.0",
+    "@aztec/protocol-contracts": "0.86.0",
+    "@aztec/stdlib": "0.86.0",
+    "@aztec/telemetry-client": "0.86.0",
+    "@aztec/world-state": "0.86.0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.85.0",
-    "@aztec/merkle-tree": "0.85.0",
-    "@aztec/noir-contracts.js": "0.85.0",
+    "@aztec/kv-store": "0.86.0",
+    "@aztec/merkle-tree": "0.86.0",
+    "@aztec/noir-contracts.js": "0.86.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/lodash.clonedeep": "^4.5.7",

package/src/private/providers/acvm_native.ts

@@ -123,14 +123,15 @@ export async function executeNativeCircuit(
       });
     });
 
-    const duration = new Timer();
+    const timer = new Timer();
     const output = await processPromise;
+    const duration = timer.ms();
     if (outputFilename) {
       const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
       await fs.copyFile(outputWitnessFileName, outputFilename);
     }
     const witness = parseIntoWitnessMap(output);
-    return { status: ACVM_RESULT.SUCCESS, witness, duration: duration.ms() };
+    return { status: ACVM_RESULT.SUCCESS, witness, duration };
   } catch (error) {
     return { status: ACVM_RESULT.FAILURE, reason: `${error}` };
   }
@@ -143,7 +144,7 @@ export class NativeACVMSimulator implements SimulationProvider {
     input: ACVMWitness,
     artifact: NoirCompiledCircuitWithName,
     callback: ForeignCallHandler | undefined,
-  ): Promise<ACVMWitness> {
+  ): Promise<ACVMSuccess> {
     // Execute the circuit on those initial witness values
 
     if (callback) {
@@ -166,7 +167,7 @@ export class NativeACVMSimulator implements SimulationProvider {
         throw new Error(`Failed to generate witness: ${result.reason}`);
       }
 
-      return result.witness;
+      return result;
     };
 
     return await runInDirectory(this.workingDirectory, operation, false, logger);

package/src/private/providers/acvm_wasm.ts

@@ -1,4 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
@@ -6,6 +7,7 @@ import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import { type ACIRCallback, type ACIRExecutionResult, acvm } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
 import { type SimulationProvider, enrichNoirError } from './simulation_provider.js';
 
 export class WASMSimulator implements SimulationProvider {
@@ -25,7 +27,7 @@ export class WASMSimulator implements SimulationProvider {
     input: ACVMWitness,
     artifact: NoirCompiledCircuitWithName,
     callback: ForeignCallHandler,
-  ): Promise<ACVMWitness> {
+  ): Promise<ACVMSuccess> {
     this.log.debug('init', { hash: artifact.hash });
     await this.init();
 
@@ -34,13 +36,14 @@ export class WASMSimulator implements SimulationProvider {
     //
     // Execute the circuit
     try {
+      const timer = new Timer();
       const result = await executeCircuit(
         decodedBytecode,
         input,
         callback, // handle calls to debug_log
       );
       this.log.debug('execution successful', { hash: artifact.hash });
-      return result;
+      return { witness: result, duration: timer.ms() } as ACVMSuccess;
     } catch (err) {
       // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
       // assertion payload.

package/src/private/providers/acvm_wasm_with_blobs.ts

@@ -1,3 +1,4 @@
+import { Timer } from '@aztec/foundation/timer';
 import { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import type { WitnessMap } from '@aztec/noir-types';
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
@@ -5,6 +6,7 @@ import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
 import { type SimulationProvider, enrichNoirError } from './simulation_provider.js';
 
 /**
@@ -19,19 +21,19 @@ export class WASMSimulatorWithBlobs implements SimulationProvider {
     input: WitnessMap,
     artifact: NoirCompiledCircuitWithName,
     callback: ForeignCallHandler,
-  ): Promise<WitnessMap> {
+  ): Promise<ACVMSuccess> {
     // Decode the bytecode from base64 since the acvm does not know about base64 encoding
     const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
     //
     // Execute the circuit
     try {
+      const timer = new Timer();
       const _witnessMap = await executeCircuit(
         decodedBytecode,
         input,
         callback, // handle calls to debug_log and evaluate_blobs mock
       );
-
-      return _witnessMap;
+      return { witness: _witnessMap, duration: timer.ms() } as ACVMSuccess;
     } catch (err) {
       // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
       // assertion payload.

package/src/private/providers/circuit_recording/simulation_provider_recorder_wrapper.ts

@@ -4,6 +4,7 @@ import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import type { ACIRCallback, ACIRExecutionResult } from '../../acvm/acvm.js';
 import type { ACVMWitness } from '../../acvm/acvm_types.js';
+import type { ACVMSuccess } from '../acvm_native.js';
 import type { SimulationProvider } from '../simulation_provider.js';
 import { CircuitRecorder } from './circuit_recorder.js';
 
@@ -18,10 +19,10 @@ export class SimulationProviderRecorderWrapper implements SimulationProvider {
     input: ACVMWitness,
     artifact: NoirCompiledCircuitWithName,
     callback: ForeignCallHandler | undefined,
-  ): Promise<ACVMWitness> {
+  ): Promise<ACVMSuccess> {
     const bytecode = Buffer.from(artifact.bytecode, 'base64');
 
-    return this.#simulate<ForeignCallHandler | undefined, ACVMWitness>(
+    return this.#simulate<ForeignCallHandler | undefined, ACVMSuccess>(
       wrappedCallback => this.simulator.executeProtocolCircuit(input, artifact, wrappedCallback),
       input,
       bytecode,

package/src/private/providers/simulation_provider.ts

@@ -6,6 +6,7 @@ import type { NoirCompiledCircuit, NoirCompiledCircuitWithName } from '@aztec/st
 
 import { type ACIRCallback, type ACIRExecutionResult, extractCallStack } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
 
 /**
  * Low level simulation interface
@@ -23,7 +24,7 @@ export interface SimulationProvider {
     input: ACVMWitness,
     artifact: NoirCompiledCircuitWithName,
     callback: ForeignCallHandler | undefined,
-  ): Promise<ACVMWitness>;
+  ): Promise<ACVMSuccess>;
 
   /**
    * Execute a user circuit (smart contract function)/generate a witness

package/src/public/avm/avm_context.ts

@@ -5,7 +5,7 @@ import type { PublicPersistableStateManager } from '../state_manager/state_manag
 import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
-import type { AvmSimulator } from './avm_simulator.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
 
 /**
  * An execution context includes the information necessary to initiate AVM
@@ -27,7 +27,7 @@ export class AvmContext {
 
   // This is needed to break a dependency cycle created by the CALL opcode,
   // which needs to create a new simulator but cannot depend directly on AvmSimulator.
-  public provideSimulator?: (ctx: this) => Promise<AvmSimulator>;
+  public provideSimulator?: (context: AvmContext) => Promise<AvmSimulatorInterface>;
 
   /**
    * Prepare a new AVM context that will be ready for an external/nested call

package/src/public/avm/avm_simulator.ts

@@ -13,14 +13,10 @@ 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 {
-  AvmExecutionError,
-  AvmRevertReason,
-  InvalidProgramCounterError,
-  revertReasonFromExceptionalHalt,
-  revertReasonFromExplicitRevert,
-} from './errors.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
+import { AvmExecutionError, AvmRevertReason, InvalidProgramCounterError } from './errors.js';
 import type { Instruction } from './opcodes/instruction.js';
+import { revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './revert_reason.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -32,7 +28,7 @@ type OpcodeTally = {
   gas: Gas;
 };
 
-export class AvmSimulator {
+export class AvmSimulator implements AvmSimulatorInterface {
   private log: Logger;
   private bytecode: Buffer | undefined;
   private opcodeTallies: Map<string, OpcodeTally> = new Map();

package/src/public/avm/avm_simulator_interface.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface for AvmSimulator to break the circular dependency between avm_context.ts and avm_simulator.ts
+ */
+export interface AvmSimulatorInterface {
+  execute(): Promise<any>; // Using any here to avoid importing AvmContractCallResult
+  executeBytecode(bytecode: Buffer): Promise<any>;
+  getBytecode(): Buffer | undefined;
+}

package/src/public/avm/errors.ts

@@ -1,9 +1,8 @@
-import type { Fr, Point } from '@aztec/foundation/fields';
+import type { Point } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
 import { ExecutionError } from '../../common/errors.js';
-import type { AvmContext } from './avm_context.js';
 
 /**
  * Avm-specific errors should derive from this
@@ -179,54 +178,3 @@ export class AvmRevertReason extends ExecutionError {
     super(message, failingFunction, noirCallStack, options);
   }
 }
-
-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 we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
-  let nestedError = undefined;
-  const revertDataEquals = (a: Fr[], b: Fr[]) => a.length === b.length && a.every((v, i) => v.equals(b[i]));
-  if (
-    context.machineState.collectedRevertInfo &&
-    revertDataEquals(context.machineState.collectedRevertInfo.revertDataRepresentative, revertData)
-  ) {
-    nestedError = context.machineState.collectedRevertInfo.recursiveRevertReason;
-    message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
-  }
-
-  const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
-
-  return new AvmRevertReason(
-    message,
-    /*failingFunction=*/ {
-      contractAddress: context.environment.address,
-      functionName: fnName,
-    },
-    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
-    /*options=*/ { cause: nestedError },
-  );
-}
-
-/**
- * Create a "revert reason" error for an exceptional halt.
- *
- * @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 async function revertReasonFromExceptionalHalt(
-  haltingError: AvmExecutionError,
-  context: AvmContext,
-): Promise<AvmRevertReason> {
-  return await createRevertReason(haltingError.message, [], context);
-}
-
-/**
- * Create a "revert reason" error for an explicit revert (a root cause).
- *
- * @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 async function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
-  return await createRevertReason('Assertion failed: ', revertData, context);
-}

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

@@ -16,11 +16,11 @@ import {
   initExecutionEnvironment,
   resolveContractAssertionMessage,
 } from '../../avm/fixtures/index.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 { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
-import { SimpleContractDataSource } from './simple_contract_data_source.js';
 
 const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);

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

@@ -11,8 +11,8 @@ import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
+import type { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
 import { createContractClassAndInstance } from './index.js';
-import type { SimpleContractDataSource } from './simple_contract_data_source.js';
 
 /**
  * An abstract test class that enables tests of real apps in the AVM without requiring e2e tests.

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

@@ -1,308 +1,2 @@
-import { DEPLOYER_CONTRACT_ADDRESS, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { AvmGadgetsTestContract } from '@aztec/noir-contracts.js/AvmGadgetsTest';
-import { AvmTestContract } from '@aztec/noir-contracts.js/AvmTest';
-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 { GasFees } from '@aztec/stdlib/gas';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import { deriveKeys } from '@aztec/stdlib/keys';
-import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-
-import { strict as assert } from 'assert';
-import { mock } from 'jest-mock-extended';
-import merge from 'lodash.merge';
-
-import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
-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 { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
-import { AvmSimulator } from '../avm_simulator.js';
-import type { AvmRevertReason } from '../errors.js';
-
-export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
-export const DEFAULT_BLOCK_NUMBER = 42;
-
-/**
- * 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;
-  doMerkleOperations?: boolean;
-  firstNullifier?: Fr;
-  blockNumber?: number;
-}): 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?.blockNumber || DEFAULT_BLOCK_NUMBER,
-    overrides?.doMerkleOperations || false,
-    overrides?.publicStorage,
-    overrides?.nullifiers,
-  );
-}
-
-/**
- * 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 ?? [],
-  );
-}
-
-/**
- * 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 ?? Fr.zero(),
-    overrides?.slotNumber ?? Fr.zero(),
-    overrides?.timestamp ?? Fr.zero(),
-    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 ?? MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
-    daGasLeft: overrides?.daGasLeft ?? 1e8,
-  });
-}
-
-/**
- * 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);
-}
-
-export function getAvmTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
-  return getFunctionSelector(functionName, AvmTestContract.artifactForPublic);
-}
-
-export function getAvmGadgetsTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
-  const artifact = getAllFunctionAbis(AvmGadgetsTestContract.artifactForPublic).find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmGadgetsTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
-}
-
-export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = getContractFunctionArtifact(functionName, AvmTestContract.artifactForPublic) as FunctionArtifact;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact;
-}
-
-export function getAvmGadgetsTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = AvmGadgetsTestContract.artifactForPublic.functions.find(f => f.name === functionName)!;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact;
-}
-
-export function getAvmTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmTestContractArtifact(functionName);
-  return artifact.bytecode;
-}
-
-export function getAvmGadgetsTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmGadgetsTestContractArtifact(functionName);
-  return artifact.bytecode;
-}
-
-export function resolveAvmTestContractAssertionMessage(
-  functionName: string,
-  revertReason: AvmRevertReason,
-  output: Fr[],
-): string | undefined {
-  return resolveContractAssertionMessage(functionName, revertReason, output, AvmTestContract.artifactForPublic);
-}
-
-export function resolveAvmGadgetsTestContractAssertionMessage(
-  functionName: string,
-  revertReason: AvmRevertReason,
-  output: Fr[],
-): string | undefined {
-  traverseCauseChain(revertReason, cause => {
-    revertReason = cause as AvmRevertReason;
-  });
-
-  const functionArtifact = AvmGadgetsTestContract.artifactForPublic.functions.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,
-  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(seed, bytecode);
-
-  const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
-  const { publicKeys } = await deriveKeys(Fr.random());
-  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(DEPLOYER_CONTRACT_ADDRESS),
-    contractInstance.address.toField(),
-  );
-
-  return { contractClass, contractInstance, contractAddressNullifier };
-}
+export * from './initializers.js';
+export * from './utils.js';