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

package/dest/logs/log_service.js

@@ -1,9 +1,8 @@
-import { PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { AppTaggingSecret, AppTaggingSecretKind, SiloedTag, computeSharedTaggingSecret } from '@aztec/stdlib/logs';
 import { LogSource } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
 import { assertAllowedScope } from '../storage/allowed_scopes.js';
-import { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, syncTaggedPrivateLogs } from '../tagging/index.js';
+import { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, logQueryAnchorOf, syncTaggedPrivateLogs } from '../tagging/index.js';
 const rangeKey = (fromBlock, toBlock)=>`${fromBlock ?? ''}-${toBlock ?? ''}`;
 export class LogService {
     aztecNode;
@@ -37,17 +36,17 @@ export class LogService {
         if (logRetrievalRequests.length === 0) {
             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, requests, anchorBlockHash) {
+    async #fetchPublicLogs(contractAddress, requests, anchor) {
         const indices = requests.flatMap((r, i)=>r.source !== LogSource.PRIVATE ? [
                 i
             ] : []);
@@ -61,7 +60,7 @@ 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, {
+            const results = await getAllPublicLogsByTagsFromContract(this.aztecNode, contractAddress, tags, anchor, {
                 fromBlock: group.fromBlock,
                 toBlock: group.toBlock,
                 includeEffects: true
@@ -72,7 +71,7 @@ export class LogService {
         }));
         return resultsPerRequest;
     }
-    async #fetchPrivateLogs(requests, anchorBlockHash) {
+    async #fetchPrivateLogs(requests, anchor) {
         const indices = requests.flatMap((r, i)=>r.source !== LogSource.PUBLIC ? [
                 i
             ] : []);
@@ -86,7 +85,7 @@ export class LogService {
             })));
         await Promise.all(Array.from(groups.values()).map(async (group)=>{
             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
@@ -121,7 +120,7 @@ export class LogService {
         }
         return groups;
     }
-    static #toLogRetrievalResponse(log) {
+    static #toRetrievedTaggedLog(log) {
         // 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;
@@ -130,18 +129,19 @@ 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
+            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
         };
     }
-    async fetchTaggedLogs(contractAddress, recipient, providedSecrets) {
+    /** Fetches the pending tagged logs for a recipient across all its tagging secrets for the contract. */ async fetchTaggedLogs(contractAddress, recipient, providedSecrets) {
         assertAllowedScope(recipient, this.scopes);
         this.log.verbose(`Fetching tagged logs for contract ${contractAddress.toString()} and recipient ${recipient.toString()}`);
         const l2Tips = await this.l2TipsStore.getL2Tips();
@@ -159,23 +159,7 @@ export class LogService {
                 secret
             ])).values());
         const logs = await syncTaggedPrivateLogs(secrets, this.aztecNode, this.recipientTaggingStore, this.anchorBlockHeader, l2Tips.finalized.block.number, 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));
     }
     /**
    * Computes the tagging secrets PXE can enumerate for a recipient: one per known sender (via ECDH) plus any

package/dest/messages/tx_resolver_service.d.ts

@@ -1,17 +1,28 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-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). */
+import { TxHash } from '@aztec/stdlib/tx';
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */
 export declare class TxResolverService {
     private readonly aztecNode;
     constructor(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.
      */
-    resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(ResolvedTx | null)[]>;
+    resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(TxOnchainContext | null)[]>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcmVzb2x2ZXJfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lc3NhZ2VzL3R4X3Jlc29sdmVyX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBR2pFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLDREQUE0RCxDQUFDO0FBRTdGLCtHQUErRztBQUMvRyxxQkFBYSxpQkFBaUI7SUFDaEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBQXRDLFlBQTZCLFNBQVMsRUFBRSxTQUFTLEVBQUk7SUFFckQ7Ozs7OztPQU1HO0lBQ0csVUFBVSxDQUFDLFFBQVEsRUFBRSxFQUFFLEVBQUUsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FpRDFGO0NBQ0YifQ==
+/** 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;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcmVzb2x2ZXJfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lc3NhZ2VzL3R4X3Jlc29sdmVyX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBd0IsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEUsNkdBQTZHO0FBQzdHLHFCQUFhLGlCQUFpQjtJQUNoQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFBdEMsWUFBNkIsU0FBUyxFQUFFLFNBQVMsRUFBSTtJQUVyRDs7Ozs7O09BTUc7SUFDRyxVQUFVLENBQUMsUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLENBa0RoRztDQUNGO0FBRUQsOEZBQThGO0FBQzlGLE1BQU0sTUFBTSxnQkFBZ0IsR0FBRztJQUM3QixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2YsVUFBVSxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQ2pCLFVBQVUsRUFBRSxFQUFFLEVBQUUsQ0FBQztJQUNqQixXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLFNBQVMsRUFBRSxTQUFTLENBQUM7SUFDckIsY0FBYyxFQUFFLE1BQU0sQ0FBQztDQUN4QixDQUFDIn0=

package/dest/messages/tx_resolver_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tx_resolver_service.d.ts","sourceRoot":"","sources":["../../src/messages/tx_resolver_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAGjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4DAA4D,CAAC;AAE7F,+GAA+G;AAC/G,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,SAAS,EAAI;IAErD;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,CAiD1F;CACF"}
+{"version":3,"file":"tx_resolver_service.d.ts","sourceRoot":"","sources":["../../src/messages/tx_resolver_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAwB,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEhE,6GAA6G;AAC7G,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,SAAS,EAAI;IAErD;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,CAkDhG;CACF;AAED,8FAA8F;AAC9F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dest/messages/tx_resolver_service.js

@@ -1,6 +1,6 @@
 import { uniqueBy } from '@aztec/foundation/collection';
 import { TxHash } from '@aztec/stdlib/tx';
-/** Resolves transaction hashes into their on-chain context (note hashes, first nullifier, and mined block). */ export class TxResolverService {
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */ export class TxResolverService {
     aztecNode;
     constructor(aztecNode){
         this.aztecNode = aztecNode;
@@ -8,9 +8,9 @@ import { TxHash } from '@aztec/stdlib/tx';
     /**
    * 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, anchorBlockNumber) {
         const nonZeroTxHashes = txHashes.filter((h)=>!h.isZero()).map((h)=>TxHash.fromField(h));
         const uniqueTxHashes = uniqueBy(nonZeroTxHashes, (h)=>h.toString());
@@ -43,17 +43,18 @@ import { TxHash } from '@aztec/stdlib/tx';
                 return null;
             }
             // 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 {
                 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
             };
         });
     }

package/dest/node/benchmarked_node.d.ts

@@ -0,0 +1,20 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats } from '@aztec/stdlib/tx';
+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 declare function withRecording(node: AztecNode): BenchmarkedAztecNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVuY2htYXJrZWRfbm9kZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL25vZGUvYmVuY2htYXJrZWRfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQWlCbEQsTUFBTSxXQUFXLFNBQVM7SUFDeEIsOEZBQThGO0lBQzlGLElBQUksSUFBSSxTQUFTLENBQUM7Q0FDbkI7QUFFRCx3RUFBd0U7QUFDeEUsTUFBTSxXQUFXLG9CQUFxQixTQUFRLFNBQVM7SUFDckQ7Ozs7OztPQU1HO0lBQ0gsY0FBYyxJQUFJLFNBQVMsQ0FBQztDQUM3QjtBQUVELGlFQUFpRTtBQUNqRSx3QkFBZ0IsYUFBYSxDQUFDLElBQUksRUFBRSxTQUFTLEdBQUcsb0JBQW9CLENBNEZuRSJ9

package/dest/node/benchmarked_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarked_node.d.ts","sourceRoot":"","sources":["../../src/node/benchmarked_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAiBlD,MAAM,WAAW,SAAS;IACxB,8FAA8F;IAC9F,IAAI,IAAI,SAAS,CAAC;CACnB;AAED,wEAAwE;AACxE,MAAM,WAAW,oBAAqB,SAAQ,SAAS;IACrD;;;;;;OAMG;IACH,cAAc,IAAI,SAAS,CAAC;CAC7B;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,oBAAoB,CA4FnE"}

package/dest/node/benchmarked_node.js

@@ -0,0 +1,94 @@
+import { Timer } from '@aztec/foundation/timer';
+/** Wraps `node` so that the reads it answers can be recorded. */ export function withRecording(node) {
+    // The stats of every recording currently open
+    const open = new Set();
+    // Round trip tracking
+    let inFlightCount = 0;
+    let currentRoundTripTimer = null;
+    let currentRoundTripMethods = [];
+    return new Proxy(node, {
+        get (target, prop) {
+            if (prop === 'startRecording') {
+                return ()=>{
+                    const stats = {
+                        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)=>{
+                // 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;
+                }
+            };
+        }
+    });
+}
+/** The times `stats` holds for `method`, added on first use. */ function timesFor(stats, method) {
+    return (stats.perMethod[method] ??= {
+        times: []
+    }).times;
+}
+/** Whether completion can be chained onto `value` with `.then`, which a promise from any implementation allows. */ function isThenable(value) {
+    return typeof value === 'object' && value !== null && 'then' in value && typeof value.then === 'function';
+}

package/dest/node/caching_aztec_node.d.ts

@@ -0,0 +1,24 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type BenchmarkedAztecNode } from './benchmarked_node.js';
+/**
+ * An {@link AztecNode} wrapper that serves repeated reads from a cache it owns.
+ */
+export interface CachingAztecNode extends BenchmarkedAztecNode {
+    /** Clears the read cache. The owner calls this periodically to bound memory. Cached entries never go stale. */
+    wipeCache(): void;
+}
+/**
+ * Wraps `node`, serving repeated reads from a cache the wrapper owns. Consumers share cached reads by sharing the
+ * wrapper.
+ *
+ * Only hash-pinned reads are cached. A block hash names immutable content, so the same call can never correctly answer
+ * differently, and even an `undefined` witness or leaf index is kept as a non-membership fact. That makes the wrapper
+ * safe for any consumer, whatever its anchor block. Uncached methods, and reads that name a block any other way (see
+ * {@link hashReferenceOf}), pass straight through. A few entries below opt out even when hash-pinned, where the answer
+ * can still change, and the tag queries opt in only once the request also stops short of blocks yet to be produced
+ * (see {@link hasImmutableAnswer}).
+ *
+ * Wiping (see {@link CachingAztecNode.wipeCache}) bounds memory. Correctness does not depend on it.
+ */
+export declare function withCache(node: AztecNode): CachingAztecNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZ19henRlY19ub2RlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm9kZS9jYWNoaW5nX2F6dGVjX25vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFZakUsT0FBTyxFQUFFLEtBQUssb0JBQW9CLEVBQWlCLE1BQU0sdUJBQXVCLENBQUM7QUFFakY7O0dBRUc7QUFDSCxNQUFNLFdBQVcsZ0JBQWlCLFNBQVEsb0JBQW9CO0lBQzVELCtHQUErRztJQUMvRyxTQUFTLElBQUksSUFBSSxDQUFDO0NBQ25CO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQWdCLFNBQVMsQ0FBQyxJQUFJLEVBQUUsU0FBUyxHQUFHLGdCQUFnQixDQXdKM0QifQ==

package/dest/node/caching_aztec_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caching_aztec_node.d.ts","sourceRoot":"","sources":["../../src/node/caching_aztec_node.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAYjE,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,uBAAuB,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,+GAA+G;IAC/G,SAAS,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,gBAAgB,CAwJ3D"}

package/dest/node/caching_aztec_node.js

@@ -0,0 +1,267 @@
+import { BlockHash } from '@aztec/stdlib/block';
+import { withRecording } from './benchmarked_node.js';
+/**
+ * Wraps `node`, serving repeated reads from a cache the wrapper owns. Consumers share cached reads by sharing the
+ * wrapper.
+ *
+ * Only hash-pinned reads are cached. A block hash names immutable content, so the same call can never correctly answer
+ * differently, and even an `undefined` witness or leaf index is kept as a non-membership fact. That makes the wrapper
+ * safe for any consumer, whatever its anchor block. Uncached methods, and reads that name a block any other way (see
+ * {@link hashReferenceOf}), pass straight through. A few entries below opt out even when hash-pinned, where the answer
+ * can still change, and the tag queries opt in only once the request also stops short of blocks yet to be produced
+ * (see {@link hasImmutableAnswer}).
+ *
+ * Wiping (see {@link CachingAztecNode.wipeCache}) bounds memory. Correctness does not depend on it.
+ */ export function withCache(node) {
+    const cache = new AztecNodeCache();
+    // The recording wrapper sits below the cache, so a recording sees only the reads the node answered: a read served
+    // from the cache appears nowhere in it. Every read below goes to `source` rather than to `node`, and
+    // `startRecording` passes through this wrapper untouched.
+    const source = withRecording(node);
+    /** Runs `read` through `cache` when `block` pins a chain position by hash. Everything else goes to the node. */ const readCachedIfBlockIsHashPinned = (block, key, read, options)=>{
+        const blockHash = hashReferenceOf(block);
+        return blockHash === undefined ? read() : cache.fetch(key(blockHash.toString()), read, options);
+    };
+    const cachedReads = {
+        getBlock: (block, options)=>{
+            if (options?.includeL1PublishInfo || options?.includeAttestations) {
+                // These payloads keep changing after a block is fixed (its L1 publication status, its incoming committee
+                // attestations), so a repeat can correctly differ; read straight from the node.
+                return source.getBlock(block, options);
+            }
+            return readCachedIfBlockIsHashPinned(block, (blockHash)=>`block:${blockHash}:${keyPart(options)}`, ()=>source.getBlock(block, options), {
+                // PXE only asks for pinned blocks it has already observed, so an undefined answer means the node has not
+                // served the block yet, not that it never will.
+                shouldCache: (response)=>response !== undefined
+            });
+        },
+        getContract: (address, referenceBlock)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`contract:${blockHash}:${address.toString()}`, ()=>source.getContract(address, referenceBlock)),
+        getBlockHashMembershipWitness: (referenceBlock, blockHash)=>readCachedIfBlockIsHashPinned(referenceBlock, (referenceHash)=>`block-hash-membership-witness:${referenceHash}:${blockHash.toString()}`, ()=>source.getBlockHashMembershipWitness(referenceBlock, blockHash)),
+        getPublicDataWitness: (referenceBlock, leafSlot)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`public-data-witness:${blockHash}:${leafSlot.toString()}`, ()=>source.getPublicDataWitness(referenceBlock, leafSlot)),
+        getNoteHashMembershipWitness: (referenceBlock, noteHash)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`note-hash-membership-witness:${blockHash}:${noteHash.toString()}`, ()=>source.getNoteHashMembershipWitness(referenceBlock, noteHash)),
+        getNullifierMembershipWitness: (referenceBlock, nullifier)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`nullifier-membership-witness:${blockHash}:${nullifier.toString()}`, ()=>source.getNullifierMembershipWitness(referenceBlock, nullifier)),
+        getLowNullifierMembershipWitness: (referenceBlock, nullifier)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`low-nullifier-membership-witness:${blockHash}:${nullifier.toString()}`, ()=>source.getLowNullifierMembershipWitness(referenceBlock, nullifier)),
+        getL1ToL2MessageMembershipWitness: (referenceBlock, l1ToL2Message)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`l1-to-l2-message-membership-witness:${blockHash}:${l1ToL2Message.toString()}`, ()=>source.getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message)),
+        getPublicStorageAt: (referenceBlock, contractAddress, storageSlot)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`public-storage:${blockHash}:${contractAddress.toString()}:${storageSlot.toString()}`, ()=>source.getPublicStorageAt(referenceBlock, contractAddress, storageSlot)),
+        findLeavesIndexes: (referenceBlock, treeId, leafValues)=>{
+            // Cached per leaf: only leaves without a cached result are fetched, in a single batched node call. The per-leaf
+            // keys don't fit single-key readCachedIfBlockIsHashPinned, so the hash gate is inline.
+            const referenceHash = hashReferenceOf(referenceBlock);
+            if (referenceHash === undefined) {
+                return source.findLeavesIndexes(referenceBlock, treeId, leafValues);
+            }
+            return readBatchedPerKey(cache, leafValues.map((leaf)=>`leaf-index:${referenceHash.toString()}:${treeId}:${leaf.toString()}`), (missing)=>source.findLeavesIndexes(referenceBlock, treeId, missing.map((i)=>leafValues[i])), {
+                method: 'findLeavesIndexes',
+                requested: 'leaves'
+            });
+        },
+        getPrivateLogsByTags: (query)=>{
+            if (!hasImmutableAnswer(query)) {
+                return source.getPrivateLogsByTags(query);
+            }
+            const keyPrefix = `private-logs:${privateLogsQueryKey(query)}`;
+            return readBatchedPerKey(cache, query.tags.map((tag)=>`${keyPrefix}:${tagQueryKey(tag)}`), (missing)=>source.getPrivateLogsByTags({
+                    ...query,
+                    tags: missing.map((i)=>query.tags[i])
+                }), {
+                method: 'getPrivateLogsByTags',
+                requested: 'tags'
+            });
+        },
+        getPublicLogsByTags: (query)=>{
+            if (!hasImmutableAnswer(query)) {
+                return source.getPublicLogsByTags(query);
+            }
+            const keyPrefix = `public-logs:${publicLogsQueryKey(query)}`;
+            return readBatchedPerKey(cache, query.tags.map((tag)=>`${keyPrefix}:${tagQueryKey(tag)}`), (missing)=>source.getPublicLogsByTags({
+                    ...query,
+                    tags: missing.map((i)=>query.tags[i])
+                }), {
+                method: 'getPublicLogsByTags',
+                requested: 'tags'
+            });
+        }
+    };
+    return new Proxy(source, {
+        get (target, prop) {
+            if (prop === 'wipeCache') {
+                return ()=>cache.wipe();
+            }
+            if (Object.hasOwn(cachedReads, prop)) {
+                return cachedReads[prop];
+            }
+            const value = Reflect.get(target, prop);
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+}
+/**
+ * Store of node read promises keyed by method and arguments.
+ *
+ * Holds no node reference of its own: it only memoizes promises handed to it by the {@link withCache} wrapper that
+ * owns it. Rejected promises are evicted so callers can retry. A settled value is kept unless the caller's
+ * `shouldCache` turns it away.
+ */ class AztecNodeCache {
+    cache = new Map();
+    /**
+   * Returns the cached promise for `key`, or runs `read` and caches the in-flight promise.
+   *
+   * `shouldCache` runs once the promise settles and answers whether its value is kept. Every settled value is kept by
+   * default. Callers waiting on a value that is then turned away still share the one in-flight read, so declining to
+   * keep a value costs nothing on concurrent reads.
+   */ fetch(key, read, { shouldCache } = {}) {
+        return this.#get(key) ?? this.#set(key, read(), shouldCache);
+    }
+    /**
+   * The cached promise for each of `keys`, `undefined` where there is none. For callers that batch their own misses
+   * rather than reading one key.
+   */ peekAll(keys) {
+        return keys.map((key)=>this.#get(key));
+    }
+    /**
+   * Clears the store.
+   */ wipe() {
+        this.cache.clear();
+    }
+    #get(key) {
+        return this.cache.get(key);
+    }
+    #set(key, promise, shouldCache) {
+        const evict = ()=>{
+            if (this.cache.get(key) === promise) {
+                this.cache.delete(key);
+            }
+        };
+        // A rejected read is evicted so callers can retry; a `shouldCache` that throws is treated the same way. The
+        // trailing catch keeps a throwing predicate from surfacing as an unhandled rejection on this detached promise.
+        promise.then((value)=>{
+            if (shouldCache && !shouldCache(value)) {
+                evict();
+            }
+        }, evict).catch(evict);
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+/**
+ * The block hash `block` pins to (a `BlockHash` or `{ hash }` reference), or `undefined` for every other way of naming
+ * a block.
+ *
+ * A number or a tag names a moving chain position, as does naming no block at all: a reorg can put a different block
+ * at the same number, and tags follow the growing chain. An `{ archive }` root is different, since it commits to every
+ * block hash up to its own block and so pins content as tightly as a hash. It stays uncached because no PXE read uses
+ * one: keeping an `undefined` answer as a non-membership fact is only sound because PXE pins blocks it has already
+ * seen, and that holds for the references PXE actually builds.
+ */ function hashReferenceOf(block) {
+    if (block instanceof BlockHash) {
+        return block;
+    }
+    if (typeof block === 'object' && block !== null && 'hash' in block) {
+        return block.hash;
+    }
+    return undefined;
+}
+/**
+ * Answers one result per entry of `keys`, taking whatever the cache already holds and fetching the rest in a single
+ * batched call. Each fetched result is cached under its own key, so a later call that overlaps this one fetches only
+ * the entries it has not seen, and a key repeated within `keys` is asked of the node once.
+ *
+ * `fetchMissing` receives the indexes still missing, in order, and must answer one result per requested index.
+ * `shortResponse` names the method and what it requests, for the error raised when it does not.
+ */ function readBatchedPerKey(cache, keys, fetchMissing, shortResponse) {
+    const cached = cache.peekAll(keys);
+    // One request per missing key rather than per missing position, so a key repeated in `keys` seeds a single entry
+    // that every position carrying it then reads.
+    const requestIndexByKey = new Map();
+    cached.forEach((result, index)=>{
+        if (result === undefined && !requestIndexByKey.has(keys[index])) {
+            requestIndexByKey.set(keys[index], index);
+        }
+    });
+    const fetchedByKey = new Map();
+    if (requestIndexByKey.size > 0) {
+        const requestedIndexes = [
+            ...requestIndexByKey.values()
+        ];
+        const batch = fetchMissing(requestedIndexes).then((fetched)=>{
+            if (fetched.length !== requestedIndexes.length) {
+                // Each entry is filled from the batch response by position. If the node returned fewer results than we asked
+                // for, the positions past the end would read undefined, which the cache keeps as a genuine answer, so a
+                // truncated response would be cached as fact. Rejecting the whole batch evicts those entries instead, so a
+                // retry re-fetches every one of them.
+                throw new Error(`${shortResponse.method} returned ${fetched.length} results for ${requestedIndexes.length} requested ` + `${shortResponse.requested}`);
+            }
+            return fetched;
+        });
+        [
+            ...requestIndexByKey.keys()
+        ].forEach((key, batchIndex)=>{
+            fetchedByKey.set(key, cache.fetch(key, ()=>batch.then((fetched)=>fetched[batchIndex])));
+        });
+    }
+    // Every position is answered: a cache hit, or the entry its key's request seeded just above.
+    return Promise.all(keys.map((key, index)=>cached[index] ?? fetchedByKey.get(key)));
+}
+/**
+ * Whether a tag query's answer can no longer change, and so can be cached.
+ *
+ * Two things would let it change, and the query has to rule out both. `referenceBlock` names the chain the answer
+ * belongs to, so the call fails once that block is gone rather than answering from a chain that reorged. `toBlock`
+ * stops the query below the tip, so blocks yet to be produced cannot add logs to the answer. Where the query starts
+ * does not matter: an open lower end reaches only blocks that are already behind it, which no longer move. PXE's tag
+ * queries get both from the `getAll*LogsByTags` helpers, which take them from the anchor block the query is pinned to.
+ */ function hasImmutableAnswer(query) {
+    return query.referenceBlock !== undefined && query.toBlock !== undefined;
+}
+/** Cache-key segment for the parts of a private tag query that every tag in it shares. */ function privateLogsQueryKey(query) {
+    const parts = {
+        ...sharedQueryKeyParts(query)
+    };
+    return Object.values(parts).map(keyPart).join(':');
+}
+/** Cache-key segment for the parts of a public tag query that every tag in it shares. */ function publicLogsQueryKey(query) {
+    const parts = {
+        ...sharedQueryKeyParts(query),
+        contractAddress: query.contractAddress
+    };
+    return Object.values(parts).map(keyPart).join(':');
+}
+/** The key parts {@link PrivateLogsQuery} and {@link PublicLogsQuery} have in common. */ function sharedQueryKeyParts(query) {
+    return {
+        referenceBlock: query.referenceBlock,
+        fromBlock: query.fromBlock,
+        toBlock: query.toBlock,
+        txHash: query.txHash,
+        includeEffects: query.includeEffects,
+        limitPerTag: query.limitPerTag
+    };
+}
+/**
+ * Cache-key segment for one tag entry, covering the pagination cursor as well as the tag: each page of a tag's stream
+ * is a read of its own, and a repeated query asks for the same pages in the same order.
+ */ function tagQueryKey(entry) {
+    return 'tag' in entry ? `${keyPart(entry.tag)}@${keyPart(entry.afterLog)}` : keyPart(entry);
+}
+/**
+ * Renders a call argument as a stable cache-key segment, via its own `toString` when it has one, else as JSON.
+ *
+ * Example: the options object `{ includeTransactions: true }` renders as `'{"includeTransactions":true}'`, and an
+ * absent optional argument as `'undefined'`.
+ */ function keyPart(value) {
+    if ([
+        'string',
+        'number',
+        'bigint',
+        'boolean'
+    ].includes(typeof value)) {
+        return String(value);
+    }
+    if (value && typeof value === 'object') {
+        const toString = value.toString;
+        if (toString && toString !== Object.prototype.toString) {
+            return toString.call(value);
+        }
+        return JSON.stringify(value, (_key, nested)=>typeof nested === 'bigint' ? nested.toString() : nested);
+    }
+    return String(value);
+}