@aztec/pxe 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/src/entrypoints/server/store.ts

@@ -0,0 +1,47 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { type AztecLMDBStoreV2, openStoreAt } from '@aztec/kv-store/lmdb-v2';
+
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+
+import { storeIdentitySlug } from '../../storage/store_identity.js';
+
+/** Location and identity inputs for opening an identity-partitioned PXE-side store. */
+export type IdentityStoreConfig = {
+  dataDirectory: string;
+  /** Maximum LMDB map size in KB. When omitted, the kv-store default map size applies. */
+  dataStoreMapSizeKb?: number;
+  l1ChainId: number;
+  rollupAddress: EthAddress;
+};
+
+/**
+ * Opens the persistent LMDB store selected by `name` and identity triple `(l1ChainId, rollupAddress, schemaVersion)`.
+ * A store exists per identity: reopening with the same identity returns the same data, a different identity selects
+ * a different (possibly fresh) store. Callers wanting an ephemeral store use `openTmpStore` explicitly instead.
+ */
+export async function openStore(
+  name: string,
+  schemaVersion: number,
+  config: IdentityStoreConfig,
+  bindings?: LoggerBindings,
+): Promise<AztecLMDBStoreV2> {
+  // Stores live under `<dataDirectory>/<name>-stores/<l1ChainId>-<rollupAddress>-v<schemaVersion>`, a sibling of the
+  // legacy `<dataDirectory>/<name>` directory: older binaries reset the legacy directory on a rollup mismatch, so
+  // per-identity stores must not nest inside it.
+  const subDir = join(
+    config.dataDirectory,
+    `${name}-stores`,
+    storeIdentitySlug({ l1ChainId: config.l1ChainId, rollupAddress: config.rollupAddress, schemaVersion }),
+  );
+  await mkdir(subDir, { recursive: true });
+
+  createLogger(`pxe:data:${name}`, bindings).info(`Opening ${name} data store (LMDB v2)`, {
+    storeName: name,
+    subDir,
+    dataStoreMapSizeKb: config.dataStoreMapSizeKb,
+  });
+
+  return openStoreAt(subDir, config.dataStoreMapSizeKb, undefined, bindings);
+}

package/src/entrypoints/server/utils.ts

@@ -1,7 +1,7 @@
 import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { createLogger } from '@aztec/foundation/log';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { WASMSimulator } from '@aztec/simulator/client';
 import { MemoryCircuitRecorder, SimulatorRecorderWrapper } from '@aztec/simulator/server';
@@ -15,6 +15,7 @@ import type { PXEConfig } from '../../config/index.js';
 import { PXE } from '../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
 import { type PXECreationOptions, isPrivateKernelProver } from '../pxe_creation_options.js';
+import { openStore } from './store.js';
 
 type PXEConfigWithoutDefaults = Omit<
   PXEConfig,
@@ -46,12 +47,25 @@ export async function createPXE(
 
   if (!options.store) {
     const storeLogger = loggers.store ?? createLogger('pxe:data:lmdb', { actor });
-    options.store = await createStore(
-      'pxe_data',
-      PXE_DATA_SCHEMA_VERSION,
-      configWithContracts,
-      storeLogger.getBindings(),
-    );
+    options.store = configWithContracts.dataDirectory
+      ? await openStore(
+          'pxe_data',
+          PXE_DATA_SCHEMA_VERSION,
+          {
+            dataDirectory: configWithContracts.dataDirectory,
+            dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+            l1ChainId,
+            rollupAddress: l1ContractAddresses.rollupAddress,
+          },
+          storeLogger.getBindings(),
+        )
+      : await openTmpStore(
+          'pxe_data',
+          true,
+          configWithContracts.dataStoreMapSizeKb,
+          undefined,
+          storeLogger.getBindings(),
+        );
   }
   const proverLogger = loggers.prover ?? createLogger('pxe:bb:native', { actor });
 

package/src/events/event_service.ts

@@ -1,8 +1,10 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { InBlock } from '@aztec/stdlib/block';
 import { computePrivateEventCommitment, siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { BlockHeader, IndexedTxEffect } from '@aztec/stdlib/tx';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { EventValidationRequest } from '../contract_function_simulator/noir-structs/event_validation_request.js';
 import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
@@ -17,17 +19,17 @@ export class EventService {
   ) {}
 
   /**
-   * Validates and stores a batch of private events against pre-fetched tx effects.
+   * Validates and stores a batch of private events against the pre-fetched onchain context of their txs.
    *
    * @param requests - The events to validate and store.
    * @param scope - The scope under which the events are being stored.
-   * @param txEffects - Pre-fetched tx effects keyed by `TxHash.toString()`. Must contain entries for every request's
-   *                   txHash; missing entries are treated as a node bug and cause an error.
+   * @param validationTxData - The onchain context of each request's tx, keyed by `TxHash.toString()`. Must contain
+   * entries for every request's txHash; missing entries are treated as a node bug and cause an error.
    */
   public async validateAndStoreEvents(
     requests: EventValidationRequest[],
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
   ): Promise<void> {
     if (requests.length === 0) {
       return;
@@ -35,13 +37,15 @@ export class EventService {
 
     const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
 
-    await Promise.all(requests.map(req => this.#validateAndStoreEvent(req, scope, txEffects, anchorBlockNumber)));
+    await Promise.all(
+      requests.map(req => this.#validateAndStoreEvent(req, scope, validationTxData, anchorBlockNumber)),
+    );
   }
 
   async #validateAndStoreEvent(
     request: EventValidationRequest,
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
     anchorBlockNumber: number,
   ): Promise<void> {
     const {
@@ -71,15 +75,15 @@ export class EventService {
     // since `fetchTaggedLogs` only processes logs up to the synced block.
     const siloedEventCommitment = await siloNullifier(contractAddress, eventCommitment);
 
-    const txEffect = txEffects.get(txHash.toString());
-    if (!txEffect) {
+    const txData = validationTxData.get(txHash.toString());
+    if (!txData) {
       // We error out instead of just logging a warning and skipping the event because this would indicate a bug. This
       // is because the node has already served info about this tx either when obtaining the log (LogResult carries
       // the tx info) or when getting metadata for the offchain message (before the message got passed to `process_log`).
       throw new Error(`Could not find tx effect for tx hash ${txHash} when processing an event.`);
     }
 
-    if (txEffect.l2BlockNumber > anchorBlockNumber) {
+    if (txData.l2BlockNumber > anchorBlockNumber) {
       // We should never process a message from a tx past the anchor block. If we got here, a preprocessing step made
       // a mistake.
       throw new Error(
@@ -88,7 +92,7 @@ export class EventService {
     }
 
     // Find the index of the event commitment in the nullifiers array to determine event ordering within the tx
-    const eventIndexInTx = txEffect.data.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
+    const eventIndexInTx = txData.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
     if (eventIndexInTx === -1) {
       // Unlike in NoteService, this might not be a bug since the commitment hasn't been verified yet in the message
       // processing pipeline. A malformed or malicious message could trigger this condition. Because of this we don't
@@ -108,12 +112,18 @@ export class EventService {
         contractAddress,
         scope,
         txHash,
-        l2BlockNumber: txEffect.l2BlockNumber,
-        l2BlockHash: txEffect.l2BlockHash,
-        txIndexInBlock: txEffect.txIndexInBlock,
+        l2BlockNumber: txData.l2BlockNumber,
+        l2BlockHash: txData.l2BlockHash,
+        txIndexInBlock: txData.txIndexInBlock,
         eventIndexInTx,
       },
       this.jobId,
     );
   }
 }
+
+/** The onchain context of the tx an event validation request points at: where it was mined and its nullifiers. */
+export type EventValidationTxData = InBlock & {
+  nullifiers: Fr[];
+  txIndexInBlock: number;
+};

package/src/logs/log_service.ts

@@ -1,10 +1,10 @@
-import { PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { KeyStore } from '@aztec/key-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockHash, L2TipsProvider } from '@aztec/stdlib/block';
+import type { L2TipsProvider } from '@aztec/stdlib/block';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import {
@@ -15,20 +15,22 @@ import {
   computeSharedTaggingSecret,
 } from '@aztec/stdlib/logs';
 import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 
 import {
   type LogRetrievalRequest,
   LogSource,
 } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
-import type { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
-import type { PendingTaggedLog } from '../contract_function_simulator/noir-structs/pending_tagged_log.js';
-import { ResolvedTx } from '../contract_function_simulator/noir-structs/resolved_tx.js';
+import type { TxOnchainContext } from '../messages/tx_resolver_service.js';
 import { AddressStore } from '../storage/address_store/address_store.js';
+import { assertAllowedScope } from '../storage/allowed_scopes.js';
 import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
 import {
+  type LogQueryAnchor,
   getAllPrivateLogsByTags,
   getAllPublicLogsByTagsFromContract,
+  logQueryAnchorOf,
   syncTaggedPrivateLogs,
 } from '../tagging/index.js';
 
@@ -47,6 +49,7 @@ export class LogService {
     private readonly recipientTaggingStore: RecipientTaggingStore,
     private readonly taggingSecretSourcesStore: TaggingSecretSourcesStore,
     private readonly addressStore: AddressStore,
+    private readonly scopes: AztecAddress[],
     private readonly jobId: string,
     bindings?: LoggerBindings,
   ) {
@@ -57,7 +60,7 @@ export class LogService {
   public async fetchLogsByTag(
     contractAddress: AztecAddress,
     logRetrievalRequests: LogRetrievalRequest[],
-  ): Promise<LogRetrievalResponse[][]> {
+  ): Promise<RetrievedTaggedLog[][]> {
     for (const request of logRetrievalRequests) {
       if (!contractAddress.equals(request.contractAddress)) {
         throw new Error(`Got a log retrieval request from ${request.contractAddress}, expected ${contractAddress}`);
@@ -68,23 +71,23 @@ export class LogService {
       return [];
     }
 
-    const anchorBlockHash = await this.anchorBlockHeader.hash();
+    const anchor = await logQueryAnchorOf(this.anchorBlockHeader);
 
     const [publicLogsPerRequest, privateLogsPerRequest] = await Promise.all([
-      this.#fetchPublicLogs(contractAddress, logRetrievalRequests, anchorBlockHash),
-      this.#fetchPrivateLogs(logRetrievalRequests, anchorBlockHash),
+      this.#fetchPublicLogs(contractAddress, logRetrievalRequests, anchor),
+      this.#fetchPrivateLogs(logRetrievalRequests, anchor),
     ]);
 
     return logRetrievalRequests.map((_request, i) => [
-      ...publicLogsPerRequest[i].map(LogService.#toLogRetrievalResponse),
-      ...privateLogsPerRequest[i].map(LogService.#toLogRetrievalResponse),
+      ...publicLogsPerRequest[i].map(LogService.#toRetrievedTaggedLog),
+      ...privateLogsPerRequest[i].map(LogService.#toRetrievedTaggedLog),
     ]);
   }
 
   async #fetchPublicLogs(
     contractAddress: AztecAddress,
     requests: LogRetrievalRequest[],
-    anchorBlockHash: BlockHash,
+    anchor: LogQueryAnchor,
   ): Promise<LogResult[][]> {
     const indices = requests.flatMap((r, i) => (r.source !== LogSource.PRIVATE ? [i] : []));
     if (indices.length === 0) {
@@ -97,13 +100,11 @@ export class LogService {
     await Promise.all(
       Array.from(groups.values()).map(async group => {
         const tags = group.entries.map(e => e.request.tag);
-        const results = await getAllPublicLogsByTagsFromContract(
-          this.aztecNode,
-          contractAddress,
-          tags,
-          anchorBlockHash,
-          { fromBlock: group.fromBlock, toBlock: group.toBlock, includeEffects: true },
-        );
+        const results = await getAllPublicLogsByTagsFromContract(this.aztecNode, contractAddress, tags, anchor, {
+          fromBlock: group.fromBlock,
+          toBlock: group.toBlock,
+          includeEffects: true,
+        });
         group.entries.forEach((entry, i) => {
           resultsPerRequest[entry.index] = results[i];
         });
@@ -113,7 +114,7 @@ export class LogService {
     return resultsPerRequest;
   }
 
-  async #fetchPrivateLogs(requests: LogRetrievalRequest[], anchorBlockHash: BlockHash): Promise<LogResult[][]> {
+  async #fetchPrivateLogs(requests: LogRetrievalRequest[], anchor: LogQueryAnchor): Promise<LogResult[][]> {
     const indices = requests.flatMap((r, i) => (r.source !== LogSource.PUBLIC ? [i] : []));
     if (indices.length === 0) {
       return requests.map(() => []);
@@ -127,7 +128,7 @@ export class LogService {
         const siloedTags = await Promise.all(
           group.entries.map(e => SiloedTag.computeFromTagAndApp(e.request.tag, e.request.contractAddress)),
         );
-        const results = await getAllPrivateLogsByTags(this.aztecNode, siloedTags, anchorBlockHash, {
+        const results = await getAllPrivateLogsByTags(this.aztecNode, siloedTags, anchor, {
           fromBlock: group.fromBlock,
           toBlock: group.toBlock,
           includeEffects: true,
@@ -163,7 +164,7 @@ export class LogService {
     return groups;
   }
 
-  static #toLogRetrievalResponse(log: LogResult): LogRetrievalResponse {
+  static #toRetrievedTaggedLog(log: LogResult): RetrievedTaggedLog {
     // includeEffects: true was used, so noteHashes and nullifiers are populated. Every tx has at least one nullifier
     // (the first nullifier derived from the tx hash); empty here would indicate a buggy node.
     const noteHashes = log.noteHashes!;
@@ -172,23 +173,27 @@ export class LogService {
       throw new Error(`Log for tx ${log.txHash} returned no nullifiers from the node`);
     }
     return {
-      // Skip the tag, and clip to the wire cap: public logs can exceed PRIVATE_LOG_CIPHERTEXT_LEN, which is the fixed
-      // size of the oracle's BoundedVec slot. A no-op for private logs, which are already within the cap.
-      logPayload: log.logData.slice(1, 1 + PRIVATE_LOG_CIPHERTEXT_LEN),
+      logData: log.logData,
       txHash: log.txHash,
-      uniqueNoteHashesInTx: noteHashes,
-      firstNullifierInTx: nullifiers[0],
+      noteHashes,
+      nullifiers,
       blockNumber: log.blockNumber,
       blockTimestamp: log.blockTimestamp,
       blockHash: log.blockHash,
+      // The log index and the tx receipt both count the tx's position in `block.body.txEffects`, so this is the same
+      // index a receipt reports. Note ordering depends on the two staying in agreement.
+      txIndexInBlock: log.txIndexWithinBlock,
     };
   }
 
+  /** Fetches the pending tagged logs for a recipient across all its tagging secrets for the contract. */
   public async fetchTaggedLogs(
     contractAddress: AztecAddress,
     recipient: AztecAddress,
     providedSecrets: AppTaggingSecret[],
-  ): Promise<PendingTaggedLog[]> {
+  ): Promise<RetrievedTaggedLog[]> {
+    assertAllowedScope(recipient, this.scopes);
+
     this.log.verbose(
       `Fetching tagged logs for contract ${contractAddress.toString()} and recipient ${recipient.toString()}`,
     );
@@ -213,17 +218,7 @@ export class LogService {
       this.jobId,
     );
 
-    return logs.map(log => {
-      const noteHashes = log.noteHashes!;
-      const nullifiers = log.nullifiers!;
-      if (nullifiers.length === 0) {
-        throw new Error(`Log for tx ${log.txHash} returned no nullifiers from the node`);
-      }
-      return {
-        log: log.logData,
-        context: new ResolvedTx(log.txHash, noteHashes, nullifiers[0], log.blockNumber, log.blockHash.toFr()),
-      };
-    });
+    return logs.map(log => LogService.#toRetrievedTaggedLog(log));
   }
 
   /**
@@ -289,3 +284,10 @@ export class LogService {
     );
   }
 }
+
+/** A tagged log fetched from the node, together with the onchain context of the tx that emitted it. */
+export type RetrievedTaggedLog = TxOnchainContext & {
+  /** The raw log payload, tag included. */
+  logData: Fr[];
+  blockTimestamp: UInt64;
+};

package/src/messages/tx_resolver_service.ts

@@ -1,22 +1,22 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { uniqueBy } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import { type IndexedTxEffect, TxHash } from '@aztec/stdlib/tx';
 
-import { ResolvedTx } from '../contract_function_simulator/noir-structs/resolved_tx.js';
-
-/** Resolves transaction hashes into their on-chain context (note hashes, first nullifier, and mined block). */
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */
 export class TxResolverService {
   constructor(private readonly aztecNode: AztecNode) {}
 
   /**
    * Resolves a list of tx hashes into their on-chain context.
    *
-   * For each tx hash, looks up the corresponding tx effect and extracts the note hashes, first nullifier, and the
-   * number and hash of the block it was mined in. Returns `null` for tx hashes that are zero, not yet available, or in
-   * blocks beyond the anchor block.
+   * For each tx hash, looks up the corresponding tx effect and extracts its note hashes and nullifiers, and the
+   * position it was mined at. Returns `null` for tx hashes that are zero, not yet available, or in blocks beyond the
+   * anchor block.
    */
-  async resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(ResolvedTx | null)[]> {
+  async resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(TxOnchainContext | null)[]> {
     const nonZeroTxHashes = txHashes.filter(h => !h.isZero()).map(h => TxHash.fromField(h));
     const uniqueTxHashes = uniqueBy(nonZeroTxHashes, h => h.toString());
     const fetched = await Promise.all(
@@ -51,19 +51,30 @@ export class TxResolverService {
       }
 
       // Every tx has at least one nullifier (the first nullifier derived from the tx hash). Hitting this condition
-      // would mean a buggy node, but since we need to access data.nullifiers[0], the defensive check does no harm.
+      // would mean a buggy node, but since consumers rely on nullifiers[0], the defensive check does no harm.
       const data = txEffect.data;
       if (data.nullifiers.length === 0) {
         throw new Error(`Tx effect for ${txHash} has no nullifiers`);
       }
 
-      return new ResolvedTx(
-        data.txHash,
-        data.noteHashes,
-        data.nullifiers[0],
-        txEffect.l2BlockNumber,
-        txEffect.l2BlockHash.toFr(),
-      );
+      return {
+        txHash: data.txHash,
+        noteHashes: data.noteHashes,
+        nullifiers: data.nullifiers,
+        blockNumber: txEffect.l2BlockNumber,
+        blockHash: txEffect.l2BlockHash,
+        txIndexInBlock: txEffect.txIndexInBlock,
+      };
     });
   }
 }
+
+/** The onchain context of a tx: the position it was mined at, and the effects it produced. */
+export type TxOnchainContext = {
+  txHash: TxHash;
+  noteHashes: Fr[];
+  nullifiers: Fr[];
+  blockNumber: BlockNumber;
+  blockHash: BlockHash;
+  txIndexInBlock: number;
+};

package/src/node/benchmarked_node.ts

@@ -0,0 +1,140 @@
+import { Timer } from '@aztec/foundation/timer';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats } from '@aztec/stdlib/tx';
+
+/*
+ * Proxy generator for an AztecNode that tracks the time taken for each RPC call and the number of round trips (actual
+ * blocking waits for node responses).
+ *
+ * A round trip is counted when we transition from 0 to 1 in-flight calls, and ends when all concurrent calls complete.
+ * This means parallel calls in Promise.all count as a single round trip.
+ *
+ * Note that batching of RPC calls in `safe_json_rpc_client.ts` could affect the round trip counts but in places we
+ * currently use this information we do not even use HTTP as we have direct access to the Aztec Node instance in TS
+ * (i.e. not running against external node) so this is not a problem for now.
+ *
+ * If you want to use this against external node and the info gets skewed by batching you can set the `maxBatchSize`
+ * value in `safe_json_rpc_client.ts` to 1 (the main motivation for batching was to get around parallel http requests
+ * limits in web browsers which is not a problem when debugging in node.js).
+ */
+export interface Recording {
+  /** Closes the recording and returns what it saw. Reads served after this are not recorded. */
+  stop(): NodeStats;
+}
+
+/** An {@link AztecNode} wrapper that can report the reads it serves. */
+export interface BenchmarkedAztecNode extends AztecNode {
+  /**
+   * Opens a recording of the reads this wrapper serves, until {@link Recording.stop}. Recordings are independent, so
+   * several may run at once: one measuring a whole run sees the same reads as one measuring a single operation.
+   *
+   * Nothing is measured while none is open, which is what keeps a long-lived wrapper from accumulating a run's worth
+   * of timings nobody asked for.
+   */
+  startRecording(): Recording;
+}
+
+/** Wraps `node` so that the reads it answers can be recorded. */
+export function withRecording(node: AztecNode): BenchmarkedAztecNode {
+  // The stats of every recording currently open
+  const open = new Set<NodeStats>();
+
+  // Round trip tracking
+  let inFlightCount = 0;
+  let currentRoundTripTimer: Timer | null = null;
+  let currentRoundTripMethods: string[] = [];
+
+  return new Proxy(node, {
+    get(target, prop) {
+      if (prop === 'startRecording') {
+        return (): Recording => {
+          const stats: NodeStats = {
+            perMethod: {},
+            roundTrips: { roundTrips: 0, totalBlockingTime: 0, roundTripDurations: [], roundTripMethods: [] },
+          };
+          open.add(stats);
+          return {
+            stop: () => {
+              open.delete(stats);
+              return stats;
+            },
+          };
+        };
+      }
+
+      const value = Reflect.get(target, prop);
+      if (typeof value !== 'function' || typeof prop !== 'string') {
+        return value;
+      }
+
+      return (...args: unknown[]) => {
+        // With no recording open there is nobody to report to, so the read is left untimed.
+        if (open.size === 0) {
+          return value.apply(target, args);
+        }
+
+        // Start of a new round trip batch?
+        if (inFlightCount === 0) {
+          currentRoundTripTimer = new Timer();
+          currentRoundTripMethods = [];
+        }
+        inFlightCount++;
+        currentRoundTripMethods.push(prop);
+
+        const callTimer = new Timer();
+        const result = value.apply(target, args);
+
+        // Handle completion - called when the call finishes (after Promise resolves)
+        const handleCompletion = () => {
+          const callTime = callTimer.ms();
+          for (const stats of open) {
+            timesFor(stats, prop).push(callTime);
+          }
+
+          inFlightCount--;
+
+          // End of round trip batch - all concurrent calls completed
+          if (inFlightCount === 0 && currentRoundTripTimer) {
+            const roundTripTime = currentRoundTripTimer.ms();
+            for (const { roundTrips } of open) {
+              roundTrips.roundTrips++;
+              roundTrips.totalBlockingTime += roundTripTime;
+              roundTrips.roundTripDurations.push(roundTripTime);
+              roundTrips.roundTripMethods.push(currentRoundTripMethods);
+            }
+            currentRoundTripTimer = null;
+            currentRoundTripMethods = [];
+          }
+        };
+
+        // If the result is a Promise, chain the completion handler
+        if (isThenable(result)) {
+          return result.then(
+            resolved => {
+              handleCompletion();
+              return resolved;
+            },
+            error => {
+              handleCompletion();
+              throw error;
+            },
+          );
+        } else {
+          // Synchronous method - handle completion immediately
+          handleCompletion();
+          return result;
+        }
+      };
+    },
+  }) as BenchmarkedAztecNode;
+}
+
+/** The times `stats` holds for `method`, added on first use. */
+function timesFor(stats: NodeStats, method: string) {
+  return (stats.perMethod[method as keyof AztecNode] ??= { times: [] }).times;
+}
+
+/** Whether completion can be chained onto `value` with `.then`, which a promise from any implementation allows. */
+function isThenable(value: unknown): value is PromiseLike<unknown> {
+  return typeof value === 'object' && value !== null && 'then' in value && typeof value.then === 'function';
+}