@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/public/avm/errors.js

@@ -0,0 +1,179 @@
+import { ExecutionError } from '../../common/errors.js';
+/**
+ * Avm-specific errors should derive from this
+ */ export class AvmExecutionError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'AvmExecutionError';
+    }
+}
+export class NoBytecodeForContractError extends AvmExecutionError {
+    constructor(contractAddress){
+        super(`No bytecode found at: ${contractAddress}`);
+        this.name = 'NoBytecodeFoundInterpreterError';
+    }
+}
+export class ArithmeticError extends AvmExecutionError {
+    constructor(message){
+        super(message);
+        this.name = 'ArithmeticError';
+    }
+}
+/**
+ * Error is thrown when the program counter goes to an invalid location.
+ * There is no instruction at the provided pc
+ */ export class InvalidProgramCounterError extends AvmExecutionError {
+    constructor(pc, max){
+        super(`Invalid program counter ${pc}, max is ${max}`);
+        this.name = 'InvalidProgramCounterError';
+    }
+}
+/**
+ * Error is thrown when the program counter points to a byte
+ * of an invalid opcode.
+ */ export class InvalidOpcodeError extends AvmExecutionError {
+    constructor(str){
+        super(str);
+        this.name = 'InvalidOpcodeError';
+    }
+}
+/**
+ * Error is thrown during parsing.
+ */ export class AvmParsingError extends AvmExecutionError {
+    constructor(str){
+        super(str);
+        this.name = 'AvmParsingError';
+    }
+}
+/**
+ * Error is thrown when the tag has an invalid value.
+ */ export class InvalidTagValueError extends AvmExecutionError {
+    constructor(tagValue){
+        super(`Tag value ${tagValue} is invalid.`);
+        this.name = 'InvalidTagValueError';
+    }
+}
+/**
+ * Error thrown during an instruction's execution (during its execute()).
+ */ export class InstructionExecutionError extends AvmExecutionError {
+    constructor(message){
+        super(message);
+        this.name = 'InstructionExecutionError';
+    }
+}
+/**
+ * Error thrown on failed AVM memory tag check.
+ */ export class TagCheckError extends AvmExecutionError {
+    static forOffset(offset, gotTag, expectedTag) {
+        return new TagCheckError(`Tag mismatch at offset ${offset}, got ${gotTag}, expected ${expectedTag}`);
+    }
+    static forTag(gotTag, expectedTag) {
+        return new TagCheckError(`Tag mismatch, got ${gotTag}, expected ${expectedTag}`);
+    }
+    constructor(message){
+        super(message);
+        this.name = 'TagCheckError';
+    }
+}
+/**
+ * Error is thrown when a relative memory address resolved to an offset which
+ * is out of range, i.e, greater than maxUint32.
+ */ export class RelativeAddressOutOfRangeError extends AvmExecutionError {
+    constructor(baseAddr, relOffset){
+        super(`Address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
+        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, size){
+        super(`Memory slice is out of range. Base address ${baseAddr}, size ${size}`);
+        this.name = 'MemorySliceOutOfRangeError';
+    }
+}
+/** Error thrown when out of gas. */ export class OutOfGasError extends AvmExecutionError {
+    constructor(dimensions){
+        super(`Not enough ${dimensions.map((d)=>d.toUpperCase()).join(', ')} gas left`);
+        this.name = 'OutOfGasError';
+    }
+}
+/**
+ * Error is thrown when the supplied points length is not a multiple of 3. Specific for MSM opcode.
+ */ export class MSMPointsLengthError extends AvmExecutionError {
+    constructor(pointsReadLength){
+        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){
+        super(`Point ${point.toString()} is not on the curve.`);
+        this.name = 'MSMPointNotOnCurveError';
+    }
+}
+/**
+ * Error is thrown when some inputs of ToRadixBE are not valid.
+ */ export class InvalidToRadixInputsError extends AvmExecutionError {
+    constructor(errorString){
+        super(errorString);
+        this.name = 'InvalidToRadixInputsError';
+    }
+}
+/**
+ * Error is thrown when a static call attempts to alter some state
+ */ export class StaticCallAlterationError extends InstructionExecutionError {
+    constructor(){
+        super('Static call cannot update the state, emit L2->L1 messages or generate logs');
+        this.name = 'StaticCallAlterationError';
+    }
+}
+/**
+ * Meaningfully named alias for ExecutionError when used in the context of the AVM.
+ * Maintains a recursive structure reflecting the AVM's external callstack/errorstack, where
+ * options.cause is the error that caused this error (if this is not the root-cause itself).
+ */ export class AvmRevertReason extends ExecutionError {
+    constructor(message, failingFunction, noirCallStack, options){
+        super(message, failingFunction, noirCallStack, options);
+    }
+}
+async function createRevertReason(message, revertData, context) {
+    // 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, b)=>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, context) {
+    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, context) {
+    return await createRevertReason('Assertion failed: ', revertData, context);
+}

package/dest/{avm → public/avm}/fixtures/avm_simulation_tester.d.ts

@@ -1,7 +1,7 @@
-import { type MerkleTreeWriteOperations } from '@aztec/circuit-types';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
-import { AvmPersistableStateManager } from '../../server.js';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
+import { AvmPersistableStateManager } from '../../avm/journal/journal.js';
 import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
 /**
@@ -11,8 +11,8 @@ import { SimpleContractDataSource } from './simple_contract_data_source.js';
  */
 export declare class AvmSimulationTester extends BaseAvmSimulationTester {
     private stateManager;
-    constructor(contractDataSource: SimpleContractDataSource, merkleTrees: MerkleTreeWriteOperations, skipContractDeployments: boolean | undefined, stateManager: AvmPersistableStateManager);
-    static create(skipContractDeployments?: boolean): Promise<AvmSimulationTester>;
+    constructor(contractDataSource: SimpleContractDataSource, merkleTrees: MerkleTreeWriteOperations, stateManager: AvmPersistableStateManager);
+    static create(): Promise<AvmSimulationTester>;
     /**
      * Simulate a top-level contract call.
      */

package/dest/public/avm/fixtures/avm_simulation_tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulation_tester.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/fixtures/avm_simulation_tester.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAKjF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAQnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAG1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAK5E;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAI5D,OAAO,CAAC,YAAY;gBAFpB,kBAAkB,EAAE,wBAAwB,EAC5C,WAAW,EAAE,yBAAyB,EAC9B,YAAY,EAAE,0BAA0B;WAKrC,MAAM,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAiBnD;;OAEG;IACG,YAAY,CAChB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,GAAG,EAAE,EACX,YAAY,UAAQ,GACnB,OAAO,CAAC,qBAAqB,CAAC;CAsClC"}

package/dest/public/avm/fixtures/avm_simulation_tester.js

@@ -0,0 +1,76 @@
+import { Fr } from '@aztec/foundation/fields';
+import { encodeArguments } from '@aztec/stdlib/abi';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { NativeWorldStateService } from '@aztec/world-state';
+import { SideEffectTrace } from '../../../public/side_effect_trace.js';
+import { getContractFunctionArtifact, 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';
+const TIMESTAMP = new Fr(99833);
+const DEFAULT_GAS_FEES = new GasFees(2, 3);
+/**
+ * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the core AvmSimulator.
+ * It provides an interface for simulating one top-level call at a time and maintains state between
+ * subsequent top-level calls.
+ */ export class AvmSimulationTester extends BaseAvmSimulationTester {
+    stateManager;
+    constructor(contractDataSource, merkleTrees, stateManager){
+        super(contractDataSource, merkleTrees), this.stateManager = stateManager;
+    }
+    static async create() {
+        const contractDataSource = new SimpleContractDataSource();
+        const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
+        const worldStateDB = new WorldStateDB(merkleTrees, 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, trace, /*doMerkleOperations=*/ false, firstNullifier);
+        return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
+    }
+    /**
+   * Simulate a top-level contract call.
+   */ async simulateCall(sender, address, fnName, args, isStaticCall = false) {
+        const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+        if (!contractArtifact) {
+            throw new Error(`Contract not found at address: ${address}`);
+        }
+        const fnSelector = await getFunctionSelector(fnName, contractArtifact);
+        const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
+        const encodedArgs = encodeArguments(fnAbi, args);
+        const calldata = [
+            fnSelector.toField(),
+            ...encodedArgs
+        ];
+        const globals = GlobalVariables.empty();
+        globals.timestamp = TIMESTAMP;
+        globals.gasFees = DEFAULT_GAS_FEES;
+        const environment = initExecutionEnvironment({
+            calldata,
+            globals,
+            address,
+            sender,
+            isStaticCall
+        });
+        const persistableState = await this.stateManager.fork();
+        const context = initContext({
+            env: environment,
+            persistableState
+        });
+        // First we simulate (though it's not needed in this simple case).
+        const simulator = new AvmSimulator(context);
+        const result = await simulator.execute();
+        if (result.reverted) {
+            this.logger.error(`Error in ${fnName}:`);
+            this.logger.error(resolveContractAssertionMessage(fnName, result.revertReason, result.output, contractArtifact));
+        } else {
+            this.logger.info(`Simulation of function ${fnName} succeeded!`);
+            await this.stateManager.merge(persistableState);
+        }
+        return result;
+    }
+}

package/dest/{avm → public/avm}/fixtures/base_avm_simulation_tester.d.ts

@@ -1,9 +1,9 @@
-import { type MerkleTreeWriteOperations } from '@aztec/circuit-types';
-import { type ContractClassPublic, type ContractInstanceWithAddress } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
-import { type SimpleContractDataSource } from './simple_contract_data_source.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+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.
  * It enables this by letting us (1) perform pseudo-contract-deployments (and registrations)
@@ -18,18 +18,19 @@ import { type SimpleContractDataSource } from './simple_contract_data_source.js'
 export declare abstract class BaseAvmSimulationTester {
     contractDataSource: SimpleContractDataSource;
     merkleTrees: MerkleTreeWriteOperations;
-    private skipContractDeployments;
+    private initialFeePayerBalance;
     logger: import("@aztec/foundation/log").Logger;
-    constructor(contractDataSource: SimpleContractDataSource, merkleTrees: MerkleTreeWriteOperations, skipContractDeployments?: boolean);
-    setFeePayerBalance(feePayer: AztecAddress, balance: Fr): Promise<void>;
+    constructor(contractDataSource: SimpleContractDataSource, merkleTrees: MerkleTreeWriteOperations, initialFeePayerBalance?: Fr);
+    setFeePayerBalance(feePayer: AztecAddress, balance?: Fr): Promise<void>;
     setPublicStorage(address: AztecAddress, slot: Fr, value: Fr): Promise<void>;
     /**
      * Derive the contract class and instance with some seed.
      * Add both to the contract data source along with the contract artifact.
      */
-    registerAndDeployContract(constructorArgs: any[], deployer: AztecAddress, contractArtifact: ContractArtifact, seed?: number): Promise<ContractInstanceWithAddress>;
-    getFirstContractInstance(): ContractInstanceWithAddress;
+    registerAndDeployContract(constructorArgs: any[], deployer: AztecAddress, contractArtifact: ContractArtifact, skipNullifierInsertion?: boolean, seed?: number, originalContractClassId?: Fr): Promise<ContractInstanceWithAddress>;
+    registerFeeJuiceContract(): Promise<ContractInstanceWithAddress>;
     addContractClass(contractClass: ContractClassPublic, contractArtifact: ContractArtifact): Promise<void>;
-    addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void>;
+    addContractInstance(contractInstance: ContractInstanceWithAddress, skipNullifierInsertion?: boolean): Promise<void>;
+    private insertContractAddressNullifier;
 }
 //# sourceMappingURL=base_avm_simulation_tester.d.ts.map

package/dest/public/avm/fixtures/base_avm_simulation_tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_avm_simulation_tester.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/fixtures/base_avm_simulation_tester.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE/F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAIjF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,8BAAsB,uBAAuB;IAIlC,kBAAkB,EAAE,wBAAwB;IAC5C,WAAW,EAAE,yBAAyB;IAC7C,OAAO,CAAC,sBAAsB;IALzB,MAAM,yCAAyC;gBAG7C,kBAAkB,EAAE,wBAAwB,EAC5C,WAAW,EAAE,yBAAyB,EACrC,sBAAsB,KAAmB;IAG7C,kBAAkB,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,KAA8B;IAMhF,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAOjE;;;OAGG;IACG,yBAAyB,CAC7B,eAAe,EAAE,GAAG,EAAE,EACtB,QAAQ,EAAE,YAAY,EACtB,gBAAgB,EAAE,gBAAgB,EAClC,sBAAsB,UAAQ,EAC9B,IAAI,SAAI,EACR,uBAAuB,CAAC,EAAE,EAAE,GAC3B,OAAO,CAAC,2BAA2B,CAAC;IAiBjC,wBAAwB,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAWtE,gBAAgB,CAAC,aAAa,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMjG,mBAAmB,CAAC,gBAAgB,EAAE,2BAA2B,EAAE,sBAAsB,UAAQ;YAOzF,8BAA8B;CAO7C"}

package/dest/public/avm/fixtures/base_avm_simulation_tester.js

@@ -0,0 +1,83 @@
+import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { createContractClassAndInstance } from './index.js';
+/**
+ * An abstract test class that enables tests of real apps in the AVM without requiring e2e tests.
+ * It enables this by letting us (1) perform pseudo-contract-deployments (and registrations)
+ * that trigger merkle tree operations and (2) maintain a contract data source to store
+ * and retrieve contract classes and instances.
+ *
+ * This class is meant to be extended when writing tests for a specific simulation interface.
+ * For example, has been extended for testing of the core AvmSimulator, and again for the PublicTxSimulator,
+ * both of which benefit from such pseudo-deployments by populating merkle trees and a contract data source
+ * with contract information.
+ */ export class BaseAvmSimulationTester {
+    contractDataSource;
+    merkleTrees;
+    initialFeePayerBalance;
+    logger;
+    constructor(contractDataSource, merkleTrees, initialFeePayerBalance = new Fr(10 ** 10)){
+        this.contractDataSource = contractDataSource;
+        this.merkleTrees = merkleTrees;
+        this.initialFeePayerBalance = initialFeePayerBalance;
+        this.logger = createLogger('avm-simulation-tester');
+    }
+    async setFeePayerBalance(feePayer, balance = this.initialFeePayerBalance) {
+        const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
+        const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+        await this.setPublicStorage(feeJuiceAddress, balanceSlot, balance);
+    }
+    async setPublicStorage(address, slot, value) {
+        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);
+    }
+    /**
+   * Derive the contract class and instance with some seed.
+   * Add both to the contract data source along with the contract artifact.
+   */ async registerAndDeployContract(constructorArgs, deployer, contractArtifact, skipNullifierInsertion = false, seed = 0, originalContractClassId) {
+        const { contractClass, contractInstance } = await createContractClassAndInstance(constructorArgs, deployer, contractArtifact, seed, originalContractClassId);
+        await this.contractDataSource.addNewContract(contractArtifact, contractClass, contractInstance);
+        if (!skipNullifierInsertion) {
+            await this.insertContractAddressNullifier(contractInstance.address);
+        }
+        return contractInstance;
+    }
+    async registerFeeJuiceContract() {
+        const feeJuice = await getCanonicalFeeJuice();
+        const feeJuiceContractClassPublic = {
+            ...feeJuice.contractClass,
+            privateFunctions: [],
+            unconstrainedFunctions: []
+        };
+        await this.contractDataSource.addNewContract(feeJuice.artifact, feeJuiceContractClassPublic, feeJuice.instance);
+        return feeJuice.instance;
+    }
+    addContractClass(contractClass, contractArtifact) {
+        this.logger.debug(`Adding contract class with Id ${contractClass.id}`);
+        this.contractDataSource.addContractArtifact(contractClass.id, contractArtifact);
+        return this.contractDataSource.addContractClass(contractClass);
+    }
+    async addContractInstance(contractInstance, skipNullifierInsertion = false) {
+        if (!skipNullifierInsertion) {
+            await this.insertContractAddressNullifier(contractInstance.address);
+        }
+        await this.contractDataSource.addContractInstance(contractInstance);
+    }
+    async insertContractAddressNullifier(contractAddress) {
+        const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), contractAddress.toField());
+        await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [
+            contractAddressNullifier.toBuffer()
+        ], 0);
+    }
+}

package/dest/{avm → public/avm}/fixtures/index.d.ts

@@ -1,16 +1,18 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { GlobalVariables } from '@aztec/circuits.js';
-import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
-import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
-import { type WorldStateDB } from '../../server.js';
+import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractClassPublic, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { WorldStateDB } from '../../public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.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 { type AvmEphemeralForest } from '../avm_tree.js';
-import { type AvmRevertReason } from '../errors.js';
+import type { AvmRevertReason } from '../errors.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
 import { NullifierManager } from '../journal/nullifiers.js';
 import { PublicStorage } from '../journal/public_storage.js';
@@ -30,7 +32,7 @@ export declare function initPersistableStateManager(overrides?: {
     publicStorage?: PublicStorage;
     nullifiers?: NullifierManager;
     doMerkleOperations?: boolean;
-    merkleTrees?: AvmEphemeralForest;
+    db?: MerkleTreeWriteOperations;
     firstNullifier?: Fr;
 }): AvmPersistableStateManager;
 /**
@@ -64,4 +66,19 @@ export declare function getAvmTestContractBytecode(functionName: string): Buffer
 export declare function getAvmGadgetsTestContractBytecode(functionName: string): Buffer;
 export declare function resolveAvmTestContractAssertionMessage(functionName: string, revertReason: AvmRevertReason, output: Fr[]): string | undefined;
 export declare function resolveAvmGadgetsTestContractAssertionMessage(functionName: string, revertReason: AvmRevertReason, output: Fr[]): string | undefined;
+/**
+ * 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 declare function createContractClassAndInstance(constructorArgs: any[], deployer: AztecAddress, contractArtifact: ContractArtifact, seed?: number, originalContractClassId?: Fr): Promise<{
+    contractClass: ContractClassPublic;
+    contractInstance: ContractInstanceWithAddress;
+    contractAddressNullifier: Fr;
+}>;
 //# sourceMappingURL=index.d.ts.map

package/dest/public/avm/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/fixtures/index.ts"],"names":[],"mappings":"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"}

package/dest/public/avm/fixtures/index.js

@@ -0,0 +1,175 @@
+import { DEPLOYER_CONTRACT_ADDRESS, MAX_L2_GAS_PER_TX_PUBLIC_PORTION, PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { AvmGadgetsTestContractArtifact } from '@aztec/noir-contracts.js/AvmGadgetsTest';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeInitializationHash } from '@aztec/stdlib/contract';
+import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
+import { GasFees } from '@aztec/stdlib/gas';
+import { siloNullifier } from '@aztec/stdlib/hash';
+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 { 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 { AvmPersistableStateManager } from '../journal/journal.js';
+import { NullifierManager } from '../journal/nullifiers.js';
+import { PublicStorage } from '../journal/public_storage.js';
+export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+/**
+ * Create a new AVM context with default values.
+ */ export function initContext(overrides) {
+    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) {
+    const worldStateDB = overrides?.worldStateDB || mock();
+    return new AvmPersistableStateManager(worldStateDB, overrides?.trace || mock(), overrides?.publicStorage || new PublicStorage(worldStateDB), overrides?.nullifiers || new NullifierManager(worldStateDB), overrides?.doMerkleOperations || false, overrides?.db || mock(), overrides?.firstNullifier || new Fr(27));
+}
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */ export function initExecutionEnvironment(overrides) {
+    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) {
+    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) {
+    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, overrides) {
+    return merge({}, original, overrides);
+}
+export function randomMemoryBytes(length) {
+    return [
+        ...Array(length)
+    ].map((_)=>new Uint8(Math.floor(Math.random() * 255)));
+}
+export function randomMemoryUint32s(length) {
+    return [
+        ...Array(length)
+    ].map((_)=>new Uint32(Math.floor(Math.random() * 255)));
+}
+export function randomMemoryUint64s(length) {
+    return [
+        ...Array(length)
+    ].map((_)=>new Uint64(Math.floor(Math.random() * 255)));
+}
+export function randomMemoryFields(length) {
+    return [
+        ...Array(length)
+    ].map((_)=>new Field(Fr.random()));
+}
+export function getFunctionSelector(functionName, contractArtifact) {
+    const fnArtifact = contractArtifact.functions.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, contractArtifact) {
+    const artifact = contractArtifact.functions.find((f)=>f.name === functionName);
+    if (!artifact) {
+        return undefined;
+    }
+    return artifact;
+}
+export function resolveContractAssertionMessage(functionName, revertReason, output, contractArtifact) {
+    traverseCauseChain(revertReason, (cause)=>{
+        revertReason = cause;
+    });
+    const functionArtifact = contractArtifact.functions.find((f)=>f.name === functionName);
+    if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
+        return undefined;
+    }
+    return resolveAssertionMessageFromRevertData(output, functionArtifact);
+}
+export function getAvmTestContractFunctionSelector(functionName) {
+    return getFunctionSelector(functionName, AvmTestContractArtifact);
+}
+export function getAvmGadgetsTestContractFunctionSelector(functionName) {
+    const artifact = AvmGadgetsTestContractArtifact.functions.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) {
+    const artifact = getContractFunctionArtifact(functionName, AvmTestContractArtifact);
+    assert(!!artifact?.bytecode, `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`);
+    return artifact;
+}
+export function getAvmGadgetsTestContractArtifact(functionName) {
+    const artifact = AvmGadgetsTestContractArtifact.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) {
+    const artifact = getAvmTestContractArtifact(functionName);
+    return artifact.bytecode;
+}
+export function getAvmGadgetsTestContractBytecode(functionName) {
+    const artifact = getAvmGadgetsTestContractArtifact(functionName);
+    return artifact.bytecode;
+}
+export function resolveAvmTestContractAssertionMessage(functionName, revertReason, output) {
+    return resolveContractAssertionMessage(functionName, revertReason, output, AvmTestContractArtifact);
+}
+export function resolveAvmGadgetsTestContractAssertionMessage(functionName, revertReason, output) {
+    traverseCauseChain(revertReason, (cause)=>{
+        revertReason = cause;
+    });
+    const functionArtifact = AvmGadgetsTestContractArtifact.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, deployer, contractArtifact, seed = 0, originalContractClassId) {
+    const bytecode = getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact).bytecode;
+    const contractClass = await makeContractClassPublic(seed, /*publicDispatchFunction=*/ {
+        bytecode,
+        selector: new FunctionSelector(PUBLIC_DISPATCH_SELECTOR)
+    });
+    const constructorAbi = getContractFunctionArtifact('constructor', contractArtifact);
+    const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+    const contractInstance = originalContractClassId === undefined ? await makeContractInstanceFromClassId(contractClass.id, seed, {
+        deployer,
+        initializationHash
+    }) : await makeContractInstanceFromClassId(originalContractClassId, seed, {
+        deployer,
+        initializationHash,
+        currentClassId: contractClass.id
+    });
+    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), contractInstance.address.toField());
+    return {
+        contractClass,
+        contractInstance,
+        contractAddressNullifier
+    };
+}