@aztec/pxe 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/dest/contract_function_simulator/pxe_oracle_interface.js

@@ -1,22 +1,20 @@
 import { timesParallel } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { getFunctionArtifact } from '@aztec/stdlib/abi';
 import { computeUniqueNoteHash, siloNoteHash, siloNullifier, siloPrivateLog } from '@aztec/stdlib/hash';
 import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
-import { computeAddressSecret, computeAppTaggingSecret } from '@aztec/stdlib/keys';
-import { IndexedTaggingSecret, PendingTaggedLog, PrivateLogWithTxData, PublicLogWithTxData, deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
+import { computeAddressSecret } from '@aztec/stdlib/keys';
+import { PendingTaggedLog, PrivateLogWithTxData, PublicLogWithTxData, deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { Note } from '@aztec/stdlib/note';
+import { NoteDao } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { MessageLoadOracleInputs } from '../contract_function_simulator/oracle/message_load_oracle_inputs.js';
 import { ORACLE_VERSION } from '../oracle_version.js';
-import { NoteDao } from '../storage/note_data_provider/note_dao.js';
+import { DirectionalAppTaggingSecret, SiloedTag, Tag, WINDOW_HALF_SIZE, getInitialIndexesMap, getPreTagsForTheWindow } from '../tagging/index.js';
 import { EventValidationRequest } from './noir-structs/event_validation_request.js';
 import { LogRetrievalRequest } from './noir-structs/log_retrieval_request.js';
 import { LogRetrievalResponse } from './noir-structs/log_retrieval_response.js';
 import { NoteValidationRequest } from './noir-structs/note_validation_request.js';
-import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 /**
  * A data layer that provides and stores information needed for simulating/proving a transaction.
  */ export class PXEOracleInterface {
@@ -49,7 +47,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         const completeAddress = await this.addressDataProvider.getCompleteAddress(account);
         if (!completeAddress) {
             throw new Error(`No public key registered for address ${account}.
-        Register it by calling pxe.addAccount(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`);
+        Register it by calling pxe.addAccount(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`);
         }
         return completeAddress;
     }
@@ -60,16 +58,19 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         }
         return instance;
     }
-    async getNotes(contractAddress, storageSlot, status, scopes) {
+    async getNotes(contractAddress, owner, storageSlot, status, scopes) {
         const noteDaos = await this.noteDataProvider.getNotes({
             contractAddress,
+            owner,
             storageSlot,
             status,
             scopes
         });
-        return noteDaos.map(({ contractAddress, storageSlot, noteNonce, note, noteHash, siloedNullifier, index })=>({
+        return noteDaos.map(({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index })=>({
                 contractAddress,
+                owner,
                 storageSlot,
+                randomness,
                 noteNonce,
                 note,
                 noteHash,
@@ -89,14 +90,6 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
             debug
         };
     }
-    async getFunctionArtifactByName(contractAddress, functionName) {
-        const instance = await this.contractDataProvider.getContractInstance(contractAddress);
-        if (!instance) {
-            return;
-        }
-        const artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
-        return artifact && getFunctionArtifact(artifact, functionName);
-    }
     /**
    * Fetches a message from the db, given its key.
    * @param contractAddress - Address of a contract by which the message was emitted.
@@ -140,30 +133,41 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         }
     }
     async getNullifierMembershipWitnessAtLatestBlock(nullifier) {
-        return this.getNullifierMembershipWitness(await this.getBlockNumber(), nullifier);
+        const blockNumber = (await this.getAnchorBlockHeader()).globalVariables.blockNumber;
+        return this.getNullifierMembershipWitness(blockNumber, nullifier);
     }
     getNullifierMembershipWitness(blockNumber, nullifier) {
         return this.aztecNode.getNullifierMembershipWitness(blockNumber, nullifier);
     }
-    getLowNullifierMembershipWitness(blockNumber, nullifier) {
+    async getLowNullifierMembershipWitness(blockNumber, nullifier) {
+        const header = await this.getAnchorBlockHeader();
+        if (blockNumber !== 'latest' && blockNumber > header.globalVariables.blockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${header.globalVariables.blockNumber}`);
+        }
         return this.aztecNode.getLowNullifierMembershipWitness(blockNumber, nullifier);
     }
     async getBlock(blockNumber) {
+        const header = await this.getAnchorBlockHeader();
+        if (blockNumber !== 'latest' && blockNumber > header.globalVariables.blockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${header.globalVariables.blockNumber}`);
+        }
         return await this.aztecNode.getBlock(blockNumber);
     }
     async getPublicDataWitness(blockNumber, leafSlot) {
+        const header = await this.getAnchorBlockHeader();
+        if (blockNumber !== 'latest' && blockNumber > header.globalVariables.blockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${header.globalVariables.blockNumber}`);
+        }
         return await this.aztecNode.getPublicDataWitness(blockNumber, leafSlot);
     }
     async getPublicStorageAt(blockNumber, contract, slot) {
+        const header = await this.getAnchorBlockHeader();
+        if (blockNumber !== 'latest' && blockNumber > header.globalVariables.blockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${header.globalVariables.blockNumber}`);
+        }
         return await this.aztecNode.getPublicStorageAt(blockNumber, contract, slot);
     }
-    /**
-   * Retrieve the latest block header synchronized by the PXE.
-   * @dev This structure is fed into the circuits simulator and is used to prove against certain historical roots.
-   * @returns The BlockHeader object.
-   * TODO: I think this naming is bad as it's not the latest block header synched by the node, but the latest block
-   * header synchronized by the PXE. Would rename this to something like getSynchronizedBlockHeader().
-   */ getBlockHeader() {
+    getAnchorBlockHeader() {
         return this.syncDataProvider.getBlockHeader();
     }
     assertCompatibleOracleVersion(version) {
@@ -171,34 +175,6 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
             throw new Error(`Incompatible oracle version. Expected version ${ORACLE_VERSION}, got ${version}.`);
         }
     }
-    /**
-   * Fetches the latest block number synchronized by the node.
-   * @returns The block number.
-   */ async getBlockNumber() {
-        return await this.aztecNode.getBlockNumber();
-    }
-    /**
-   * Fetches the timestamp of the latest block synchronized by the node.
-   * @returns The timestamp.
-   */ async getTimestamp() {
-        const latestBlockHeader = await this.aztecNode.getBlockHeader();
-        if (!latestBlockHeader) {
-            throw new Error('Latest block header not found when getting timestamp');
-        }
-        return latestBlockHeader.globalVariables.timestamp;
-    }
-    /**
-   * Fetches the current chain id.
-   * @returns The chain id.
-   */ async getChainId() {
-        return await this.aztecNode.getChainId();
-    }
-    /**
-   * Fetches the current version.
-   * @returns The version.
-   */ async getVersion() {
-        return await this.aztecNode.getVersion();
-    }
     getDebugFunctionName(contractAddress, selector) {
         return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
     }
@@ -210,57 +186,27 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
    */ getSenders() {
         return this.taggingDataProvider.getSenderAddresses();
     }
-    /**
-   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
-   * Includes the next index to be used used for tagging with this secret.
-   * @param contractAddress - The contract address to silo the secret for
-   * @param sender - The address sending the note
-   * @param recipient - The address receiving the note
-   * @returns An indexed tagging secret that can be used to tag notes.
-   */ async getIndexedTaggingSecretAsSender(contractAddress, sender, recipient) {
-        await this.syncTaggedLogsAsSender(contractAddress, sender, recipient);
-        const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-        const [index] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([
-            appTaggingSecret
-        ], sender);
-        return new IndexedTaggingSecret(appTaggingSecret, index);
+    getLastUsedIndexAsSender(secret) {
+        return this.taggingDataProvider.getLastUsedIndexesAsSender(secret);
     }
-    /**
-   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
-   * @param contractAddress - The contract address to silo the secret for
-   * @param sender - The address sending the note
-   * @param recipient - The address receiving the note
-   */ async incrementAppTaggingSecretIndexAsSender(contractAddress, sender, recipient) {
-        const secret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-        const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
-        this.log.debug(`Incrementing app tagging secret at ${contractName}(${contractAddress})`, {
-            secret,
-            sender,
-            recipient,
-            contractName,
-            contractAddress
-        });
-        const [index] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([
-            secret
-        ], sender);
-        await this.taggingDataProvider.setTaggingSecretsIndexesAsSender([
-            new IndexedTaggingSecret(secret, index + 1)
-        ], sender);
-    }
-    async #calculateAppTaggingSecret(contractAddress, sender, recipient) {
+    async calculateDirectionalAppTaggingSecret(contractAddress, sender, recipient) {
         const senderCompleteAddress = await this.getCompleteAddress(sender);
         const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-        return computeAppTaggingSecret(senderCompleteAddress, senderIvsk, recipient, contractAddress);
+        return DirectionalAppTaggingSecret.compute(senderCompleteAddress, senderIvsk, recipient, contractAddress, recipient);
     }
     /**
-   * Returns the indexed tagging secrets for a given recipient and all the senders in the address book
+   * Returns the last used tagging indexes along with the directional app tagging secrets for a given recipient and all
+   * the senders in the address book.
    * This method should be exposed as an oracle call to allow aztec.nr to perform the orchestration
    * of the syncTaggedLogs and processTaggedLogs methods. However, it is not possible to do so at the moment,
    * so we're keeping it private for now.
    * @param contractAddress - The contract address to silo the secret for
    * @param recipient - The address receiving the notes
-   * @returns A list of indexed tagging secrets
-   */ async #getIndexedTaggingSecretsForSenders(contractAddress, recipient) {
+   * @returns A list of directional app tagging secrets along with the last used tagging indexes. If the corresponding
+   * secret was never used, the index is undefined.
+   * TODO(benesjan): The naming here is broken as the function name does not reflect the return type. Fix when associating
+   * indexes with tx hash.
+   */ async #getLastUsedTaggingIndexesForSenders(contractAddress, recipient) {
         const recipientCompleteAddress = await this.getCompleteAddress(recipient);
         const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
         // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
@@ -269,21 +215,23 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
             ...await this.taggingDataProvider.getSenderAddresses(),
             ...await this.keyStore.getAccounts()
         ].filter((address, index, self)=>index === self.findIndex((otherAddress)=>otherAddress.equals(address)));
-        const appTaggingSecrets = await Promise.all(senders.map((contact)=>computeAppTaggingSecret(recipientCompleteAddress, recipientIvsk, contact, contractAddress)));
-        const indexes = await this.taggingDataProvider.getTaggingSecretsIndexesAsRecipient(appTaggingSecrets, recipient);
-        return appTaggingSecrets.map((secret, i)=>new IndexedTaggingSecret(secret, indexes[i]));
+        const secrets = await Promise.all(senders.map((contact)=>{
+            return DirectionalAppTaggingSecret.compute(recipientCompleteAddress, recipientIvsk, contact, contractAddress, recipient);
+        }));
+        const indexes = await this.taggingDataProvider.getLastUsedIndexesAsRecipient(secrets);
+        if (indexes.length !== secrets.length) {
+            throw new Error('Indexes and directional app tagging secrets have different lengths');
+        }
+        return secrets.map((secret, i)=>({
+                secret,
+                index: indexes[i]
+            }));
     }
-    /**
-   * Updates the local index of the shared tagging secret of a sender / recipient pair
-   * if a log with a larger index is found from the node.
-   * @param contractAddress - The address of the contract that the logs are tagged for
-   * @param sender - The address of the sender, we must know the sender's ivsk_m.
-   * @param recipient - The address of the recipient.
-   */ async syncTaggedLogsAsSender(contractAddress, sender, recipient) {
-        const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-        const [oldIndex] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([
-            appTaggingSecret
-        ], sender);
+    async syncTaggedLogsAsSender(secret, contractAddress) {
+        const lastUsedIndex = await this.taggingDataProvider.getLastUsedIndexesAsSender(secret);
+        // If lastUsedIndex is undefined, we've never used this secret, so start from 0
+        // Otherwise, start from one past the last used index
+        const startIndex = lastUsedIndex === undefined ? 0 : lastUsedIndex + 1;
         // This algorithm works such that:
         // 1. If we find minimum consecutive empty logs in a window of logs we set the index to the index of the last log
         // we found and quit.
@@ -293,40 +241,50 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         const WINDOW_SIZE = MIN_CONSECUTIVE_EMPTY_LOGS * 2;
         let [numConsecutiveEmptyLogs, currentIndex] = [
             0,
-            oldIndex
+            startIndex
         ];
+        let lastFoundLogIndex = undefined;
         do {
             // We compute the tags for the current window of indexes
-            const currentTags = await timesParallel(WINDOW_SIZE, (i)=>{
-                const indexedAppTaggingSecret = new IndexedTaggingSecret(appTaggingSecret, currentIndex + i);
-                return indexedAppTaggingSecret.computeSiloedTag(recipient, contractAddress);
+            const currentTags = await timesParallel(WINDOW_SIZE, async (i)=>{
+                return SiloedTag.compute(await Tag.compute({
+                    secret,
+                    index: currentIndex + i
+                }), contractAddress);
             });
             // We fetch the logs for the tags
-            const possibleLogs = await this.#getPrivateLogsByTags(currentTags);
+            // TODO: The following conversion is unfortunate and we should most likely just type the #getPrivateLogsByTags
+            // to accept SiloedTag[] instead of Fr[]. That would result in a large change so I didn't do it yet.
+            const tagsAsFr = currentTags.map((tag)=>tag.value);
+            const possibleLogs = await this.#getPrivateLogsByTags(tagsAsFr);
             // We find the index of the last log in the window that is not empty
-            const indexOfLastLog = possibleLogs.findLastIndex((possibleLog)=>possibleLog.length !== 0);
-            if (indexOfLastLog === -1) {
+            const indexOfLastLogWithinArray = possibleLogs.findLastIndex((possibleLog)=>possibleLog.length !== 0);
+            if (indexOfLastLogWithinArray === -1) {
                 break;
             }
-            // We move the current index to that of the last log we found
-            currentIndex += indexOfLastLog + 1;
+            // We've found logs so we update the last found log index
+            lastFoundLogIndex = (lastFoundLogIndex ?? 0) + indexOfLastLogWithinArray;
+            // We move the current index to that of the log right after the last found log
+            currentIndex = lastFoundLogIndex + 1;
             // We compute the number of consecutive empty logs we found and repeat the process if we haven't found enough.
-            numConsecutiveEmptyLogs = WINDOW_SIZE - indexOfLastLog - 1;
+            numConsecutiveEmptyLogs = WINDOW_SIZE - indexOfLastLogWithinArray - 1;
         }while (numConsecutiveEmptyLogs < MIN_CONSECUTIVE_EMPTY_LOGS)
         const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
-        if (currentIndex !== oldIndex) {
-            await this.taggingDataProvider.setTaggingSecretsIndexesAsSender([
-                new IndexedTaggingSecret(appTaggingSecret, currentIndex)
-            ], sender);
-            this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
-                sender,
-                secret: appTaggingSecret,
+        if (lastFoundLogIndex !== undefined) {
+            // Last found index is defined meaning we have actually found logs so we update the last used index
+            await this.taggingDataProvider.setLastUsedIndexesAsSender([
+                {
+                    secret,
+                    index: lastFoundLogIndex
+                }
+            ]);
+            this.log.debug(`Syncing logs for secret ${secret.toString()} at contract ${contractName}(${contractAddress})`, {
                 index: currentIndex,
                 contractName,
                 contractAddress
             });
         } else {
-            this.log.debug(`No new logs found for sender ${sender} at contract ${contractName}(${contractAddress})`);
+            this.log.debug(`No new logs found for secret ${secret.toString()} at contract ${contractName}(${contractAddress})`);
         }
     }
     /**
@@ -351,7 +309,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
         for (const recipient of recipients){
             // Get all the secrets for the recipient and sender pairs (#9365)
-            const secrets = await this.#getIndexedTaggingSecretsForSenders(contractAddress, recipient);
+            const indexedSecrets = await this.#getLastUsedTaggingIndexesForSenders(contractAddress, recipient);
             // We fetch logs for a window of indexes in a range:
             //    <latest_log_index - WINDOW_HALF_SIZE, latest_log_index + WINDOW_HALF_SIZE>.
             //
@@ -360,25 +318,39 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
             // for logs the first time we don't receive any logs for a tag, we might never receive anything from that sender again.
             //    Also there's a possibility that we have advanced our index, but the sender has reused it, so we might have missed
             // some logs. For these reasons, we have to look both back and ahead of the stored index.
-            let secretsAndWindows = secrets.map((secret)=>{
-                return {
-                    appTaggingSecret: secret.appTaggingSecret,
-                    leftMostIndex: Math.max(0, secret.index - WINDOW_HALF_SIZE),
-                    rightMostIndex: secret.index + WINDOW_HALF_SIZE
-                };
+            let secretsAndWindows = indexedSecrets.map((indexedSecret)=>{
+                if (indexedSecret.index === undefined) {
+                    return {
+                        secret: indexedSecret.secret,
+                        leftMostIndex: 0,
+                        rightMostIndex: WINDOW_HALF_SIZE
+                    };
+                } else {
+                    return {
+                        secret: indexedSecret.secret,
+                        leftMostIndex: Math.max(0, indexedSecret.index - WINDOW_HALF_SIZE),
+                        rightMostIndex: indexedSecret.index + WINDOW_HALF_SIZE
+                    };
+                }
             });
             // As we iterate we store the largest index we have seen for a given secret to later on store it in the db.
             const newLargestIndexMapToStore = {};
-            // The initial/unmodified indexes of the secrets stored in a key-value map where key is the app tagging secret.
-            const initialIndexesMap = getInitialIndexesMap(secrets);
+            // The initial/unmodified indexes of the secrets stored in a key-value map where key is the directional app
+            // tagging secret.
+            const initialIndexesMap = getInitialIndexesMap(indexedSecrets);
             while(secretsAndWindows.length > 0){
-                const secretsForTheWholeWindow = getIndexedTaggingSecretsForTheWindow(secretsAndWindows);
-                const tagsForTheWholeWindow = await Promise.all(secretsForTheWholeWindow.map((secret)=>secret.computeSiloedTag(recipient, contractAddress)));
+                const preTagsForTheWholeWindow = getPreTagsForTheWindow(secretsAndWindows);
+                const tagsForTheWholeWindow = await Promise.all(preTagsForTheWholeWindow.map(async (preTag)=>{
+                    return SiloedTag.compute(await Tag.compute(preTag), contractAddress);
+                }));
                 // We store the new largest indexes we find in the iteration in the following map to later on construct
                 // a new set of secrets and windows to fetch logs for.
                 const newLargestIndexMapForIteration = {};
                 // Fetch the private logs for the tags and iterate over them
-                const logsByTags = await this.#getPrivateLogsByTags(tagsForTheWholeWindow);
+                // TODO: The following conversion is unfortunate and we should most likely just type the #getPrivateLogsByTags
+                // to accept SiloedTag[] instead of Fr[]. That would result in a large change so I didn't do it yet.
+                const tagsForTheWholeWindowAsFr = tagsForTheWholeWindow.map((tag)=>tag.value);
+                const logsByTags = await this.#getPrivateLogsByTags(tagsForTheWholeWindowAsFr);
                 this.log.debug(`Found ${logsByTags.filter((logs)=>logs.length > 0).length} logs as recipient ${recipient}`, {
                     recipient,
                     contractName,
@@ -387,19 +359,19 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
                 for(let logIndex = 0; logIndex < logsByTags.length; logIndex++){
                     const logsByTag = logsByTags[logIndex];
                     if (logsByTag.length > 0) {
-                        // We filter out the logs that are newer than the historical block number of the tx currently being constructed
+                        // We filter out the logs that are newer than the anchor block number of the tx currently being constructed
                         const filteredLogsByBlockNumber = logsByTag.filter((l)=>l.blockNumber <= maxBlockNumber);
                         // We store the logs in capsules (to later be obtained in Noir)
                         await this.#storePendingTaggedLogs(contractAddress, pendingTaggedLogArrayBaseSlot, recipient, filteredLogsByBlockNumber);
-                        // We retrieve the indexed tagging secret corresponding to the log as I need that to evaluate whether
+                        // We retrieve the pre tag corresponding to the log as I need that to evaluate whether
                         // a new largest index have been found.
-                        const secretCorrespondingToLog = secretsForTheWholeWindow[logIndex];
-                        const initialIndex = initialIndexesMap[secretCorrespondingToLog.appTaggingSecret.toString()];
-                        if (secretCorrespondingToLog.index >= initialIndex && (newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()] === undefined || secretCorrespondingToLog.index >= newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()])) {
+                        const preTagCorrespondingToLog = preTagsForTheWholeWindow[logIndex];
+                        const initialIndex = initialIndexesMap[preTagCorrespondingToLog.secret.toString()];
+                        if (preTagCorrespondingToLog.index >= initialIndex && (newLargestIndexMapForIteration[preTagCorrespondingToLog.secret.toString()] === undefined || preTagCorrespondingToLog.index >= newLargestIndexMapForIteration[preTagCorrespondingToLog.secret.toString()])) {
                             // We have found a new largest index so we store it for later processing (storing it in the db + fetching
                             // the difference of the window sets of current and the next iteration)
-                            newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()] = secretCorrespondingToLog.index + 1;
-                            this.log.debug(`Incrementing index to ${secretCorrespondingToLog.index + 1} at contract ${contractName}(${contractAddress})`);
+                            newLargestIndexMapForIteration[preTagCorrespondingToLog.secret.toString()] = preTagCorrespondingToLog.index + 1;
+                            this.log.debug(`Incrementing index to ${preTagCorrespondingToLog.index + 1} at contract ${contractName}(${contractAddress})`);
                         }
                     }
                 }
@@ -407,26 +379,31 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
                 // for. Note that it's very unlikely that a new log from the current window would appear between the iterations
                 // so we fetch the logs only for the difference of the window sets.
                 const newSecretsAndWindows = [];
-                for (const [appTaggingSecret, newIndex] of Object.entries(newLargestIndexMapForIteration)){
-                    const secret = secrets.find((secret)=>secret.appTaggingSecret.toString() === appTaggingSecret);
-                    if (secret) {
+                for (const [directionalAppTaggingSecret, newIndex] of Object.entries(newLargestIndexMapForIteration)){
+                    const maybeIndexedSecret = indexedSecrets.find((indexedSecret)=>indexedSecret.secret.toString() === directionalAppTaggingSecret);
+                    if (maybeIndexedSecret) {
                         newSecretsAndWindows.push({
-                            appTaggingSecret: secret.appTaggingSecret,
+                            secret: maybeIndexedSecret.secret,
                             // We set the left most index to the new index to avoid fetching the same logs again
                             leftMostIndex: newIndex,
                             rightMostIndex: newIndex + WINDOW_HALF_SIZE
                         });
                         // We store the new largest index in the map to later store it in the db.
-                        newLargestIndexMapToStore[appTaggingSecret] = newIndex;
+                        newLargestIndexMapToStore[directionalAppTaggingSecret] = newIndex;
                     } else {
-                        throw new Error(`Secret not found for appTaggingSecret ${appTaggingSecret}. This is a bug as it should never happen!`);
+                        throw new Error(`Secret not found for directionalAppTaggingSecret ${directionalAppTaggingSecret}. This is a bug as it should never happen!`);
                     }
                 }
                 // Now we set the new secrets and windows and proceed to the next iteration.
                 secretsAndWindows = newSecretsAndWindows;
             }
-            // At this point we have processed all the logs for the recipient so we store the new largest indexes in the db.
-            await this.taggingDataProvider.setTaggingSecretsIndexesAsRecipient(Object.entries(newLargestIndexMapToStore).map(([appTaggingSecret, index])=>new IndexedTaggingSecret(Fr.fromHexString(appTaggingSecret), index)), recipient);
+            // At this point we have processed all the logs for the recipient so we store the last used indexes in the db.
+            // newLargestIndexMapToStore contains "next" indexes to look for (one past the last found), so subtract 1 to get
+            // last used.
+            await this.taggingDataProvider.setLastUsedIndexesAsRecipient(Object.entries(newLargestIndexMapToStore).map(([directionalAppTaggingSecret, index])=>({
+                    secret: DirectionalAppTaggingSecret.fromString(directionalAppTaggingSecret),
+                    index: index - 1
+                })));
         }
     }
     async #storePendingTaggedLogs(contractAddress, capsuleArrayBaseSlot, recipient, privateLogs) {
@@ -447,7 +424,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         // faster as we don't need to wait for the network round-trip.
         const noteValidationRequests = (await this.capsuleDataProvider.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot)).map(NoteValidationRequest.fromFields);
         const eventValidationRequests = (await this.capsuleDataProvider.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot)).map(EventValidationRequest.fromFields);
-        const noteDeliveries = noteValidationRequests.map((request)=>this.deliverNote(request.contractAddress, request.storageSlot, request.noteNonce, request.content, request.noteHash, request.nullifier, request.txHash, request.recipient));
+        const noteDeliveries = noteValidationRequests.map((request)=>this.deliverNote(request.contractAddress, request.owner, request.storageSlot, request.randomness, request.noteNonce, request.content, request.noteHash, request.nullifier, request.txHash, request.recipient));
         const eventDeliveries = eventValidationRequests.map((request)=>this.deliverEvent(request.contractAddress, request.eventTypeId, request.serializedEvent, request.eventCommitment, request.txHash, request.recipient));
         await Promise.all([
             ...noteDeliveries,
@@ -457,7 +434,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         await this.capsuleDataProvider.setCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, []);
         await this.capsuleDataProvider.setCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, []);
     }
-    async deliverNote(contractAddress, storageSlot, noteNonce, content, noteHash, nullifier, txHash, recipient) {
+    async deliverNote(contractAddress, owner, storageSlot, randomness, noteNonce, content, noteHash, nullifier, txHash, recipient) {
         // We are going to store the new note in the NoteDataProvider, 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
@@ -481,6 +458,17 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         // 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 = await this.aztecNode.getTxEffect(txHash);
+        if (!txEffect) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash}`);
+        }
+        if (txEffect.l2BlockNumber > syncedBlockNumber) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
+        }
+        const noteInTx = txEffect.data.noteHashes.some((nh)=>nh.equals(uniqueNoteHash));
+        if (!noteInTx) {
+            throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
+        }
         // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
         // note existence in said tree. We concurrently also check if the note's nullifier exists, performing all node
         // queries in a single round-trip.
@@ -495,7 +483,8 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         if (uniqueNoteHashTreeIndexInBlock === undefined) {
             throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`);
         }
-        const noteDao = new NoteDao(new Note(content), contractAddress, storageSlot, noteNonce, noteHash, siloedNullifier, txHash, uniqueNoteHashTreeIndexInBlock?.l2BlockNumber, uniqueNoteHashTreeIndexInBlock?.l2BlockHash.toString(), uniqueNoteHashTreeIndexInBlock?.data, recipient);
+        const noteDao = new NoteDao(new Note(content), contractAddress, owner, storageSlot, randomness, noteNonce, noteHash, siloedNullifier, txHash, uniqueNoteHashTreeIndexInBlock.l2BlockNumber, uniqueNoteHashTreeIndexInBlock.l2BlockHash.toString(), uniqueNoteHashTreeIndexInBlock.data);
+        // The note was found by `recipient`, so we use that as the scope when storing the note.
         await this.noteDataProvider.addNotes([
             noteDao
         ], recipient);
@@ -508,12 +497,12 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         });
         if (nullifierIndex !== undefined) {
             const { data: _, ...blockHashAndNum } = nullifierIndex;
-            await this.noteDataProvider.removeNullifiedNotes([
+            await this.noteDataProvider.applyNullifiers([
                 {
                     data: siloedNullifier,
                     ...blockHashAndNum
                 }
-            ], recipient);
+            ]);
             this.log.verbose(`Removed just-added note`, {
                 contract: contractAddress,
                 slot: storageSlot,
@@ -540,7 +529,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
             } else if (privateLog !== null) {
                 return new LogRetrievalResponse(privateLog.logPayload, privateLog.txHash, privateLog.uniqueNoteHashesInTx, privateLog.firstNullifierInTx);
             } else {
-                null;
+                return null;
             }
         }));
         // Requests are cleared once we're done.
@@ -548,20 +537,39 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         // The responses are stored as Option<LogRetrievalResponse> in a second CapsuleArray.
         await this.capsuleDataProvider.setCapsuleArray(contractAddress, logRetrievalResponsesArrayBaseSlot, maybeLogRetrievalResponses.map(LogRetrievalResponse.toSerializedOption));
     }
-    async deliverEvent(contractAddress, selector, content, eventCommitment, txHash, recipient) {
+    async deliverEvent(contractAddress, selector, content, eventCommitment, txHash, scope) {
         // While using 'latest' block number would be fine for private events since they cannot be accessed from Aztec.nr
         // (and thus we're less concerned about being ahead of the synced block), we use the synced block number to
         // maintain consistent behavior in the PXE. Additionally, events should never be ahead of the synced block here
         // since `fetchTaggedLogs` only processes logs up to the synced block.
-        const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        const siloedEventCommitment = await siloNullifier(contractAddress, eventCommitment);
+        const [syncedBlockNumber, siloedEventCommitment, txEffect] = await Promise.all([
+            this.syncDataProvider.getBlockNumber(),
+            siloNullifier(contractAddress, eventCommitment),
+            this.aztecNode.getTxEffect(txHash)
+        ]);
+        if (!txEffect) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash}`);
+        }
+        if (txEffect.l2BlockNumber > syncedBlockNumber) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
+        }
+        const eventInTx = txEffect.data.nullifiers.some((n)=>n.equals(siloedEventCommitment));
+        if (!eventInTx) {
+            throw new Error(`Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present in tx ${txHash}`);
+        }
         const [nullifierIndex] = await this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [
             siloedEventCommitment
         ]);
         if (nullifierIndex === undefined) {
             throw new Error(`Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present on the nullifier tree at block ${syncedBlockNumber} (from tx ${txHash})`);
         }
-        return this.privateEventDataProvider.storePrivateEventLog(contractAddress, recipient, selector, content, txHash, Number(nullifierIndex.data), nullifierIndex.l2BlockNumber);
+        return this.privateEventDataProvider.storePrivateEventLog(selector, content, Number(nullifierIndex.data), {
+            contractAddress,
+            scope,
+            txHash,
+            l2BlockNumber: nullifierIndex.l2BlockNumber,
+            l2BlockHash: nullifierIndex.l2BlockHash
+        });
     }
     // TODO(#14555): delete this function and implement this behavior in the node instead
     async getPublicLogByTag(tag, contractAddress) {
@@ -609,56 +617,60 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
         }
         return new PrivateLogWithTxData(scopedLog.log.getEmittedFieldsWithoutTag(), scopedLog.txHash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
     }
-    async removeNullifiedNotes(contractAddress) {
+    /**
+   * Looks for nullifiers of active contract notes and marks them as nullified if a nullifier is found.
+   *
+   * Fetches notes from the NoteDataProvider and checks which nullifiers are present in the
+   * onchain nullifier Merkle tree -  up to the latest locally synced block. We use the
+   * locally synced block instead of querying the chain's 'latest' block to ensure correctness:
+   * notes are only marked nullified once their corresponding nullifier has been included in a
+   * block up to which the PXE has synced.
+   * This allows recent nullifications to be processed even if the node is not an archive node.
+   *
+   * @param contractAddress - The contract whose notes should be checked and nullified.
+   */ async syncNoteNullifiers(contractAddress) {
         this.log.verbose('Searching for nullifiers of known notes', {
             contract: contractAddress
         });
-        // We avoid making node queries at 'latest' since we mark notes as nullified only if the corresponding nullifier
-        // has been included in a block up to which PXE has synced. Note that while this technically results in historical
-        // queries, we perform it at the latest locally synced block number which *should* be recent enough to be
-        // available, even for non-archive nodes.
         const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        for (const recipient of (await this.keyStore.getAccounts())){
-            const currentNotesForRecipient = await this.noteDataProvider.getNotes({
-                contractAddress,
-                recipient
-            });
-            if (currentNotesForRecipient.length === 0) {
-                continue;
+        const contractNotes = await this.noteDataProvider.getNotes({
+            contractAddress
+        });
+        if (contractNotes.length === 0) {
+            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
+                ]);
             }
-            const nullifiersToCheck = currentNotesForRecipient.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(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, batch)))).flat();
-            const foundNullifiers = nullifiersToCheck.map((nullifier, i)=>{
-                if (nullifierIndexes[i] !== undefined) {
-                    return {
-                        ...nullifierIndexes[i],
-                        ...{
-                            data: nullifier
-                        }
-                    };
-                }
-            }).filter((nullifier)=>nullifier !== undefined);
-            const nullifiedNotes = await this.noteDataProvider.removeNullifiedNotes(foundNullifiers, recipient);
-            nullifiedNotes.forEach((noteDao)=>{
-                this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
-                    contract: noteDao.contractAddress,
-                    slot: noteDao.storageSlot,
-                    nullifier: noteDao.siloedNullifier.toString()
-                });
+            return acc;
+        }, [
+            []
+        ]);
+        const nullifierIndexes = (await Promise.all(nullifierBatches.map((batch)=>this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, batch)))).flat();
+        const foundNullifiers = nullifiersToCheck.map((nullifier, i)=>{
+            if (nullifierIndexes[i] !== undefined) {
+                return {
+                    ...nullifierIndexes[i],
+                    ...{
+                        data: nullifier
+                    }
+                };
+            }
+        }).filter((nullifier)=>nullifier !== undefined);
+        const nullifiedNotes = await this.noteDataProvider.applyNullifiers(foundNullifiers);
+        nullifiedNotes.forEach((noteDao)=>{
+            this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
+                contract: noteDao.contractAddress,
+                slot: noteDao.storageSlot,
+                nullifier: noteDao.siloedNullifier.toString()
             });
-        }
+        });
     }
     storeCapsule(contractAddress, slot, capsule) {
         return this.capsuleDataProvider.storeCapsule(contractAddress, slot, capsule);