@aztec/simulator 0.68.0 → 0.68.1

package/src/public/fixtures/index.ts

@@ -1,4 +1,4 @@
-import { MerkleTreeId, PublicExecutionRequest, Tx } from '@aztec/circuit-types';
+import { MerkleTreeId, type MerkleTreeWriteOperations, PublicExecutionRequest, Tx } from '@aztec/circuit-types';
 import {
   type AvmCircuitInputs,
   BlockHeader,
@@ -14,6 +14,7 @@ import {
   GasSettings,
   GlobalVariables,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
   PartialPrivateTailPublicInputsForPublic,
   PrivateKernelTailCircuitPublicInputs,
   type PublicFunction,
@@ -31,63 +32,54 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
-import { PublicTxSimulator, WorldStateDB } from '@aztec/simulator';
+import {
+  AvmEphemeralForest,
+  AvmSimulator,
+  PublicEnqueuedCallSideEffectTrace,
+  PublicTxSimulator,
+  WorldStateDB,
+} from '@aztec/simulator';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
 
 import { strict as assert } from 'assert';
 
+import { initContext, initExecutionEnvironment, initPersistableStateManager } from '../../avm/fixtures/index.js';
+
+const TIMESTAMP = new Fr(99833);
+
 export async function simulateAvmTestContractGenerateCircuitInputs(
   functionName: string,
-  calldata: Fr[] = [],
+  args: Fr[] = [],
   expectRevert: boolean = false,
-  skipContractDeployments: boolean = false,
+  contractDataSource = new MockedAvmTestContractDataSource(),
   assertionErrString?: string,
 ): Promise<AvmCircuitInputs> {
-  const sender = AztecAddress.random();
-  const functionSelector = getAvmTestContractFunctionSelector(functionName);
-  calldata = [functionSelector.toField(), ...calldata];
-
-  const globalVariables = GlobalVariables.empty();
-  globalVariables.gasFees = GasFees.empty();
-  globalVariables.timestamp = new Fr(99833);
+  const globals = GlobalVariables.empty();
+  globals.timestamp = TIMESTAMP;
 
-  const telemetry = new NoopTelemetryClient();
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), telemetry)).fork();
-  const contractDataSource = new MockedAvmTestContractDataSource(skipContractDeployments);
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  await contractDataSource.deployContracts(merkleTrees);
   const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
 
-  const contractInstance = contractDataSource.contractInstance;
-
-  if (!skipContractDeployments) {
-    const contractAddressNullifier = siloNullifier(
-      AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-      contractInstance.address.toField(),
-    );
-    await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
-    // other contract address used by the bulk test's GETCONTRACTINSTANCE test
-    const otherContractAddressNullifier = siloNullifier(
-      AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
-      contractDataSource.otherContractInstance.address.toField(),
-    );
-    await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [otherContractAddressNullifier.toBuffer()], 0);
-  }
-
   const simulator = new PublicTxSimulator(
     merkleTrees,
     worldStateDB,
     new NoopTelemetryClient(),
-    globalVariables,
+    globals,
     /*doMerkleOperations=*/ true,
   );
 
+  const sender = AztecAddress.random();
+  const functionSelector = getAvmTestContractFunctionSelector(functionName);
+  args = [functionSelector.toField(), ...args];
   const callContext = new CallContext(
     sender,
-    contractInstance.address,
+    contractDataSource.firstContractInstance.address,
     contractDataSource.fnSelector,
     /*isStaticCall=*/ false,
   );
-  const executionRequest = new PublicExecutionRequest(callContext, calldata);
+  const executionRequest = new PublicExecutionRequest(callContext, args);
 
   const tx: Tx = createTxForPublicCall(executionRequest);
 
@@ -108,6 +100,46 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
   return avmCircuitInputs;
 }
 
+export async function simulateAvmTestContractCall(
+  functionName: string,
+  args: Fr[] = [],
+  expectRevert: boolean = false,
+  contractDataSource = new MockedAvmTestContractDataSource(),
+) {
+  const globals = GlobalVariables.empty();
+  globals.timestamp = TIMESTAMP;
+
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  await contractDataSource.deployContracts(merkleTrees);
+  const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+
+  const trace = new PublicEnqueuedCallSideEffectTrace();
+  const ephemeralTrees = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
+  const persistableState = initPersistableStateManager({
+    worldStateDB,
+    trace,
+    merkleTrees: ephemeralTrees,
+    doMerkleOperations: true,
+  });
+
+  const sender = AztecAddress.random();
+  const functionSelector = getAvmTestContractFunctionSelector(functionName);
+  args = [functionSelector.toField(), ...args];
+  const environment = initExecutionEnvironment({
+    calldata: args,
+    globals,
+    address: contractDataSource.firstContractInstance.address,
+    sender,
+  });
+  const context = initContext({ env: environment, persistableState });
+
+  // First we simulate (though it's not needed in this simple case).
+  const simulator = new AvmSimulator(context);
+  const results = await simulator.execute();
+
+  expect(results.reverted).toBe(expectRevert);
+}
+
 /**
  * Craft a carrier transaction for a public call for simulation by PublicTxSimulator.
  */
@@ -151,21 +183,45 @@ export function createTxForPublicCall(
 
 export class MockedAvmTestContractDataSource implements ContractDataSource {
   private fnName = 'public_dispatch';
+  public fnSelector: FunctionSelector = getAvmTestContractFunctionSelector(this.fnName);
   private bytecode: Buffer;
-  public fnSelector: FunctionSelector;
   private publicFn: PublicFunction;
-  private contractClass: ContractClassPublic;
-  public contractInstance: ContractInstanceWithAddress;
   private bytecodeCommitment: Fr;
+
+  // maps contract class ID to class
+  private contractClasses: Map<string, ContractClassPublic> = new Map();
+  // maps contract instance address to instance
+  public contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
+
+  public firstContractInstance: ContractInstanceWithAddress = SerializableContractInstance.default().withAddress(
+    AztecAddress.fromNumber(0),
+  );
+  public instanceSameClassAsFirstContract: ContractInstanceWithAddress =
+    SerializableContractInstance.default().withAddress(AztecAddress.fromNumber(0));
   public otherContractInstance: ContractInstanceWithAddress;
 
-  constructor(private noContractsDeployed: boolean = false) {
+  constructor(private skipContractDeployments: boolean = false) {
     this.bytecode = getAvmTestContractBytecode(this.fnName);
     this.fnSelector = getAvmTestContractFunctionSelector(this.fnName);
     this.publicFn = { bytecode: this.bytecode, selector: this.fnSelector };
-    this.contractClass = makeContractClassPublic(0, this.publicFn);
-    this.contractInstance = makeContractInstanceFromClassId(this.contractClass.id);
     this.bytecodeCommitment = computePublicBytecodeCommitment(this.bytecode);
+
+    // create enough unique classes to hit the limit (plus two extra)
+    for (let i = 0; i < MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS + 1; i++) {
+      const contractClass = makeContractClassPublic(/*seed=*/ i, this.publicFn);
+      const contractInstance = makeContractInstanceFromClassId(contractClass.id, /*seed=*/ i);
+      this.contractClasses.set(contractClass.id.toString(), contractClass);
+      this.contractInstances.set(contractInstance.address.toString(), contractInstance);
+      if (i === 0) {
+        this.firstContractInstance = contractInstance;
+      }
+    }
+    // a contract with the same class but different instance/address as the first contract
+    this.instanceSameClassAsFirstContract = makeContractInstanceFromClassId(
+      this.firstContractInstance.contractClassId,
+      /*seed=*/ 1000,
+    );
+
     // The values here should match those in `avm_simulator.test.ts`
     // Used for GETCONTRACTINSTANCE test
     this.otherContractInstance = new SerializableContractInstance({
@@ -183,6 +239,46 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
     }).withAddress(AztecAddress.fromNumber(0x4444));
   }
 
+  async deployContracts(merkleTrees: MerkleTreeWriteOperations) {
+    if (!this.skipContractDeployments) {
+      for (const contractInstance of this.contractInstances.values()) {
+        const contractAddressNullifier = siloNullifier(
+          AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+          contractInstance.address.toField(),
+        );
+        await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+      }
+
+      const instanceSameClassAsFirstContractNullifier = siloNullifier(
+        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+        this.instanceSameClassAsFirstContract.address.toField(),
+      );
+      await merkleTrees.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        [instanceSameClassAsFirstContractNullifier.toBuffer()],
+        0,
+      );
+
+      // other contract address used by the bulk test's GETCONTRACTINSTANCE test
+      const otherContractAddressNullifier = siloNullifier(
+        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+        this.otherContractInstance.address.toField(),
+      );
+      await merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [otherContractAddressNullifier.toBuffer()], 0);
+    }
+  }
+
+  public static async create(
+    merkleTrees: MerkleTreeWriteOperations,
+    skipContractDeployments: boolean = false,
+  ): Promise<MockedAvmTestContractDataSource> {
+    const dataSource = new MockedAvmTestContractDataSource(skipContractDeployments);
+    if (!skipContractDeployments) {
+      await dataSource.deployContracts(merkleTrees);
+    }
+    return dataSource;
+  }
+
   getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
     return Promise.resolve(this.publicFn);
   }
@@ -191,8 +287,8 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
     throw new Error('Method not implemented.');
   }
 
-  getContractClass(_id: Fr): Promise<ContractClassPublic> {
-    return Promise.resolve(this.contractClass);
+  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(this.contractClasses.get(id.toString()));
   }
 
   getBytecodeCommitment(_id: Fr): Promise<Fr> {
@@ -204,11 +300,13 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
   }
 
   getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    if (!this.noContractsDeployed) {
-      if (address.equals(this.contractInstance.address)) {
-        return Promise.resolve(this.contractInstance);
-      } else if (address.equals(this.otherContractInstance.address)) {
+    if (!this.skipContractDeployments) {
+      if (address.equals(this.otherContractInstance.address)) {
         return Promise.resolve(this.otherContractInstance);
+      } else if (address.equals(this.instanceSameClassAsFirstContract.address)) {
+        return Promise.resolve(this.instanceSameClassAsFirstContract);
+      } else {
+        return Promise.resolve(this.contractInstances.get(address.toString()));
       }
     }
     return Promise.resolve(undefined);

package/src/public/public_processor.ts

@@ -24,7 +24,7 @@ import {
 } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
+import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
 import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
@@ -38,7 +38,11 @@ import { PublicTxSimulator } from './public_tx_simulator.js';
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
  */
 export class PublicProcessorFactory {
-  constructor(private contractDataSource: ContractDataSource, private telemetryClient: TelemetryClient) {}
+  constructor(
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient,
+  ) {}
 
   /**
    * Creates a new instance of a PublicProcessor.
@@ -56,7 +60,7 @@ export class PublicProcessorFactory {
     const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
 
     const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-    const publicTxSimulator = new PublicTxSimulator(
+    const publicTxSimulator = this.createPublicTxSimulator(
       merkleTree,
       worldStateDB,
       this.telemetryClient,
@@ -71,9 +75,35 @@ export class PublicProcessorFactory {
       historicalHeader,
       worldStateDB,
       publicTxSimulator,
+      this.dateProvider,
       this.telemetryClient,
     );
   }
+
+  protected createPublicTxSimulator(
+    db: MerkleTreeWriteOperations,
+    worldStateDB: WorldStateDB,
+    telemetryClient: TelemetryClient,
+    globalVariables: GlobalVariables,
+    doMerkleOperations: boolean,
+    enforceFeePayment: boolean,
+  ) {
+    return new PublicTxSimulator(
+      db,
+      worldStateDB,
+      telemetryClient,
+      globalVariables,
+      doMerkleOperations,
+      enforceFeePayment,
+    );
+  }
+}
+
+class PublicProcessorTimeoutError extends Error {
+  constructor(message: string = 'Timed out while processing tx') {
+    super(message);
+    this.name = 'PublicProcessorTimeoutError';
+  }
 }
 
 /**
@@ -88,6 +118,7 @@ export class PublicProcessor implements Traceable {
     protected historicalHeader: BlockHeader,
     protected worldStateDB: WorldStateDB,
     protected publicTxSimulator: PublicTxSimulator,
+    private dateProvider: DateProvider,
     telemetryClient: TelemetryClient,
     private log = createLogger('simulator:public-processor'),
   ) {
@@ -108,6 +139,7 @@ export class PublicProcessor implements Traceable {
     txs: Tx[],
     maxTransactions = txs.length,
     txValidator?: TxValidator<ProcessedTx>,
+    deadline?: Date,
   ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
     txs = txs.map(tx => Tx.clone(tx));
@@ -123,18 +155,19 @@ export class PublicProcessor implements Traceable {
         break;
       }
       try {
-        const [processedTx, returnValues] = await this.processTx(tx, txValidator);
+        const [processedTx, returnValues] = await this.processTx(tx, txValidator, deadline);
         result.push(processedTx);
         returns = returns.concat(returnValues);
         totalGas = totalGas.add(processedTx.gasUsed.publicGas);
       } catch (err: any) {
+        if (err?.name === 'PublicProcessorTimeoutError') {
+          this.log.warn(`Stopping tx processing due to timeout.`);
+          break;
+        }
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
 
-        failed.push({
-          tx,
-          error: err instanceof Error ? err : new Error(errorMessage),
-        });
+        failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
         returns.push(new NestedProcessReturnValues([]));
       }
     }
@@ -150,15 +183,14 @@ export class PublicProcessor implements Traceable {
   private async processTx(
     tx: Tx,
     txValidator?: TxValidator<ProcessedTx>,
+    deadline?: Date,
   ): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
-    const [processedTx, returnValues] = !tx.hasPublicCalls()
-      ? await this.processPrivateOnlyTx(tx)
-      : await this.processTxWithPublicCalls(tx);
+    const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 
     this.log.verbose(
       !tx.hasPublicCalls()
-        ? `Processed tx ${processedTx.hash} with no public calls`
-        : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls`,
+        ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms`
+        : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`,
       {
         txHash: processedTx.hash,
         txFee: processedTx.txEffect.transactionFee.toBigInt(),
@@ -172,6 +204,7 @@ export class PublicProcessor implements Traceable {
         unencryptedLogCount: processedTx.txEffect.unencryptedLogs.getTotalLogCount(),
         privateLogCount: processedTx.txEffect.privateLogs.length,
         l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
+        durationMs: time,
       },
     );
 
@@ -226,6 +259,37 @@ export class PublicProcessor implements Traceable {
     return [processedTx, returnValues ?? []];
   }
 
+  /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
+  private async processTxWithinDeadline(
+    tx: Tx,
+    deadline?: Date,
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> {
+    const processFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
+      ? () => this.processTxWithPublicCalls(tx)
+      : () => this.processPrivateOnlyTx(tx);
+
+    if (!deadline) {
+      return await processFn();
+    }
+
+    const timeout = +deadline - this.dateProvider.now();
+    this.log.debug(`Processing tx ${tx.getTxHash().toString()} within ${timeout}ms`, {
+      deadline: deadline.toISOString(),
+      now: new Date(this.dateProvider.now()).toISOString(),
+      txHash: tx.getTxHash().toString(),
+    });
+
+    if (timeout < 0) {
+      throw new PublicProcessorTimeoutError();
+    }
+
+    return await executeTimeout(
+      () => processFn(),
+      timeout,
+      () => new PublicProcessorTimeoutError(),
+    );
+  }
+
   /**
    * Creates the public data write for paying the tx fee.
    * This is used in private only txs, since for txs with public calls
@@ -260,7 +324,7 @@ export class PublicProcessor implements Traceable {
   @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
     [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
-  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx]> {
+  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined]> {
     const gasFees = this.globalVariables.gasFees;
     const transactionFee = tx.data.gasUsed.computeFee(gasFees);
 
@@ -279,7 +343,7 @@ export class PublicProcessor implements Traceable {
         .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
         .map(log => ContractClassRegisteredEvent.fromLog(log.data)),
     );
-    return [processedTx];
+    return [processedTx, undefined];
   }
 
   @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({

package/src/public/side_effect_errors.ts

@@ -1,6 +1,6 @@
 export class SideEffectLimitReachedError extends Error {
   constructor(sideEffectType: string, limit: number) {
-    super(`Reached the limit on number of '${sideEffectType}' side effects: ${limit}`);
+    super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
     this.name = 'SideEffectLimitReachedError';
   }
 }

package/src/public/unique_class_ids.ts

@@ -0,0 +1,80 @@
+import { MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS } from '@aztec/circuits.js';
+
+import { strict as assert } from 'assert';
+
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */
+export class UniqueClassIds {
+  private readonly classIds: Set<string> = new Set();
+
+  constructor(private readonly parent?: UniqueClassIds) {}
+
+  /**
+   * Create a fork that references this one as its parent
+   */
+  public fork() {
+    return new UniqueClassIds(/*parent=*/ this);
+  }
+
+  /**
+   * Check for a class ID here or in parent's (recursively).
+   *
+   * @param classId - the contract class ID (as a string) to check
+   * @returns boolean: whether the class ID is here
+   */
+  public has(classId: string): boolean {
+    // First try check this' classIds
+    let here = this.classIds.has(classId);
+    // Then try parent's
+    if (!here && this.parent) {
+      // Note: this will recurse to grandparent/etc until we reach top or find it
+      here = this.parent.has(classId);
+    }
+    return here;
+  }
+
+  /**
+   * Get the total number of classIds
+   */
+  public size(): number {
+    return this.classIds.size + (this.parent ? this.parent.size() : 0);
+  }
+
+  /**
+   * Add a class ID (if not already present) to the set.
+   *
+   * @param classId - the contract class ID (as a string)
+   */
+  public add(classId: string) {
+    assert(!this.has(classId), `Bug! Tried to add duplicate classId ${classId} to set of unique classIds.`);
+    if (!this.has(classId)) {
+      this.classIds.add(classId);
+      assert(
+        this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+        `Bug! Surpassed limit (${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}) of unique contract class IDs used for bytecode retrievals.`,
+      );
+    }
+  }
+
+  /**
+   * Merge in another set of unique class IDs into this one, but fail on duplicates.
+   *
+   * @param incoming: other unique class IDs
+   */
+  public acceptAndMerge(incoming: UniqueClassIds) {
+    for (const classId of incoming.classIds.keys()) {
+      assert(
+        !this.has(classId),
+        `Bug! Cannot merge classId ${classId} into set of unique classIds as it already exists.`,
+      );
+      this.classIds.add(classId);
+    }
+    // since set() has an assertion, and size() always checks parent, this should be impossible
+    assert(
+      this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+      `Bug! Merging unique class Ids should never exceed the limit of ${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}.`,
+    );
+  }
+}