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

package/src/{avm → public/avm}/fixtures/base_avm_simulation_tester.ts

@@ -1,23 +1,18 @@
-import { MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/circuit-types';
-import {
-  type ContractClassPublic,
-  type ContractInstanceWithAddress,
-  DEPLOYER_CONTRACT_ADDRESS,
-  PUBLIC_DISPATCH_SELECTOR,
-  PublicDataWrite,
-  computeInitializationHash,
-} from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/circuits.js/hash';
-import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/circuits.js/testing';
-import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+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 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 { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 
-import { computeFeePayerBalanceStorageSlot } from '../../server.js';
-import { PUBLIC_DISPATCH_FN_NAME, getContractFunctionArtifact } from './index.js';
-import { type SimpleContractDataSource } from './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.
@@ -36,11 +31,10 @@ export abstract class BaseAvmSimulationTester {
   constructor(
     public contractDataSource: SimpleContractDataSource,
     public merkleTrees: MerkleTreeWriteOperations,
-    /* May want to skip contract deployment tree ops to test failed contract address nullifier checks on CALL */
-    private skipContractDeployments = false,
+    private initialFeePayerBalance = new Fr(10 ** 10),
   ) {}
 
-  async setFeePayerBalance(feePayer: AztecAddress, balance: Fr) {
+  async setFeePayerBalance(feePayer: AztecAddress, balance = this.initialFeePayerBalance) {
     const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
     const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
     await this.setPublicStorage(feeJuiceAddress, balanceSlot, balance);
@@ -61,28 +55,35 @@ export abstract class BaseAvmSimulationTester {
     constructorArgs: any[],
     deployer: AztecAddress,
     contractArtifact: ContractArtifact,
+    skipNullifierInsertion = false,
     seed = 0,
+    originalContractClassId?: Fr, // if previously upgraded
   ): Promise<ContractInstanceWithAddress> {
-    const bytecode = getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact)!.bytecode;
-    const contractClass = await makeContractClassPublic(
+    const { contractClass, contractInstance } = await createContractClassAndInstance(
+      constructorArgs,
+      deployer,
+      contractArtifact,
       seed,
-      /*publicDispatchFunction=*/ { bytecode, selector: new FunctionSelector(PUBLIC_DISPATCH_SELECTOR) },
+      originalContractClassId,
     );
 
-    const constructorAbi = getContractFunctionArtifact('constructor', contractArtifact);
-    const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
-    const contractInstance = await makeContractInstanceFromClassId(contractClass.id, seed, {
-      deployer,
-      initializationHash,
-    });
+    await this.contractDataSource.addNewContract(contractArtifact, contractClass, contractInstance);
 
-    await this.addContractClass(contractClass, contractArtifact);
-    await this.addContractInstance(contractInstance);
+    if (!skipNullifierInsertion) {
+      await this.insertContractAddressNullifier(contractInstance.address);
+    }
     return contractInstance;
   }
 
-  getFirstContractInstance(): ContractInstanceWithAddress {
-    return this.contractDataSource.getFirstContractInstance();
+  async registerFeeJuiceContract(): Promise<ContractInstanceWithAddress> {
+    const feeJuice = await getCanonicalFeeJuice();
+    const feeJuiceContractClassPublic = {
+      ...feeJuice.contractClass,
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(feeJuice.artifact, feeJuiceContractClassPublic, feeJuice.instance);
+    return feeJuice.instance;
   }
 
   addContractClass(contractClass: ContractClassPublic, contractArtifact: ContractArtifact): Promise<void> {
@@ -91,14 +92,18 @@ export abstract class BaseAvmSimulationTester {
     return this.contractDataSource.addContractClass(contractClass);
   }
 
-  async addContractInstance(contractInstance: ContractInstanceWithAddress) {
-    if (!this.skipContractDeployments) {
-      const contractAddressNullifier = await siloNullifier(
-        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-        contractInstance.address.toField(),
-      );
-      await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+  async addContractInstance(contractInstance: ContractInstanceWithAddress, skipNullifierInsertion = false) {
+    if (!skipNullifierInsertion) {
+      await this.insertContractAddressNullifier(contractInstance.address);
     }
     await this.contractDataSource.addContractInstance(contractInstance);
   }
+
+  private async insertContractAddressNullifier(contractAddress: AztecAddress) {
+    const contractAddressNullifier = await siloNullifier(
+      AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+      contractAddress.toField(),
+    );
+    await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+  }
 }

package/src/{avm → public/avm}/fixtures/index.ts

@@ -1,25 +1,39 @@
-import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
-import { GasFees, GlobalVariables, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/circuits.js';
-import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+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 { type ContractArtifact, type FunctionArtifact, FunctionSelector } 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 type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+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.js';
-import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
-import { type WorldStateDB } from '../../server.js';
+import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
+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 { AvmSimulator } from '../avm_simulator.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';
@@ -34,11 +48,13 @@ export function initContext(overrides?: {
   env?: AvmExecutionEnvironment;
   machineState?: AvmMachineState;
 }): AvmContext {
-  return new 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. */
@@ -48,7 +64,7 @@ export function initPersistableStateManager(overrides?: {
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
   doMerkleOperations?: boolean;
-  merkleTrees?: AvmEphemeralForest;
+  db?: MerkleTreeWriteOperations;
   firstNullifier?: Fr;
 }): AvmPersistableStateManager {
   const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
@@ -58,7 +74,7 @@ export function initPersistableStateManager(overrides?: {
     overrides?.publicStorage || new PublicStorage(worldStateDB),
     overrides?.nullifiers || new NullifierManager(worldStateDB),
     overrides?.doMerkleOperations || false,
-    overrides?.merkleTrees || mock<AvmEphemeralForest>(),
+    overrides?.db || mock<MerkleTreeWriteOperations>(),
     overrides?.firstNullifier || new Fr(27),
   );
 }
@@ -229,3 +245,52 @@ export function resolveAvmGadgetsTestContractAssertionMessage(
 
   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)!.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 };
+}

package/src/{avm → public/avm}/fixtures/simple_contract_data_source.ts

@@ -1,15 +1,13 @@
-import {
-  type ContractClassPublic,
-  type ContractDataSource,
-  type ContractInstanceWithAddress,
-  type FunctionSelector,
-  type PublicFunction,
-  computePublicBytecodeCommitment,
-} from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type {
+  ContractClassPublic,
+  ContractDataSource,
+  ContractInstanceWithAddress,
+  PublicFunction,
+} from '@aztec/stdlib/contract';
 
 import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
 
@@ -32,8 +30,18 @@ export class SimpleContractDataSource implements ContractDataSource {
 
   /////////////////////////////////////////////////////////////
   // Helper functions not in the contract data source interface
-  getFirstContractInstance(): ContractInstanceWithAddress {
-    return this.contractInstances.values().next().value;
+  /**
+   * Derive the contract class and instance with some seed.
+   * Add both to the contract data source along with the contract artifact.
+   */
+  async addNewContract(
+    contractArtifact: ContractArtifact,
+    contractClass: ContractClassPublic,
+    contractInstance: ContractInstanceWithAddress,
+  ) {
+    this.addContractArtifact(contractClass.id, contractArtifact);
+    await this.addContractClass(contractClass);
+    await this.addContractInstance(contractInstance);
   }
 
   addContractArtifact(classId: Fr, artifact: ContractArtifact): void {
@@ -41,7 +49,7 @@ export class SimpleContractDataSource implements ContractDataSource {
   }
 
   /////////////////////////////////////////////////////////////
-  // ContractDataSource function impelementations
+  // ContractDataSource function implementations
   getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
     throw new Error('Method not implemented.');
   }
@@ -54,9 +62,8 @@ export class SimpleContractDataSource implements ContractDataSource {
     return Promise.resolve(this.contractClasses.get(id.toString()));
   }
 
-  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const contractClass = await this.getContractClass(id);
-    return Promise.resolve(computePublicBytecodeCommitment(contractClass!.packedBytecode));
+  getBytecodeCommitment(_id: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(undefined);
   }
 
   getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
@@ -74,8 +81,8 @@ export class SimpleContractDataSource implements ContractDataSource {
       return undefined;
     }
     this.logger.debug(`Retrieved contract artifact for address: ${address}`);
-    this.logger.debug(`Contract class ID: ${contractInstance.contractClassId}`);
-    return Promise.resolve(this.contractArtifacts.get(contractInstance!.contractClassId.toString()));
+    this.logger.debug(`Contract class ID: ${contractInstance.currentContractClassId}`);
+    return Promise.resolve(this.contractArtifacts.get(contractInstance!.currentContractClassId.toString()));
   }
 
   getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {

package/src/{avm → public/avm}/index.ts

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

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

@@ -0,0 +1 @@
+export * from './journal.js';