@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/public/avm/errors.ts

@@ -1,27 +1,19 @@
-import type { Fr, Point } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Point } from '@aztec/foundation/fields';
 import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
 import { ExecutionError } from '../../common/errors.js';
-import type { AvmContext } from './avm_context.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
 
 /**
  * Avm-specific errors should derive from this
  */
-export abstract class AvmExecutionError extends Error {
+export abstract class AvmExecutionError extends CheckedPublicExecutionError {
   constructor(message: string) {
     super(message);
     this.name = 'AvmExecutionError';
   }
 }
 
-export class NoBytecodeForContractError extends AvmExecutionError {
-  constructor(contractAddress: AztecAddress) {
-    super(`No bytecode found at: ${contractAddress}`);
-    this.name = 'NoBytecodeFoundInterpreterError';
-  }
-}
-
 export class ArithmeticError extends AvmExecutionError {
   constructor(message: string) {
     super(message);
@@ -130,22 +122,12 @@ export class OutOfGasError extends AvmExecutionError {
 }
 
 /**
- * Error is thrown when the supplied points length is not a multiple of 3. Specific for MSM opcode.
+ * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for ECADD opcode.
  */
-export class MSMPointsLengthError extends AvmExecutionError {
-  constructor(pointsReadLength: number) {
-    super(`Points vector length should be a multiple of 3, was ${pointsReadLength}`);
-    this.name = 'MSMPointsLengthError';
-  }
-}
-
-/**
- * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for MSM opcode.
- */
-export class MSMPointNotOnCurveError extends AvmExecutionError {
-  constructor(point: Point) {
-    super(`Point ${point.toString()} is not on the curve.`);
-    this.name = 'MSMPointNotOnCurveError';
+export class EcAddPointNotOnCurveError extends AvmExecutionError {
+  constructor(pointIndex: number, point: Point) {
+    super(`EcAdd point${pointIndex} (${point.toString()}) is not on the curve.`);
+    this.name = 'EcAddPointNotOnCurveError';
   }
 }
 
@@ -179,54 +161,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

@@ -1,5 +1,6 @@
 import { Fr } from '@aztec/foundation/fields';
 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,19 @@ 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 { 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 +33,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 +73,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,
       globals,
       address,
       sender,
       isStaticCall,
+      config,
     });
     const persistableState = await this.stateManager.fork();
     const context = initContext({ env: environment, persistableState });

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

@@ -1,18 +1,20 @@
-import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 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,102 @@
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+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 { 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 ?? [],
+    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 ?? 0,
+    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,150 @@
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+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 = 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';