@aztec/simulator 0.82.2 → 0.82.3-nightly.20250403

package/src/public/hinting_db_sources.ts

@@ -1,21 +1,45 @@
-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,
+  AvmSequentialInsertHintNullifierTree,
+  AvmSequentialInsertHintPublicDataTree,
 } 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,
+  NullifierLeafPreimage,
+  PublicDataTreeLeaf,
+  PublicDataTreeLeafPreimage,
+  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 +93,204 @@ 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 as PublicDataTreeLeafPreimage),
+          );
+          break;
+        case MerkleTreeId.NULLIFIER_TREE:
+          this.hints.getLeafPreimageHintsNullifierTree.push(
+            new AvmGetLeafPreimageHintNullifierTree(key, index, preimage as NullifierLeafPreimage),
+          );
+          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.
+  // FIXME(fcarreiro): This is a horrible interface (in the merkle ops). It's receiving the leaves as buffers,
+  // from a leaf class that is NOT the one that will be used to write. Make this type safe.
+  public override async sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+  ): Promise<SequentialInsertionResult<TreeHeight>> {
+    // Use appendLeaf for NoteHashTree and L1ToL2MessageTree.
+    assert(treeId == MerkleTreeId.PUBLIC_DATA_TREE || treeId == MerkleTreeId.NULLIFIER_TREE);
+    // We only support 1 leaf at a time for now. Can easily be extended.
+    assert(leaves.length === 1, 'sequentialInsert supports only one leaf at a time!');
+
+    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}.`,
+    );
+
+    switch (treeId) {
+      case MerkleTreeId.PUBLIC_DATA_TREE:
+        this.hints.sequentialInsertHintsPublicDataTree.push(
+          new AvmSequentialInsertHintPublicDataTree(
+            beforeState,
+            afterState,
+            treeId,
+            PublicDataTreeLeaf.fromBuffer(leaves[0]),
+            {
+              leaf: result.lowLeavesWitnessData[0].leafPreimage as PublicDataTreeLeafPreimage,
+              index: result.lowLeavesWitnessData[0].index,
+              path: result.lowLeavesWitnessData[0].siblingPath.toFields(),
+            },
+            {
+              leaf: result.insertionWitnessData[0].leafPreimage as PublicDataTreeLeafPreimage,
+              index: result.insertionWitnessData[0].index,
+              path: result.insertionWitnessData[0].siblingPath.toFields(),
+            },
+          ),
+        );
+        break;
+      case MerkleTreeId.NULLIFIER_TREE:
+        this.hints.sequentialInsertHintsNullifierTree.push(
+          new AvmSequentialInsertHintNullifierTree(
+            beforeState,
+            afterState,
+            treeId,
+            NullifierLeaf.fromBuffer(leaves[0]),
+            {
+              leaf: result.lowLeavesWitnessData[0].leafPreimage as NullifierLeafPreimage,
+              index: result.lowLeavesWitnessData[0].index,
+              path: result.lowLeavesWitnessData[0].siblingPath.toFields(),
+            },
+            {
+              leaf: result.insertionWitnessData[0].leafPreimage as NullifierLeafPreimage,
+              index: result.insertionWitnessData[0].index,
+              path: result.insertionWitnessData[0].siblingPath.toFields(),
+            },
+          ),
+        );
+        break;
+      default:
+        throw new Error('sequentialInsert only supported for PublicDataTree and NullifierTree!');
+        break;
+    }
+
+    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.leaf.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,
@@ -131,7 +131,8 @@ export class PublicProcessor implements Traceable {
   /**
    * Run each tx through the public circuit and the public kernel circuit if needed.
    * @param txs - Txs to process.
-   * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
+   * @param limits - Limits for processing the txs.
+   * @param validator - Pre-process validator and nullifier cache to use for processing the txs.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
   public async process(
@@ -142,14 +143,13 @@ export class PublicProcessor implements Traceable {
       maxBlockGas?: Gas;
       deadline?: Date;
     } = {},
-    validators: {
+    validator: {
       preprocessValidator?: TxValidator<Tx>;
-      postprocessValidator?: TxValidator<ProcessedTx>;
       nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
     } = {},
   ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
-    const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
+    const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
     const timer = new Timer();
@@ -242,26 +242,6 @@ export class PublicProcessor implements Traceable {
           continue;
         }
 
-        // Re-validate the transaction
-        if (postprocessValidator) {
-          // Only accept processed transactions that are not double-spends,
-          // public functions emitting nullifiers would pass earlier check but fail here.
-          // Note that we're checking all nullifiers generated in the private execution twice,
-          // we could store the ones already checked and skip them here as an optimization.
-          // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
-          const result = await postprocessValidator.validateTx(processedTx);
-          if (result.result !== 'valid') {
-            const reason = result.reason.join(', ');
-            this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
-            failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
-            // Need to revert the checkpoint here and don't go any further
-            await checkpoint.revert();
-            continue;
-          } else {
-            this.log.trace(`Tx ${txHash.toString()} is valid post processing.`);
-          }
-        }
-
         if (!tx.hasPublicCalls()) {
           // If there are no public calls, perform all tree insertions for side effects from private
           // When there are public calls, the PublicTxSimulator & AVM handle tree insertions.
@@ -488,7 +468,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);
       }
     });