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

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,38 +1,30 @@
-import { MerkleTreeId, type MerkleTreeWriteOperations, PublicExecutionRequest, type Tx } from '@aztec/circuit-types';
-import {
-  type AvmCircuitPublicInputs,
-  CallContext,
-  FunctionSelector,
-  GasFees,
-  GlobalVariables,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
-  PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_DISPATCH_SELECTOR,
-} from '@aztec/circuits.js';
-import { type ContractArtifact, encodeArguments } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+import { type ContractArtifact, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { PublicExecutionRequest, type Tx } from '@aztec/stdlib/tx';
+import { CallContext, GlobalVariables } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../../avm/fixtures/base_avm_simulation_tester.js';
-import { getContractFunctionArtifact, getFunctionSelector } from '../../avm/fixtures/index.js';
-import { SimpleContractDataSource } from '../../avm/fixtures/simple_contract_data_source.js';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { getContractFunctionArtifact, getFunctionSelector } from '../avm/fixtures/index.js';
+import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
 import { WorldStateDB } from '../public_db_sources.js';
-import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator.js';
+import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import { createTxForPublicCalls } from './index.js';
 
 const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
+export const DEFAULT_BLOCK_NUMBER = 42;
 
 export type TestEnqueuedCall = {
   address: AztecAddress;
   fnName: string;
   args: any[];
   isStaticCall?: boolean;
+  contractArtifact?: ContractArtifact;
 };
 
 /**
@@ -47,56 +39,59 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     private worldStateDB: WorldStateDB,
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
-    skipContractDeployments: boolean,
   ) {
-    super(contractDataSource, merkleTrees, skipContractDeployments);
+    super(contractDataSource, merkleTrees);
   }
 
-  public static async create(skipContractDeployments = false): Promise<PublicTxSimulationTester> {
+  public static async create(): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
     const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees, skipContractDeployments);
+    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees);
   }
 
-  public async simulateTx(
+  public async createTx(
     sender: AztecAddress,
     setupCalls: TestEnqueuedCall[] = [],
     appCalls: TestEnqueuedCall[] = [],
     teardownCall?: TestEnqueuedCall,
-    feePayer: AztecAddress = AztecAddress.zero(),
-  ): Promise<PublicTxResult> {
-    const globals = GlobalVariables.empty();
-    globals.timestamp = TIMESTAMP;
-    globals.gasFees = DEFAULT_GAS_FEES;
-
-    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
-
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+  ): Promise<Tx> {
     const setupExecutionRequests: PublicExecutionRequest[] = [];
     for (let i = 0; i < setupCalls.length; i++) {
       const address = setupCalls[i].address;
-      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      const contractArtifact =
+        setupCalls[i].contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
       const req = await executionRequestForCall(
+        contractArtifact,
         sender,
         address,
         setupCalls[i].fnName,
         setupCalls[i].args,
         setupCalls[i].isStaticCall,
-        contractArtifact,
       );
       setupExecutionRequests.push(req);
     }
     const appExecutionRequests: PublicExecutionRequest[] = [];
     for (let i = 0; i < appCalls.length; i++) {
       const address = appCalls[i].address;
-      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      const contractArtifact =
+        appCalls[i].contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
       const req = await executionRequestForCall(
+        contractArtifact,
         sender,
         address,
         appCalls[i].fnName,
         appCalls[i].args,
         appCalls[i].isStaticCall,
-        contractArtifact,
       );
       appExecutionRequests.push(req);
     }
@@ -104,71 +99,62 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     let teardownExecutionRequest: PublicExecutionRequest | undefined = undefined;
     if (teardownCall) {
       const address = teardownCall.address;
-      const contractArtifact = await this.contractDataSource.getContractArtifact(address);
+      const contractArtifact =
+        teardownCall.contractArtifact || (await this.contractDataSource.getContractArtifact(address));
+      if (!contractArtifact) {
+        throw new Error(`Contract artifact not found for address: ${address}`);
+      }
       teardownExecutionRequest = await executionRequestForCall(
+        contractArtifact,
         sender,
         address,
         teardownCall.fnName,
         teardownCall.args,
         teardownCall.isStaticCall,
-        contractArtifact,
       );
     }
 
-    // Use a fake "first nullifier" to make sure note hash nonces are computed properly,
-    // but make sure each tx has a unique first nullifier.
-    const firstNullifier = new Fr(420000 + this.txCount++);
-
-    const tx: Tx = await createTxForPublicCalls(
+    return await createTxForPublicCalls(
       firstNullifier,
       setupExecutionRequests,
       appExecutionRequests,
       teardownExecutionRequest,
       feePayer,
     );
+  }
+
+  public async simulateTx(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[] = [],
+    appCalls: TestEnqueuedCall[] = [],
+    teardownCall?: TestEnqueuedCall,
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+    globals = defaultGlobals(),
+  ): Promise<PublicTxResult> {
+    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier);
+
+    await this.setFeePayerBalance(feePayer);
+
+    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
 
     const startTime = performance.now();
     const avmResult = await simulator.simulate(tx);
     const endTime = performance.now();
     this.logger.debug(`Public transaction simulation took ${endTime - startTime}ms`);
 
-    if (avmResult.revertCode.isOK()) {
-      await this.commitTxStateUpdates(avmResult.avmProvingRequest.inputs.publicInputs);
-    }
-
     return avmResult;
   }
-
-  private async commitTxStateUpdates(avmCircuitInputs: AvmCircuitPublicInputs) {
-    await this.merkleTrees.appendLeaves(
-      MerkleTreeId.NOTE_HASH_TREE,
-      padArrayEnd(avmCircuitInputs.accumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
-    try {
-      await this.merkleTrees.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        padArrayEnd(avmCircuitInputs.accumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
-        NULLIFIER_SUBTREE_HEIGHT,
-      );
-    } catch (error) {
-      this.logger.warn(`Detected duplicate nullifier.`);
-    }
-
-    await this.merkleTrees.batchInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      avmCircuitInputs.accumulatedData.publicDataWrites.map(w => w.toBuffer()),
-      PUBLIC_DATA_TREE_HEIGHT,
-    );
-  }
 }
 
 async function executionRequestForCall(
+  contractArtifact: ContractArtifact,
   sender: AztecAddress,
   address: AztecAddress,
   fnName: string,
   args: Fr[] = [],
   isStaticCall: boolean = false,
-  contractArtifact: ContractArtifact = AvmTestContractArtifact,
 ): Promise<PublicExecutionRequest> {
   const fnSelector = await getFunctionSelector(fnName, contractArtifact);
   const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
@@ -183,3 +169,11 @@ async function executionRequestForCall(
   );
   return new PublicExecutionRequest(callContext, calldata);
 }
+
+function defaultGlobals() {
+  const globals = GlobalVariables.empty();
+  globals.timestamp = TIMESTAMP;
+  globals.gasFees = DEFAULT_GAS_FEES; // apply some nonzero default gas fees
+  globals.blockNumber = new Fr(DEFAULT_BLOCK_NUMBER);
+  return globals;
+}

package/src/public/fixtures/utils.ts

@@ -1,27 +1,34 @@
-import { type PublicExecutionRequest, Tx } from '@aztec/circuit-types';
 import {
-  BlockHeader,
+  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
   DEFAULT_GAS_LIMIT,
-  FunctionSelector,
-  Gas,
-  GasFees,
-  GasSettings,
+  DEPLOYER_CONTRACT_ADDRESS,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+  REGISTERER_CONTRACT_ADDRESS,
+  REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { assertLength } from '@aztec/foundation/serialize';
+import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { bufferAsFields } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import {
   PartialPrivateTailPublicInputsForPublic,
+  PartialPrivateTailPublicInputsForRollup,
   PrivateKernelTailCircuitPublicInputs,
   RollupValidationRequests,
-  TxConstantData,
-  TxContext,
-} from '@aztec/circuits.js';
-import { type FunctionArtifact } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
-import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+  ScopedLogHash,
+  countAccumulatedItems,
+} from '@aztec/stdlib/kernel';
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
-export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
-
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
@@ -44,7 +51,7 @@ export async function createTxForPublicCalls(
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
   // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier; // fake tx nullifier
+  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
 
   // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
   for (let i = setupCallRequests.length - 1; i >= 0; i--) {
@@ -84,27 +91,109 @@ export async function createTxForPublicCalls(
   return tx;
 }
 
-export function getAvmTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
-}
+export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate: Gas = new Gas(10, 10)): Tx {
+  // use max limits
+  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
 
-export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
+  const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    RollupValidationRequests.empty(),
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    /*forPublic=*/ undefined,
+    forRollup,
   );
-  return artifact;
+  return Tx.newWithTxData(txData);
 }
 
-export function getAvmTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmTestContractArtifact(functionName);
-  return artifact.bytecode;
+export async function addNewContractClassToTx(
+  tx: Tx,
+  contractClass: ContractClassPublic,
+  skipNullifierInsertion = false,
+) {
+  const contractClassLogFields = [
+    new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+    contractClass.id,
+    new Fr(contractClass.version),
+    new Fr(contractClass.artifactHash),
+    new Fr(contractClass.privateFunctionsRoot),
+    ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
+  ];
+  const contractClassLog = ContractClassLog.fromFields([
+    new Fr(REGISTERER_CONTRACT_ADDRESS),
+    ...contractClassLogFields.concat(
+      new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO),
+    ),
+  ]);
+  const contractClassLogHash = ScopedLogHash.fromFields([
+    await contractClassLog.hash(),
+    new Fr(7),
+    new Fr(contractClassLog.getEmittedLength()),
+    new Fr(REGISTERER_CONTRACT_ADDRESS),
+  ]);
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractClass.id;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
+  accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
+
+  tx.contractClassLogs.push(contractClassLog);
 }
 
-export function getAvmTestContractPublicDispatchBytecode(): Buffer {
-  return getAvmTestContractBytecode(PUBLIC_DISPATCH_FN_NAME);
+export async function addNewContractInstanceToTx(
+  tx: Tx,
+  contractInstance: ContractInstanceWithAddress,
+  skipNullifierInsertion = false,
+) {
+  // can't use publicKeys.toFields() because it includes isInfinite which
+  // is not broadcast in such private logs
+  const publicKeysAsFields = [
+    contractInstance.publicKeys.masterNullifierPublicKey.x,
+    contractInstance.publicKeys.masterNullifierPublicKey.y,
+    contractInstance.publicKeys.masterIncomingViewingPublicKey.x,
+    contractInstance.publicKeys.masterIncomingViewingPublicKey.y,
+    contractInstance.publicKeys.masterOutgoingViewingPublicKey.x,
+    contractInstance.publicKeys.masterOutgoingViewingPublicKey.y,
+    contractInstance.publicKeys.masterTaggingPublicKey.x,
+    contractInstance.publicKeys.masterTaggingPublicKey.y,
+  ];
+  const fields = [
+    DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+    contractInstance.address.toField(),
+    new Fr(contractInstance.version),
+    new Fr(contractInstance.salt),
+    contractInstance.currentContractClassId,
+    contractInstance.initializationHash,
+    ...publicKeysAsFields,
+    contractInstance.deployer.toField(),
+    new Fr(0),
+    new Fr(0),
+    new Fr(0),
+  ];
+  const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
+
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+    contractInstance.address.toField(),
+  );
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractAddressNullifier;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.privateLogs);
+  accumulatedData.privateLogs[nextLogIndex] = contractInstanceLog;
 }

package/src/public/index.ts

@@ -1,8 +1,9 @@
-export * from './db_interfaces.js';
-export * from './public_tx_simulator.js';
+export * from '../common/db_interfaces.js';
+export * from './public_tx_simulator/public_tx_simulator.js';
 export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
-export * from './fee_payment.js';
 export * from './public_db_sources.js';
-export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
+export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
 export { SideEffectTrace } from './side_effect_trace.js';
 export { getExecutionRequestsByPhase } from './utils.js';
+export { PublicTxSimulationTester } from './fixtures/index.js';
+export * from './avm/index.js';