@aztec/pxe 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/logs/log_service.js

@@ -1,118 +1,206 @@
+import { PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { ExtendedDirectionalAppTaggingSecret, PendingTaggedLog, SiloedTag } from '@aztec/stdlib/logs';
-import { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
-import { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, loadPrivateLogsForSenderRecipientPair } from '../tagging/index.js';
+import { AppTaggingSecret, SiloedTag, computeSharedTaggingSecret } from '@aztec/stdlib/logs';
+import { LogSource } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
+import { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, syncTaggedPrivateLogs } from '../tagging/index.js';
+const rangeKey = (fromBlock, toBlock)=>`${fromBlock ?? ''}-${toBlock ?? ''}`;
 export class LogService {
     aztecNode;
     anchorBlockHeader;
+    l2TipsStore;
     keyStore;
-    capsuleStore;
     recipientTaggingStore;
-    senderAddressBookStore;
+    taggingSecretSourcesStore;
     addressStore;
     jobId;
     log;
-    constructor(aztecNode, anchorBlockHeader, keyStore, capsuleStore, recipientTaggingStore, senderAddressBookStore, addressStore, jobId, bindings){
+    constructor(aztecNode, anchorBlockHeader, l2TipsStore, keyStore, recipientTaggingStore, taggingSecretSourcesStore, addressStore, jobId, bindings){
         this.aztecNode = aztecNode;
         this.anchorBlockHeader = anchorBlockHeader;
+        this.l2TipsStore = l2TipsStore;
         this.keyStore = keyStore;
-        this.capsuleStore = capsuleStore;
         this.recipientTaggingStore = recipientTaggingStore;
-        this.senderAddressBookStore = senderAddressBookStore;
+        this.taggingSecretSourcesStore = taggingSecretSourcesStore;
         this.addressStore = addressStore;
         this.jobId = jobId;
         this.log = createLogger('pxe:log_service', bindings);
     }
-    async bulkRetrieveLogs(logRetrievalRequests) {
-        return await Promise.all(logRetrievalRequests.map(async (request)=>{
-            const [publicLog, privateLog] = await Promise.all([
-                this.#getPublicLogByTag(request.tag, request.contractAddress),
-                this.#getPrivateLogByTag(await SiloedTag.computeFromTagAndApp(request.tag, request.contractAddress))
-            ]);
-            if (publicLog !== null && privateLog !== null) {
-                throw new Error(`Found both a public and private log when searching for tag ${request.tag} from contract ${request.contractAddress}`);
+    /** Fetches all logs matching each request's tag, returning an array of log arrays (one per request). */ async fetchLogsByTag(contractAddress, logRetrievalRequests) {
+        for (const request of logRetrievalRequests){
+            if (!contractAddress.equals(request.contractAddress)) {
+                throw new Error(`Got a log retrieval request from ${request.contractAddress}, expected ${contractAddress}`);
             }
-            return publicLog ?? privateLog;
+        }
+        if (logRetrievalRequests.length === 0) {
+            return [];
+        }
+        const anchorBlockHash = await this.anchorBlockHeader.hash();
+        const [publicLogsPerRequest, privateLogsPerRequest] = await Promise.all([
+            this.#fetchPublicLogs(contractAddress, logRetrievalRequests, anchorBlockHash),
+            this.#fetchPrivateLogs(logRetrievalRequests, anchorBlockHash)
+        ]);
+        return logRetrievalRequests.map((_request, i)=>[
+                ...publicLogsPerRequest[i].map(LogService.#toLogRetrievalResponse),
+                ...privateLogsPerRequest[i].map(LogService.#toLogRetrievalResponse)
+            ]);
+    }
+    async #fetchPublicLogs(contractAddress, requests, anchorBlockHash) {
+        const indices = requests.flatMap((r, i)=>r.source !== LogSource.PRIVATE ? [
+                i
+            ] : []);
+        if (indices.length === 0) {
+            return requests.map(()=>[]);
+        }
+        const resultsPerRequest = requests.map(()=>[]);
+        const groups = LogService.#groupByRange(indices.map((i)=>({
+                index: i,
+                request: requests[i]
+            })));
+        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
+            });
+            group.entries.forEach((entry, i)=>{
+                resultsPerRequest[entry.index] = results[i];
+            });
         }));
+        return resultsPerRequest;
     }
-    async #getPublicLogByTag(tag, contractAddress) {
-        const anchorBlockHash = await this.anchorBlockHeader.hash();
-        const allLogsPerTag = await getAllPublicLogsByTagsFromContract(this.aztecNode, contractAddress, [
-            tag
-        ], anchorBlockHash);
-        const logsForTag = allLogsPerTag[0];
-        if (logsForTag.length === 0) {
-            return null;
-        } else if (logsForTag.length > 1) {
-            // TODO(#11627): handle this case
-            throw new Error(`Got ${logsForTag.length} logs for tag ${tag} and contract ${contractAddress.toString()}. getPublicLogByTag currently only supports a single log per tag`);
+    async #fetchPrivateLogs(requests, anchorBlockHash) {
+        const indices = requests.flatMap((r, i)=>r.source !== LogSource.PUBLIC ? [
+                i
+            ] : []);
+        if (indices.length === 0) {
+            return requests.map(()=>[]);
         }
-        const scopedLog = logsForTag[0];
-        return new LogRetrievalResponse(scopedLog.logData.slice(1), scopedLog.txHash, scopedLog.noteHashes, scopedLog.firstNullifier);
+        const resultsPerRequest = requests.map(()=>[]);
+        const groups = LogService.#groupByRange(indices.map((i)=>({
+                index: i,
+                request: requests[i]
+            })));
+        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, {
+                fromBlock: group.fromBlock,
+                toBlock: group.toBlock,
+                includeEffects: true
+            });
+            group.entries.forEach((entry, i)=>{
+                resultsPerRequest[entry.index] = results[i];
+            });
+        }));
+        return resultsPerRequest;
     }
-    async #getPrivateLogByTag(siloedTag) {
-        const anchorBlockHash = await this.anchorBlockHeader.hash();
-        const allLogsPerTag = await getAllPrivateLogsByTags(this.aztecNode, [
-            siloedTag
-        ], anchorBlockHash);
-        const logsForTag = allLogsPerTag[0];
-        if (logsForTag.length === 0) {
-            return null;
-        } else if (logsForTag.length > 1) {
-            // TODO(#11627): handle this case
-            throw new Error(`Got ${logsForTag.length} logs for tag ${siloedTag}. getPrivateLogByTag currently only supports a single log per tag`);
+    /**
+   * Groups requests by their (fromBlock, toBlock) range so each distinct range becomes a single node call with
+   * the range pushed down into the query (no in-memory filter).
+   */ static #groupByRange(entries) {
+        const groups = new Map();
+        for (const entry of entries){
+            const fromBlock = entry.request.fromBlock.value;
+            const toBlock = entry.request.toBlock.value;
+            const key = rangeKey(fromBlock, toBlock);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.entries.push(entry);
+            } else {
+                groups.set(key, {
+                    fromBlock,
+                    toBlock,
+                    entries: [
+                        entry
+                    ]
+                });
+            }
         }
-        const scopedLog = logsForTag[0];
-        return new LogRetrievalResponse(scopedLog.logData.slice(1), scopedLog.txHash, scopedLog.noteHashes, scopedLog.firstNullifier);
+        return groups;
     }
-    async fetchTaggedLogs(contractAddress, pendingTaggedLogArrayBaseSlot, scopes) {
-        this.log.verbose(`Fetching tagged logs for ${contractAddress.toString()}`);
-        // We only load logs from block up to and including the anchor block number
-        const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
-        const anchorBlockHash = await this.anchorBlockHeader.hash();
-        // Determine recipients: use scopes if provided, otherwise get all accounts
-        const recipients = scopes !== 'ALL_SCOPES' && scopes.length > 0 ? scopes : await this.keyStore.getAccounts();
-        // For each recipient, fetch secrets, load logs, and store them.
-        // We run these per-recipient tasks in parallel so that logs are loaded for all recipients concurrently.
-        await Promise.all(recipients.map(async (recipient)=>{
-            // Get all secrets for this recipient (one per sender)
-            const secrets = await this.#getSecretsForSenders(contractAddress, recipient);
-            // Load logs for all sender-recipient pairs in parallel
-            const logArrays = await Promise.all(secrets.map((secret)=>loadPrivateLogsForSenderRecipientPair(secret, this.aztecNode, this.recipientTaggingStore, anchorBlockNumber, anchorBlockHash, this.jobId)));
-            // Flatten all logs from all secrets
-            const allLogs = logArrays.flat();
-            // Store the logs for this recipient
-            if (allLogs.length > 0) {
-                await this.#storePendingTaggedLogs(contractAddress, pendingTaggedLogArrayBaseSlot, recipient, allLogs);
+    static #toLogRetrievalResponse(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;
+        const nullifiers = log.nullifiers;
+        if (nullifiers.length === 0) {
+            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),
+            txHash: log.txHash,
+            uniqueNoteHashesInTx: noteHashes,
+            firstNullifierInTx: nullifiers[0]
+        };
+    }
+    async fetchTaggedLogs(contractAddress, recipient, providedSecrets) {
+        this.log.verbose(`Fetching tagged logs for contract ${contractAddress.toString()} and recipient ${recipient.toString()}`);
+        const l2Tips = await this.l2TipsStore.getL2Tips();
+        // Secrets PXE can enumerate for this recipient (senders via ECDH + pre-shared store secrets), plus any the app
+        // supplies explicitly for secrets PXE cannot enumerate itself (e.g. handshake-derived ones). The latter arrive
+        // already computed and are searched even when the recipient's account is unknown locally, since they need no ECDH.
+        const combinedSecrets = [
+            ...await this.#getPointDerivedSecrets(contractAddress, recipient),
+            ...providedSecrets
+        ];
+        // These sources can overlap (a sender that is also a PXE account, or a pre-shared secret that coincides with a
+        // sender-derived one), so we deduplicate the combined set.
+        const secrets = Array.from(new Map(combinedSecrets.map((secret)=>[
+                secret.toString(),
+                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]
+                }
+            };
+        });
     }
-    async #getSecretsForSenders(contractAddress, recipient) {
+    /**
+   * Computes the tagging secrets PXE can enumerate for a recipient: one per known sender (via ECDH) plus any
+   * pre-shared secret points registered directly for the recipient, each siloed to `contractAddress` and directed to
+   * `recipient`. These require knowing the recipient's address preimage and keys, so returns an empty array when those
+   * are unavailable. App-supplied secrets (e.g. handshake-derived) are handled separately by the caller and do not go
+   * through here.
+   */ async #getPointDerivedSecrets(contractAddress, recipient) {
         const recipientCompleteAddress = await this.addressStore.getCompleteAddress(recipient);
-        if (!recipientCompleteAddress) {
+        if (!recipientCompleteAddress || !await this.keyStore.hasAccount(recipient)) {
+            this.log.warn(`Skipping sender-derived tag retrieval for ${recipient.toString()} due to unknown address preimage`);
             return [];
         }
         const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
+        const points = [
+            ...await this.#getSecretsForSenders(recipientCompleteAddress, recipientIvsk),
+            ...await this.taggingSecretSourcesStore.getSharedSecretsForRecipient(recipient)
+        ];
+        return Promise.all(points.map((secret)=>AppTaggingSecret.compute(secret, contractAddress, recipient)));
+    }
+    async #getSecretsForSenders(recipientCompleteAddress, recipientIvsk) {
         // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
-        // (recipient = us, sender = us)
+        // (recipient = us, sender = us).
         const allSenders = [
-            ...await this.senderAddressBookStore.getSenders(),
+            ...await this.taggingSecretSourcesStore.getSenders(),
             ...await this.keyStore.getAccounts()
         ];
-        // We deduplicate the senders by adding them to a set and then converting the set back to an array
-        const deduplicatedSenders = Array.from(new Set(allSenders.map((sender)=>sender.toString()))).map((sender)=>AztecAddress.fromString(sender));
-        return Promise.all(deduplicatedSenders.map((sender)=>{
-            return ExtendedDirectionalAppTaggingSecret.compute(recipientCompleteAddress, recipientIvsk, sender, contractAddress, recipient);
+        return Promise.all(allSenders.map(async (sender)=>{
+            const taggingSecretPoint = await computeSharedTaggingSecret(recipientCompleteAddress, recipientIvsk, sender);
+            if (!taggingSecretPoint) {
+                // Note that all senders originate from either the TaggingSecretSourcesStore or the KeyStore.
+                throw new Error(`Failed to compute a tagging secret for sender ${sender} - this implies this is an invalid address, which should not happen as they have been previously registered in PXE.`);
+            }
+            return taggingSecretPoint;
         }));
     }
-    #storePendingTaggedLogs(contractAddress, capsuleArrayBaseSlot, recipient, privateLogs) {
-        // Build all pending tagged logs from the scoped logs
-        const pendingTaggedLogs = privateLogs.map((scopedLog)=>{
-            const pendingTaggedLog = new PendingTaggedLog(scopedLog.logData, scopedLog.txHash, scopedLog.noteHashes, scopedLog.firstNullifier, recipient);
-            return pendingTaggedLog.toFields();
-        });
-        // TODO: This looks like it could belong more at the oracle interface level
-        return this.capsuleStore.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs, this.jobId);
-    }
 }

package/dest/messages/tx_resolver_service.d.ts

@@ -0,0 +1,17 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+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). */
+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.
+     */
+    resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(ResolvedTx | null)[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcmVzb2x2ZXJfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lc3NhZ2VzL3R4X3Jlc29sdmVyX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBR2pFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSw0REFBNEQsQ0FBQztBQUV4RiwrR0FBK0c7QUFDL0cscUJBQWEsaUJBQWlCO0lBQ2hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUF0QyxZQUE2QixTQUFTLEVBQUUsU0FBUyxFQUFJO0lBRXJEOzs7Ozs7T0FNRztJQUNHLFVBQVUsQ0FBQyxRQUFRLEVBQUUsRUFBRSxFQUFFLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLENBaUQxRjtDQUNGIn0=

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

@@ -0,0 +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,EAAE,UAAU,EAAE,MAAM,4DAA4D,CAAC;AAExF,+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"}

package/dest/messages/tx_resolver_service.js

@@ -0,0 +1,55 @@
+import { uniqueBy } from '@aztec/foundation/collection';
+import { 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). */ export class TxResolverService {
+    aztecNode;
+    constructor(aztecNode){
+        this.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.
+   */ async resolveTxs(txHashes, anchorBlockNumber) {
+        const nonZeroTxHashes = txHashes.filter((h)=>!h.isZero()).map((h)=>TxHash.fromField(h));
+        const uniqueTxHashes = uniqueBy(nonZeroTxHashes, (h)=>h.toString());
+        const fetched = await Promise.all(uniqueTxHashes.map((h)=>this.aztecNode.getTxReceipt(h, {
+                includeTxEffect: true
+            })));
+        const txEffects = new Map(uniqueTxHashes.map((h, i)=>{
+            const receipt = fetched[i];
+            if (!receipt.isMined() || !receipt.txEffect) {
+                return [
+                    h.toString(),
+                    undefined
+                ];
+            }
+            return [
+                h.toString(),
+                {
+                    data: receipt.txEffect,
+                    l2BlockNumber: receipt.blockNumber,
+                    l2BlockHash: receipt.blockHash,
+                    txIndexInBlock: receipt.txIndexInBlock,
+                    slotNumber: receipt.slotNumber
+                }
+            ];
+        }).filter((entry)=>entry[1] !== undefined));
+        return txHashes.map((txHashField)=>{
+            const txHash = TxHash.fromField(txHashField);
+            const txEffect = txEffects.get(txHash.toString());
+            if (!txEffect || txEffect.l2BlockNumber > anchorBlockNumber) {
+                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.
+            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());
+        });
+    }
+}

package/dest/notes/note_service.d.ts

@@ -2,10 +2,11 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type AztecNode } from '@aztec/stdlib/interfaces/client';
 import { Note, NoteStatus } from '@aztec/stdlib/note';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
-import type { AccessScopes } from '../access_scopes.js';
+import type { BlockHeader, IndexedTxEffect } from '@aztec/stdlib/tx';
+import type { NoteValidationRequest } from '../contract_function_simulator/noir-structs/note_validation_request.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
 export declare class NoteService {
+    #private;
     private readonly noteStore;
     private readonly aztecNode;
     private readonly anchorBlockHeader;
@@ -20,7 +21,7 @@ export declare class NoteService {
      * @param status - The status of notes to fetch.
      * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
      */
-    getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr, status: NoteStatus, scopes: AccessScopes): Promise<{
+    getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr, status: NoteStatus, scopes: AztecAddress[]): Promise<{
         contractAddress: AztecAddress;
         owner: AztecAddress;
         storageSlot: Fr;
@@ -43,7 +44,27 @@ export declare class NoteService {
      *
      * @param contractAddress - The contract whose notes should be checked and nullified.
      */
-    syncNoteNullifiers(contractAddress: AztecAddress, scopes: AccessScopes): Promise<void>;
-    validateAndStoreNote(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr, randomness: Fr, noteNonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: TxHash, recipient: AztecAddress): Promise<void>;
+    syncNoteNullifiers(contractAddress: AztecAddress, scopes: AztecAddress[]): Promise<void>;
+    /**
+     * Validates and stores a batch of notes against pre-fetched tx effects.
+     *
+     * For each request we must verify that:
+     *  - the note actually exists in the corresponding tx effect (and thus in the note hash tree), and
+     *  - the note has not already been nullified.
+     *
+     * Failing to do either would result in circuits getting either non-existent notes and failing to produce inclusion
+     * proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which are catastrophic
+     * failure modes.
+     *
+     * Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
+     * emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
+     * so we must store both the note hash and nullifier block information.
+     *
+     * @param requests - The notes to validate and store.
+     * @param scope - The scope under which the notes 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.
+     */
+    validateAndStoreNotes(requests: NoteValidationRequest[], scope: AztecAddress, txEffects: Map<string, IndexedTxEffect>): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUdoRSxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsSUFBSSxFQUFXLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU1RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUVyRSxxQkFBYSxXQUFXO0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBSnhCLFlBQ21CLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDNUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FDbkIsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQy9CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxFQUFFLFlBQVk7Ozs7Ozs7Ozs7U0F5QnJCO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDVSxrQkFBa0IsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNDbEc7SUFFWSxvQkFBb0IsQ0FDL0IsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksRUFDbkIsV0FBVyxFQUFFLEVBQUUsRUFDZixVQUFVLEVBQUUsRUFBRSxFQUNkLFNBQVMsRUFBRSxFQUFFLEVBQ2IsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUNiLFFBQVEsRUFBRSxFQUFFLEVBQ1osU0FBUyxFQUFFLEVBQUUsRUFDYixNQUFNLEVBQUUsTUFBTSxFQUNkLFNBQVMsRUFBRSxZQUFZLEdBQ3RCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FzRWY7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUdoRSxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsSUFBSSxFQUFXLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVyRSxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdFQUF3RSxDQUFDO0FBQ3BILE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXJFLHFCQUFhLFdBQVc7O0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBSnhCLFlBQ21CLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDNUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FDbkIsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQy9CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxFQUFFLFlBQVksRUFBRTs7Ozs7Ozs7OztTQXlCdkI7SUFFRDs7Ozs7Ozs7Ozs7T0FXRztJQUNVLGtCQUFrQixDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxQnBHO0lBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FtQkc7SUFDVSxxQkFBcUIsQ0FDaEMsUUFBUSxFQUFFLHFCQUFxQixFQUFFLEVBQ2pDLEtBQUssRUFBRSxZQUFZLEVBQ25CLFNBQVMsRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLGVBQWUsQ0FBQyxHQUN0QyxPQUFPLENBQUMsSUFBSSxDQUFDLENBa0dmO0NBVUYifQ==

package/dest/notes/note_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"note_service.d.ts","sourceRoot":"","sources":["../../src/notes/note_service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,YACmB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EAC5B;IAEJ;;;;;;;;OAQG;IACU,QAAQ,CACnB,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,YAAY;;;;;;;;;;SAyBrB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsClG;IAEY,oBAAoB,CAC/B,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,EAAE,EACf,UAAU,EAAE,EAAE,EACd,SAAS,EAAE,EAAE,EACb,OAAO,EAAE,EAAE,EAAE,EACb,QAAQ,EAAE,EAAE,EACZ,SAAS,EAAE,EAAE,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,IAAI,CAAC,CAsEf;CACF"}
+{"version":3,"file":"note_service.d.ts","sourceRoot":"","sources":["../../src/notes/note_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wEAAwE,CAAC;AACpH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,qBAAa,WAAW;;IAEpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,YACmB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EAC5B;IAEJ;;;;;;;;OAQG;IACU,QAAQ,CACnB,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,YAAY,EAAE;;;;;;;;;;SAyBvB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBpG;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACU,qBAAqB,CAChC,QAAQ,EAAE,qBAAqB,EAAE,EACjC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC,CAkGf;CAUF"}

package/dest/notes/note_service.js

@@ -1,3 +1,4 @@
+import { chunk } from '@aztec/foundation/collection';
 import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
 import { Note, NoteDao } from '@aztec/stdlib/note';
@@ -62,19 +63,7 @@ export class NoteService {
             return;
         }
         const nullifiersToCheck = contractNotes.map((note)=>note.siloedNullifier);
-        const nullifierBatches = nullifiersToCheck.reduce((acc, nullifier)=>{
-            if (acc[acc.length - 1].length < MAX_RPC_LEN) {
-                acc[acc.length - 1].push(nullifier);
-            } else {
-                acc.push([
-                    nullifier
-                ]);
-            }
-            return acc;
-        }, [
-            []
-        ]);
-        const nullifierIndexes = (await Promise.all(nullifierBatches.map((batch)=>this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, batch)))).flat();
+        const nullifierIndexes = await this.#findNullifierIndexes(anchorBlockHash, nullifiersToCheck);
         const foundNullifiers = nullifiersToCheck.map((nullifier, i)=>{
             if (nullifierIndexes[i] !== undefined) {
                 return {
@@ -87,19 +76,29 @@ export class NoteService {
         }).filter((nullifier)=>nullifier !== undefined);
         await this.noteStore.applyNullifiers(foundNullifiers, this.jobId);
     }
-    async validateAndStoreNote(contractAddress, owner, storageSlot, randomness, noteNonce, content, noteHash, nullifier, txHash, recipient) {
-        // We are going to store the new note in the NoteStore, which will let us later return it via `getNotes`.
-        // There's two things we need to check before we do this however:
-        //  - we must make sure the note does actually exist in the note hash tree
-        //  - we need to check if the note has already been nullified
-        //
-        // Failing to do either of the above would result in circuits getting either non-existent notes and failing to
-        // produce inclusion proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which
-        // are catastrophic failure modes.
-        //
-        // Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
-        // emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
-        // so we must store both the note hash and nullifier block information.
+    /**
+   * Validates and stores a batch of notes against pre-fetched tx effects.
+   *
+   * For each request we must verify that:
+   *  - the note actually exists in the corresponding tx effect (and thus in the note hash tree), and
+   *  - the note has not already been nullified.
+   *
+   * Failing to do either would result in circuits getting either non-existent notes and failing to produce inclusion
+   * proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which are catastrophic
+   * failure modes.
+   *
+   * Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
+   * emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
+   * so we must store both the note hash and nullifier block information.
+   *
+   * @param requests - The notes to validate and store.
+   * @param scope - The scope under which the notes 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.
+   */ async validateAndStoreNotes(requests, scope, txEffects) {
+        if (requests.length === 0) {
+            return;
+        }
         // We avoid making node queries at 'latest' since we don't want to process notes or nullifiers that only exist ahead
         // in time of the locally synced state.
         // Note that while this technically results in historical queries, we perform it at the latest locally synced block
@@ -110,39 +109,64 @@ export class NoteService {
         const anchorBlockHash = await this.anchorBlockHeader.hash();
         // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
         // of other contracts, which would constitute a security breach.
-        const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, await siloNoteHash(contractAddress, noteHash));
-        const siloedNullifier = await siloNullifier(contractAddress, nullifier);
-        const [txEffect, [nullifierIndex]] = await Promise.all([
-            this.aztecNode.getTxEffect(txHash),
-            this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, [
+        const computed = await Promise.all(requests.map(async ({ contractAddress, noteHash, nullifier, noteNonce })=>{
+            const [siloedNoteHash, siloedNullifier] = await Promise.all([
+                siloNoteHash(contractAddress, noteHash),
+                siloNullifier(contractAddress, nullifier)
+            ]);
+            const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, siloedNoteHash);
+            return {
+                uniqueNoteHash,
                 siloedNullifier
-            ])
-        ]);
-        if (!txEffect) {
-            throw new Error(`Could not find tx effect for tx hash ${txHash}`);
-        }
-        if (txEffect.l2BlockNumber > anchorBlockNumber) {
-            throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${anchorBlockNumber}`);
-        }
-        // Find the index of the note hash in the noteHashes array to determine note ordering within the tx
-        const noteIndexInTx = txEffect.data.noteHashes.findIndex((nh)=>nh.equals(uniqueNoteHash));
-        if (noteIndexInTx === -1) {
-            throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
-        }
-        const noteDao = new NoteDao(new Note(content), contractAddress, owner, storageSlot, randomness, noteNonce, noteHash, siloedNullifier, txHash, txEffect.l2BlockNumber, txEffect.l2BlockHash.toString(), txEffect.txIndexInBlock, noteIndexInTx);
-        // The note was found by `recipient`, so we use that as the scope when storing the note.
-        await this.noteStore.addNotes([
-            noteDao
-        ], recipient, this.jobId);
-        if (nullifierIndex !== undefined) {
-            // We found nullifier index which implies that the note has already been nullified.
-            const { data: _, ...blockHashAndNum } = nullifierIndex;
-            await this.noteStore.applyNullifiers([
-                {
+            };
+        }));
+        const nullifierIndexes = await this.#findNullifierIndexes(anchorBlockHash, computed.map((c)=>c.siloedNullifier));
+        const noteDaos = [];
+        const foundNullifiers = [];
+        for(let i = 0; i < requests.length; i++){
+            const { contractAddress, owner, storageSlot, randomness, noteNonce, content, noteHash, txHash } = requests[i];
+            const { uniqueNoteHash, siloedNullifier } = computed[i];
+            const nullifierIndex = nullifierIndexes[i];
+            const txEffect = txEffects.get(txHash.toString());
+            if (!txEffect) {
+                // We error out instead of just logging a warning and skipping the note 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 a note.`);
+            }
+            if (txEffect.l2BlockNumber > anchorBlockNumber) {
+                // If the message was delivered onchain, this would indicate a bug: log sync should never load logs from blocks
+                // newer than the anchor block. If the note came via an offchain message, it would likely also be a bug, since
+                // we sync a new anchor block before calling `process_message`. For this not to be a bug, the message would
+                // need to come from a newer block than the anchor served by the node, implying the node isn't properly synced.
+                //     We therefore error out here rather than assuming the offchain message was constructed by a malicious
+                // sender with the intention of bricking recipient's PXE (if we assumed that we would just ignore the message).
+                throw new Error(`Obtained a newer tx effect for ${txHash} for a note validation request than the anchor block ${anchorBlockNumber}. This is a bug as we should not ever be processing a note from a newer block than the anchor block.`);
+            }
+            // Find the index of the note hash in the noteHashes array to determine note ordering within the tx
+            const noteIndexInTx = txEffect.data.noteHashes.findIndex((nh)=>nh.equals(uniqueNoteHash));
+            if (noteIndexInTx === -1) {
+                // Similar to the comment above - we error out as this would indicate a bug in nonce discovery.
+                throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
+            }
+            noteDaos.push(new NoteDao(new Note(content), contractAddress, owner, storageSlot, randomness, noteNonce, noteHash, siloedNullifier, txHash, txEffect.l2BlockNumber, txEffect.l2BlockHash.toString(), txEffect.txIndexInBlock, noteIndexInTx));
+            if (nullifierIndex !== undefined) {
+                // We found a nullifier index which implies that the note has already been nullified.
+                const { data: _, ...blockHashAndNum } = nullifierIndex;
+                foundNullifiers.push({
                     data: siloedNullifier,
                     ...blockHashAndNum
-                }
-            ], this.jobId);
+                });
+            }
         }
+        await this.noteStore.addNotes(noteDaos, scope, this.jobId);
+        if (foundNullifiers.length > 0) {
+            await this.noteStore.applyNullifiers(foundNullifiers, this.jobId);
+        }
+    }
+    async #findNullifierIndexes(anchorBlockHash, siloedNullifiers) {
+        const batches = chunk(siloedNullifiers, MAX_RPC_LEN);
+        return (await Promise.all(batches.map((batch)=>this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, batch)))).flat();
     }
 }