@aztec/simulator 0.82.2-alpha-testnet.4 → 0.82.3

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -9,17 +9,19 @@ import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } from '@aztec/
 import { NativeWorldStateService } from '@aztec/world-state';
 
 import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
-import { getContractFunctionAbi, getFunctionSelector } from '../avm/fixtures/index.js';
+import { DEFAULT_BLOCK_NUMBER, getContractFunctionAbi, getFunctionSelector } from '../avm/fixtures/index.js';
 import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
-import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { TestExecutorMetrics } from '../test_executor_metrics.js';
 import { createTxForPublicCalls } from './utils.js';
 
 const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
-export const DEFAULT_BLOCK_NUMBER = 42;
 
 export type TestEnqueuedCall = {
+  sender?: AztecAddress;
   address: AztecAddress;
   fnName: string;
   args: any[];
@@ -34,15 +36,41 @@ export type TestEnqueuedCall = {
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   private txCount = 0;
-
-  constructor(private merkleTree: MerkleTreeWriteOperations, contractDataSource: SimpleContractDataSource) {
+  private simulator: MeasuredPublicTxSimulator;
+  private metricsPrefix?: string;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractDataSource: SimpleContractDataSource,
+    globals: GlobalVariables = defaultGlobals(),
+    private metrics: TestExecutorMetrics = new TestExecutorMetrics(),
+  ) {
     super(contractDataSource, merkleTree);
+
+    const treesDB = new PublicTreesDB(merkleTree);
+    const contractsDB = new PublicContractsDB(contractDataSource);
+
+    this.simulator = new MeasuredPublicTxSimulator(
+      treesDB,
+      contractsDB,
+      globals,
+      /*doMerkleOperations=*/ true,
+      /*skipFeeEnforcement=*/ false,
+      this.metrics,
+    );
   }
 
-  public static async create(): Promise<PublicTxSimulationTester> {
+  public static async create(
+    globals: GlobalVariables = defaultGlobals(),
+    metrics: TestExecutorMetrics = new TestExecutorMetrics(),
+  ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTree = await (await NativeWorldStateService.tmp()).fork();
-    return new PublicTxSimulationTester(merkleTree, contractDataSource);
+    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics);
+  }
+
+  public setMetricsPrefix(prefix: string) {
+    this.metricsPrefix = prefix;
   }
 
   public async createTx(
@@ -54,10 +82,14 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     /* need some unique first nullifier for note-nonce computations */
     firstNullifier = new Fr(420000 + this.txCount++),
   ): Promise<Tx> {
-    const setupCallRequests = await asyncMap(setupCalls, call => this.#createPubicCallRequestForCall(call, sender));
-    const appCallRequests = await asyncMap(appCalls, call => this.#createPubicCallRequestForCall(call, sender));
+    const setupCallRequests = await asyncMap(setupCalls, call =>
+      this.#createPubicCallRequestForCall(call, call.sender ?? sender),
+    );
+    const appCallRequests = await asyncMap(appCalls, call =>
+      this.#createPubicCallRequestForCall(call, call.sender ?? sender),
+    );
     const teardownCallRequest = teardownCall
-      ? await this.#createPubicCallRequestForCall(teardownCall, sender)
+      ? await this.#createPubicCallRequestForCall(teardownCall, teardownCall.sender ?? sender)
       : undefined;
 
     return createTxForPublicCalls(firstNullifier, setupCallRequests, appCallRequests, teardownCallRequest, feePayer);
@@ -71,24 +103,48 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     feePayer: AztecAddress = sender,
     /* need some unique first nullifier for note-nonce computations */
     firstNullifier = new Fr(420000 + this.txCount++),
-    globals = defaultGlobals(),
+    txLabel: string = 'unlabeledTx',
   ): Promise<PublicTxResult> {
     const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier);
 
     await this.setFeePayerBalance(feePayer);
 
-    const treesDB = new PublicTreesDB(this.merkleTree);
-    const contractsDB = new PublicContractsDB(this.contractDataSource);
-    const simulator = new PublicTxSimulator(treesDB, contractsDB, globals, /*doMerkleOperations=*/ true);
+    const txLabelWithCount = `${txLabel}.${this.txCount - 1}`;
+    const fullTxLabel = this.metricsPrefix ? `${this.metricsPrefix}.${txLabelWithCount}` : txLabelWithCount;
 
-    const startTime = performance.now();
-    const avmResult = await simulator.simulate(tx);
-    const endTime = performance.now();
-    this.logger.debug(`Public transaction simulation took ${endTime - startTime}ms`);
+    const avmResult = await this.simulator.simulate(tx, fullTxLabel);
+
+    // Something like this is often useful for debugging:
+    //if (avmResult.revertReason) {
+    //  // resolve / enrich revert reason
+    //  const lastAppCall = appCalls[appCalls.length - 1];
+
+    //  const contractArtifact =
+    //    lastAppCall.contractArtifact || (await this.contractDataSource.getContractArtifact(lastAppCall.address));
+    //  const fnAbi = getContractFunctionAbi(lastAppCall.fnName, contractArtifact!);
+    //  const revertReason = resolveAssertionMessageFromRevertData(avmResult.revertReason.revertData, fnAbi!);
+    //  this.logger.debug(`Revert reason: ${revertReason}`);
+    //}
 
     return avmResult;
   }
 
+  public async simulateTxWithLabel(
+    txLabel: string,
+    sender: AztecAddress,
+    setupCalls?: TestEnqueuedCall[],
+    appCalls?: TestEnqueuedCall[],
+    teardownCall?: TestEnqueuedCall,
+    feePayer?: AztecAddress,
+    firstNullifier?: Fr,
+  ): Promise<PublicTxResult> {
+    return await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier, txLabel);
+  }
+
+  public prettyPrintMetrics() {
+    this.metrics.prettyPrint();
+  }
+
   async #createPubicCallRequestForCall(
     call: TestEnqueuedCall,
     sender: AztecAddress,

package/src/public/hinting_db_sources.ts

@@ -1,21 +1,41 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import {
   AvmBytecodeCommitmentHint,
   AvmContractClassHint,
   AvmContractInstanceHint,
   type AvmExecutionHints,
+  AvmGetLeafPreimageHintNullifierTree,
+  AvmGetLeafPreimageHintPublicDataTree,
+  AvmGetLeafValueHint,
+  AvmGetPreviousValueIndexHint,
+  AvmGetSiblingPathHint,
 } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import {
+  AppendOnlyTreeSnapshot,
+  type IndexedTreeId,
+  MerkleTreeId,
+  type MerkleTreeLeafType,
+  NullifierLeaf,
+  PublicDataTreeLeaf,
+  type SequentialInsertionResult,
+  getTreeName,
+} from '@aztec/stdlib/trees';
+
+import { strict as assert } from 'assert';
 
-import type { PublicContractsDBInterface } from '../server.js';
+import type { PublicContractsDBInterface } from '../common/db_interfaces.js';
+import { PublicTreesDB } from './public_db_sources.js';
 
 /**
  * A public contracts database that forwards requests and collects AVM hints.
  */
 export class HintingPublicContractsDB implements PublicContractsDBInterface {
-  constructor(private readonly db: PublicContractsDBInterface, public readonly hints: AvmExecutionHints) {}
+  constructor(private readonly db: PublicContractsDBInterface, private hints: AvmExecutionHints) {}
 
   public async getContractInstance(
     address: AztecAddress,
@@ -69,3 +89,164 @@ export class HintingPublicContractsDB implements PublicContractsDBInterface {
     return await this.db.getDebugFunctionName(contractAddress, selector);
   }
 }
+
+/**
+ * A public trees database that forwards requests and collects AVM hints.
+ */
+export class HintingPublicTreesDB extends PublicTreesDB {
+  private static readonly log: Logger = createLogger('HintingPublicTreesDB');
+
+  constructor(db: PublicTreesDB, private hints: AvmExecutionHints) {
+    super(db);
+  }
+
+  // Getters.
+  public override async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
+    const path = await super.getSiblingPath<N>(treeId, index);
+    const key = await this.getHintKey(treeId);
+    this.hints.getSiblingPathHints.push(new AvmGetSiblingPathHint(key, treeId, index, path.toFields()));
+    return Promise.resolve(path);
+  }
+
+  public override async getPreviousValueIndex<ID extends IndexedTreeId>(
+    treeId: ID,
+    value: bigint,
+  ): Promise<
+    | {
+        index: bigint;
+        alreadyPresent: boolean;
+      }
+    | undefined
+  > {
+    const result = await super.getPreviousValueIndex(treeId, value);
+    if (result === undefined) {
+      throw new Error(
+        `getPreviousValueIndex(${getTreeName(
+          treeId,
+        )}, ${value}}) returned undefined. Possible wrong tree setup or corrupted state.`,
+      );
+    }
+    const key = await this.getHintKey(treeId);
+    this.hints.getPreviousValueIndexHints.push(
+      new AvmGetPreviousValueIndexHint(key, treeId, new Fr(value), result.index, result.alreadyPresent),
+    );
+    return result;
+  }
+
+  public override async getLeafPreimage<ID extends IndexedTreeId>(
+    treeId: ID,
+    index: bigint,
+  ): Promise<IndexedTreeLeafPreimage | undefined> {
+    const preimage = await super.getLeafPreimage<ID>(treeId, index);
+    if (preimage) {
+      const key = await this.getHintKey(treeId);
+
+      switch (treeId) {
+        case MerkleTreeId.PUBLIC_DATA_TREE:
+          this.hints.getLeafPreimageHintsPublicDataTree.push(
+            new AvmGetLeafPreimageHintPublicDataTree(
+              key,
+              index,
+              preimage.asLeaf() as PublicDataTreeLeaf,
+              preimage.getNextIndex(),
+              new Fr(preimage.getNextKey()),
+            ),
+          );
+          break;
+        case MerkleTreeId.NULLIFIER_TREE:
+          this.hints.getLeafPreimageHintsNullifierTree.push(
+            new AvmGetLeafPreimageHintNullifierTree(
+              key,
+              index,
+              preimage.asLeaf() as NullifierLeaf,
+              preimage.getNextIndex(),
+              new Fr(preimage.getNextKey()),
+            ),
+          );
+          break;
+        default:
+          // Use getLeafValue for the other trees.
+          throw new Error('getLeafPreimage only supported for PublicDataTree and NullifierTree!');
+          break;
+      }
+    }
+
+    return preimage;
+  }
+
+  public override async getLeafValue<ID extends MerkleTreeId>(
+    treeId: ID,
+    index: bigint,
+  ): Promise<MerkleTreeLeafType<typeof treeId> | undefined> {
+    // Use getLeafPreimage for PublicDataTree and NullifierTree.
+    assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+
+    const value = await super.getLeafValue<ID>(treeId, index);
+    if (value) {
+      const key = await this.getHintKey(treeId);
+      // We can cast to Fr because we know the type of the tree.
+      this.hints.getLeafValueHints.push(new AvmGetLeafValueHint(key, treeId, index, value as Fr));
+    }
+
+    return value;
+  }
+
+  // State modification.
+  public override async sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+  ): Promise<SequentialInsertionResult<TreeHeight>> {
+    HintingPublicTreesDB.log.debug('sequentialInsert not hinted yet!');
+    const beforeState = await this.getHintKey(treeId);
+
+    const result = await super.sequentialInsert<TreeHeight, ID>(treeId, leaves);
+
+    const afterState = await this.getHintKey(treeId);
+    HintingPublicTreesDB.log.debug(
+      `Evolved tree state (${getTreeName(treeId)}): ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${
+        afterState.root
+      }, ${afterState.nextAvailableLeafIndex}.`,
+    );
+
+    return result;
+  }
+
+  public override async revertCheckpoint(): Promise<void> {
+    HintingPublicTreesDB.log.debug('revertCheckpoint not hinted yet!');
+    // TODO(fcarreiro): we probably want to hint on StateReference hash.
+    // WARNING: is this enough? we might actually need the number of the checkpoint or similar...
+    // We will need to keep a stack of checkpoints on the C++ side.
+    const beforeState = {
+      [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+      [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+      [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+      [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+      [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE),
+    };
+
+    await super.revertCheckpoint();
+
+    const afterState = {
+      [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+      [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+      [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+      [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+      [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE),
+    };
+
+    HintingPublicTreesDB.log.debug('Evolved tree state:');
+    for (const treeId of Object.keys(beforeState)) {
+      const id: MerkleTreeId = treeId as unknown as MerkleTreeId;
+      const treeName = getTreeName(id);
+      HintingPublicTreesDB.log.debug(
+        `${treeName}: ${beforeState[id].root}, ${beforeState[id].nextAvailableLeafIndex} -> ${afterState[id].root}, ${afterState[id].nextAvailableLeafIndex}.`,
+      );
+    }
+  }
+
+  // Private methods.
+  private async getHintKey(treeId: MerkleTreeId): Promise<AppendOnlyTreeSnapshot> {
+    const treeInfo = await super.getTreeInfo(treeId);
+    return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
+  }
+}

package/src/public/index.ts

@@ -1,5 +1,5 @@
 export * from '../common/db_interfaces.js';
-export * from './public_tx_simulator/public_tx_simulator.js';
+export * from './public_tx_simulator/index.js';
 export * from './public_db_sources.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
 export { SideEffectTrace } from './side_effect_trace.js';

package/src/public/public_db_sources.ts

@@ -18,7 +18,6 @@ import type {
   BatchInsertionResult,
   IndexedTreeId,
   MerkleTreeLeafType,
-  MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
   SequentialInsertionResult,
   TreeInfo,
@@ -393,7 +392,7 @@ class ForwardMerkleTree implements MerkleTreeWriteOperations {
 export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInterface {
   private logger = createLogger('simulator:public-trees-db');
 
-  constructor(public db: MerkleTreeWriteOperations) {
+  constructor(private readonly db: MerkleTreeWriteOperations) {
     super(db);
   }
 
@@ -404,7 +403,22 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
    * @returns The current value in the storage slot.
    */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
-    return await readPublicState(this.db, contract, slot);
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+
+    const lowLeafResult = await this.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult) {
+      throw new Error('Low leaf not found');
+    }
+
+    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
+    await this.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+    // Unconditionally fetching the preimage for the hints. Move it to the hinting layer?
+    const preimage = (await this.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+
+    return lowLeafResult.alreadyPresent ? preimage.value : Fr.ZERO;
   }
 
   /**
@@ -417,12 +431,15 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
   public async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
     const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
     const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
-    await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
+    await this.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
   }
 
   public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
-    const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    const leafValue = await this.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
+    await this.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+
     this.logger.debug(`[DB] Fetched L1 to L2 message leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
@@ -433,7 +450,10 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
 
   public async getNoteHash(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
-    const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    const leafValue = await this.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
+    await this.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+
     this.logger.debug(`[DB] Fetched note hash leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
@@ -444,7 +464,16 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
 
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
-    const index = (await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    const lowLeafResult = await this.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    if (!lowLeafResult) {
+      throw new Error('Low leaf not found');
+    }
+    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
+    await this.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
+    await this.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    const index = lowLeafResult.alreadyPresent ? lowLeafResult.index : undefined;
+
     this.logger.debug(`[DB] Fetched nullifier index`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
@@ -453,19 +482,3 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     return index;
   }
 }
-
-export async function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr> {
-  const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
-
-  const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-  if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
-    return Fr.ZERO;
-  }
-
-  const preimage = (await db.getLeafPreimage(
-    MerkleTreeId.PUBLIC_DATA_TREE,
-    lowLeafResult.index,
-  )) as PublicDataTreeLeafPreimage;
-
-  return preimage.value;
-}

package/src/public/public_processor/public_processor.ts

@@ -34,7 +34,7 @@ import {
 import { ForkCheckpoint } from '@aztec/world-state/native';
 
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
-import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { type PublicTxSimulator, TelemetryPublicTxSimulator } from '../public_tx_simulator/index.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
 
 /**
@@ -87,8 +87,8 @@ export class PublicProcessorFactory {
     doMerkleOperations: boolean,
     skipFeeEnforcement: boolean,
     telemetryClient: TelemetryClient,
-  ) {
-    return new PublicTxSimulator(
+  ): PublicTxSimulator {
+    return new TelemetryPublicTxSimulator(
       treesDB,
       contractsDB,
       globalVariables,
@@ -488,7 +488,7 @@ export class PublicProcessor implements Traceable {
       if (phase.reverted) {
         this.metrics.recordRevertedPhase(phase.phase);
       } else {
-        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
+        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs ?? 0);
       }
     });