@aztec/pxe 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

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 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';
 
@@ -58,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}`);
@@ -69,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) {
@@ -98,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];
         });
@@ -114,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(() => []);
@@ -128,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,
@@ -164,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!;
@@ -173,23 +173,25 @@ 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(
@@ -216,23 +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: {
-          txHash: log.txHash,
-          uniqueNoteHashesInTx: noteHashes,
-          firstNullifierInTx: nullifiers[0],
-          blockNumber: log.blockNumber,
-          blockHash: log.blockHash.toFr(),
-        },
-      };
-    });
+    return logs.map(log => LogService.#toRetrievedTaggedLog(log));
   }
 
   /**
@@ -298,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 type { 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,7 +51,7 @@ 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`);
@@ -59,11 +59,22 @@ export class TxResolverService {
 
       return {
         txHash: data.txHash,
-        uniqueNoteHashesInTx: data.noteHashes,
-        firstNullifierInTx: data.nullifiers[0],
+        noteHashes: data.noteHashes,
+        nullifiers: data.nullifiers,
         blockNumber: txEffect.l2BlockNumber,
-        blockHash: txEffect.l2BlockHash.toFr(),
+        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';
+}