@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/dest/contract_function_simulator/pxe_oracle_interface.js

@@ -1,701 +0,0 @@
-import { timesParallel } from '@aztec/foundation/collection';
-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 } 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 { 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';
-/**
- * A data layer that provides and stores information needed for simulating/proving a transaction.
- */ export class PXEOracleInterface {
-    aztecNode;
-    keyStore;
-    contractDataProvider;
-    noteDataProvider;
-    capsuleDataProvider;
-    syncDataProvider;
-    taggingDataProvider;
-    addressDataProvider;
-    privateEventDataProvider;
-    log;
-    constructor(aztecNode, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, log = createLogger('pxe:pxe_oracle_interface')){
-        this.aztecNode = aztecNode;
-        this.keyStore = keyStore;
-        this.contractDataProvider = contractDataProvider;
-        this.noteDataProvider = noteDataProvider;
-        this.capsuleDataProvider = capsuleDataProvider;
-        this.syncDataProvider = syncDataProvider;
-        this.taggingDataProvider = taggingDataProvider;
-        this.addressDataProvider = addressDataProvider;
-        this.privateEventDataProvider = privateEventDataProvider;
-        this.log = log;
-    }
-    getKeyValidationRequest(pkMHash, contractAddress) {
-        return this.keyStore.getKeyValidationRequest(pkMHash, contractAddress);
-    }
-    async getCompleteAddress(account) {
-        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/resources/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`);
-        }
-        return completeAddress;
-    }
-    async getContractInstance(address) {
-        const instance = await this.contractDataProvider.getContractInstance(address);
-        if (!instance) {
-            throw new Error(`No contract instance found for address ${address.toString()}`);
-        }
-        return instance;
-    }
-    async getNotes(contractAddress, storageSlot, status, scopes) {
-        const noteDaos = await this.noteDataProvider.getNotes({
-            contractAddress,
-            storageSlot,
-            status,
-            scopes
-        });
-        return noteDaos.map(({ contractAddress, storageSlot, noteNonce, note, noteHash, siloedNullifier, index })=>({
-                contractAddress,
-                storageSlot,
-                noteNonce,
-                note,
-                noteHash,
-                siloedNullifier,
-                // PXE can use this index to get full MembershipWitness
-                index
-            }));
-    }
-    async getFunctionArtifact(contractAddress, selector) {
-        const artifact = await this.contractDataProvider.getFunctionArtifact(contractAddress, selector);
-        if (!artifact) {
-            throw new Error(`Function artifact not found for contract ${contractAddress} and selector ${selector}.`);
-        }
-        const debug = await this.contractDataProvider.getFunctionDebugMetadata(contractAddress, selector);
-        return {
-            ...artifact,
-            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.
-   * @param messageHash - Hash of the message.
-   * @param secret - Secret used to compute a nullifier.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */ async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        const [messageIndex, siblingPath] = await getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
-        // Assuming messageIndex is what you intended to use for the index in MessageLoadOracleInputs
-        return new MessageLoadOracleInputs(messageIndex, siblingPath);
-    }
-    async getNullifierIndex(nullifier) {
-        return await this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
-    }
-    async #findLeafIndex(blockNumber, treeId, leafValue) {
-        const [leafIndex] = await this.aztecNode.findLeavesIndexes(blockNumber, treeId, [
-            leafValue
-        ]);
-        return leafIndex?.data;
-    }
-    async getMembershipWitness(blockNumber, treeId, leafValue) {
-        const witness = await this.#tryGetMembershipWitness(blockNumber, treeId, leafValue);
-        if (!witness) {
-            throw new Error(`Leaf value ${leafValue} not found in tree ${MerkleTreeId[treeId]} at block ${blockNumber}`);
-        }
-        return witness;
-    }
-    async #tryGetMembershipWitness(blockNumber, treeId, value) {
-        switch(treeId){
-            case MerkleTreeId.NULLIFIER_TREE:
-                return (await this.aztecNode.getNullifierMembershipWitness(blockNumber, value))?.withoutPreimage().toFields();
-            case MerkleTreeId.NOTE_HASH_TREE:
-                return (await this.aztecNode.getNoteHashMembershipWitness(blockNumber, value))?.toFields();
-            case MerkleTreeId.PUBLIC_DATA_TREE:
-                return (await this.aztecNode.getPublicDataWitness(blockNumber, value))?.withoutPreimage().toFields();
-            case MerkleTreeId.ARCHIVE:
-                return (await this.aztecNode.getArchiveMembershipWitness(blockNumber, value))?.toFields();
-            default:
-                throw new Error('Not implemented');
-        }
-    }
-    async getNullifierMembershipWitnessAtLatestBlock(nullifier) {
-        const blockNumber = (await this.getAnchorBlockHeader()).globalVariables.blockNumber;
-        return this.getNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    getNullifierMembershipWitness(blockNumber, nullifier) {
-        return this.aztecNode.getNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    async getLowNullifierMembershipWitness(blockNumber, nullifier) {
-        const header = await this.getAnchorBlockHeader();
-        if (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 > 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 > 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 > 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);
-    }
-    getAnchorBlockHeader() {
-        return this.syncDataProvider.getBlockHeader();
-    }
-    assertCompatibleOracleVersion(version) {
-        if (version !== ORACLE_VERSION) {
-            throw new Error(`Incompatible oracle version. Expected version ${ORACLE_VERSION}, got ${version}.`);
-        }
-    }
-    getDebugFunctionName(contractAddress, selector) {
-        return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
-    }
-    /**
-   * Returns the full contents of your address book.
-   * This is used when calculating tags for incoming notes by deriving the shared secret, the contract-siloed tagging secret, and
-   * finally the index specified tag. We will then query the node with this tag for each address in the address book.
-   * @returns The full list of the users contact addresses.
-   */ getSenders() {
-        return this.taggingDataProvider.getSenderAddresses();
-    }
-    getLastUsedIndexAsSender(secret) {
-        return this.taggingDataProvider.getLastUsedIndexesAsSender(secret);
-    }
-    async calculateDirectionalAppTaggingSecret(contractAddress, sender, recipient) {
-        const senderCompleteAddress = await this.getCompleteAddress(sender);
-        const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-        return DirectionalAppTaggingSecret.compute(senderCompleteAddress, senderIvsk, recipient, contractAddress, recipient);
-    }
-    /**
-   * 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 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
-        // (recipient = us, sender = us)
-        const senders = [
-            ...await this.taggingDataProvider.getSenderAddresses(),
-            ...await this.keyStore.getAccounts()
-        ].filter((address, index, self)=>index === self.findIndex((otherAddress)=>otherAddress.equals(address)));
-        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]
-            }));
-    }
-    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.
-        // 2. If we don't find minimum consecutive empty logs in a window of logs we slide the window to latest log index
-        // and repeat the process.
-        const MIN_CONSECUTIVE_EMPTY_LOGS = 10;
-        const WINDOW_SIZE = MIN_CONSECUTIVE_EMPTY_LOGS * 2;
-        let [numConsecutiveEmptyLogs, currentIndex] = [
-            0,
-            startIndex
-        ];
-        let lastFoundLogIndex = undefined;
-        do {
-            // We compute the tags for the current window of indexes
-            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
-            // 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 indexOfLastLogWithinArray = possibleLogs.findLastIndex((possibleLog)=>possibleLog.length !== 0);
-            if (indexOfLastLogWithinArray === -1) {
-                break;
-            }
-            // 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 - indexOfLastLogWithinArray - 1;
-        }while (numConsecutiveEmptyLogs < MIN_CONSECUTIVE_EMPTY_LOGS)
-        const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
-        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 secret ${secret.toString()} at contract ${contractName}(${contractAddress})`);
-        }
-    }
-    /**
-   * Synchronizes the private logs tagged with scoped addresses and all the senders in the address book. Stores the found
-   * logs in CapsuleArray ready for a later retrieval in Aztec.nr.
-   * @param contractAddress - The address of the contract that the logs are tagged for.
-   * @param pendingTaggedLogArrayBaseSlot - The base slot of the pending tagged logs capsule array in which
-   * found logs will be stored.
-   * @param scopes - The scoped addresses to sync logs for. If not provided, all accounts in the address book will be
-   * synced.
-   */ async syncTaggedLogs(contractAddress, pendingTaggedLogArrayBaseSlot, scopes) {
-        this.log.verbose('Searching for tagged logs', {
-            contract: contractAddress
-        });
-        const maxBlockNumber = await this.syncDataProvider.getBlockNumber();
-        // Ideally this algorithm would be implemented in noir, exposing its building blocks as oracles.
-        // However it is impossible at the moment due to the language not supporting nested slices.
-        // This nesting is necessary because for a given set of tags we don't
-        // know how many logs we will get back. Furthermore, these logs are of undetermined
-        // length, since we don't really know the note they correspond to until we decrypt them.
-        const recipients = scopes ? scopes : await this.keyStore.getAccounts();
-        const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
-        for (const recipient of recipients){
-            // Get all the secrets for the recipient and sender pairs (#9365)
-            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>.
-            //
-            // We use this window approach because it could happen that a sender might have messed up and inadvertently
-            // incremented their index without us getting any logs (for example, in case of a revert). If we stopped looking
-            // 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 = 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 directional app
-            // tagging secret.
-            const initialIndexesMap = getInitialIndexesMap(indexedSecrets);
-            while(secretsAndWindows.length > 0){
-                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
-                // 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,
-                    contractAddress
-                });
-                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 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 pre tag corresponding to the log as I need that to evaluate whether
-                        // a new largest index have been found.
-                        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[preTagCorrespondingToLog.secret.toString()] = preTagCorrespondingToLog.index + 1;
-                            this.log.debug(`Incrementing index to ${preTagCorrespondingToLog.index + 1} at contract ${contractName}(${contractAddress})`);
-                        }
-                    }
-                }
-                // Now based on the new largest indexes we found, we will construct a new secrets and windows set to fetch logs
-                // 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 [directionalAppTaggingSecret, newIndex] of Object.entries(newLargestIndexMapForIteration)){
-                    const maybeIndexedSecret = indexedSecrets.find((indexedSecret)=>indexedSecret.secret.toString() === directionalAppTaggingSecret);
-                    if (maybeIndexedSecret) {
-                        newSecretsAndWindows.push({
-                            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[directionalAppTaggingSecret] = newIndex;
-                    } else {
-                        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 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) {
-        // Build all pending tagged logs upfront with their tx effects
-        const pendingTaggedLogs = await Promise.all(privateLogs.map(async (scopedLog)=>{
-            // TODO(#9789): get these effects along with the log
-            const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
-            if (!txEffect) {
-                throw new Error(`Could not find tx effect for tx hash ${scopedLog.txHash}`);
-            }
-            const pendingTaggedLog = new PendingTaggedLog(scopedLog.log.fields, scopedLog.txHash, txEffect.data.noteHashes, txEffect.data.nullifiers[0], recipient);
-            return pendingTaggedLog.toFields();
-        }));
-        return this.capsuleDataProvider.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs);
-    }
-    async validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
-        // We read all note and event validation requests and process them all concurrently. This makes the process much
-        // 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 eventDeliveries = eventValidationRequests.map((request)=>this.deliverEvent(request.contractAddress, request.eventTypeId, request.serializedEvent, request.eventCommitment, request.txHash, request.recipient));
-        await Promise.all([
-            ...noteDeliveries,
-            ...eventDeliveries
-        ]);
-        // Requests are cleared once we're done.
-        await this.capsuleDataProvider.setCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, []);
-        await this.capsuleDataProvider.setCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, []);
-    }
-    async deliverNote(contractAddress, storageSlot, 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
-        //  - 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.
-        // 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
-        // number which *should* be recent enough to be available, even for non-archive nodes.
-        // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
-        // logs up to the synced block making this only an additional safety check.
-        const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        // 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);
-        // 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.
-        const [[uniqueNoteHashTreeIndexInBlock], [nullifierIndex]] = await Promise.all([
-            this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NOTE_HASH_TREE, [
-                uniqueNoteHash
-            ]),
-            this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [
-                siloedNullifier
-            ])
-        ]);
-        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);
-        await this.noteDataProvider.addNotes([
-            noteDao
-        ], recipient);
-        this.log.verbose('Added note', {
-            index: noteDao.index,
-            contract: noteDao.contractAddress.toString(),
-            slot: noteDao.storageSlot.toString(),
-            noteHash: noteDao.noteHash.toString(),
-            nullifier: noteDao.siloedNullifier.toString()
-        });
-        if (nullifierIndex !== undefined) {
-            const { data: _, ...blockHashAndNum } = nullifierIndex;
-            await this.noteDataProvider.applyNullifiers([
-                {
-                    data: siloedNullifier,
-                    ...blockHashAndNum
-                }
-            ]);
-            this.log.verbose(`Removed just-added note`, {
-                contract: contractAddress,
-                slot: storageSlot,
-                noteHash: noteHash,
-                nullifier: siloedNullifier.toString()
-            });
-        }
-    }
-    async bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
-        // We read all log retrieval requests and process them all concurrently. This makes the process much faster as we
-        // don't need to wait for the network round-trip.
-        const logRetrievalRequests = (await this.capsuleDataProvider.readCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot)).map(LogRetrievalRequest.fromFields);
-        const maybeLogRetrievalResponses = await Promise.all(logRetrievalRequests.map(async (request)=>{
-            // TODO(#14555): remove these internal functions and have node endpoints that do this instead
-            const [publicLog, privateLog] = await Promise.all([
-                this.getPublicLogByTag(request.unsiloedTag, request.contractAddress),
-                this.getPrivateLogByTag(await siloPrivateLog(request.contractAddress, request.unsiloedTag))
-            ]);
-            if (publicLog !== null) {
-                if (privateLog !== null) {
-                    throw new Error(`Found both a public and private log when searching for tag ${request.unsiloedTag} from contract ${request.contractAddress}`);
-                }
-                return new LogRetrievalResponse(publicLog.logPayload, publicLog.txHash, publicLog.uniqueNoteHashesInTx, publicLog.firstNullifierInTx);
-            } else if (privateLog !== null) {
-                return new LogRetrievalResponse(privateLog.logPayload, privateLog.txHash, privateLog.uniqueNoteHashesInTx, privateLog.firstNullifierInTx);
-            } else {
-                null;
-            }
-        }));
-        // Requests are cleared once we're done.
-        await this.capsuleDataProvider.setCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, []);
-        // 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) {
-        // 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, 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((nullifier)=>nullifier.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, nullifierIndex.l2BlockHash);
-    }
-    // TODO(#14555): delete this function and implement this behavior in the node instead
-    async getPublicLogByTag(tag, contractAddress) {
-        const logs = await this.#getPublicLogsByTagsFromContract([
-            tag
-        ], contractAddress);
-        const logsForTag = logs[0];
-        this.log.debug(`Got ${logsForTag.length} public logs for tag ${tag}`);
-        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`);
-        }
-        const scopedLog = logsForTag[0];
-        // getLogsByTag doesn't have all of the information that we need (notably note hashes and the first nullifier), so
-        // we need to make a second call to the node for `getTxEffect`.
-        // TODO(#9789): bundle this information in the `getLogsByTag` call.
-        const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
-        if (txEffect == undefined) {
-            throw new Error(`Unexpected: failed to retrieve tx effects for tx ${scopedLog.txHash} which is known to exist`);
-        }
-        return new PublicLogWithTxData(scopedLog.log.getEmittedFieldsWithoutTag(), scopedLog.txHash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
-    }
-    // TODO(#14555): delete this function and implement this behavior in the node instead
-    async getPrivateLogByTag(siloedTag) {
-        const logs = await this.#getPrivateLogsByTags([
-            siloedTag
-        ]);
-        const logsForTag = logs[0];
-        this.log.debug(`Got ${logsForTag.length} private logs for tag ${siloedTag}`);
-        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`);
-        }
-        const scopedLog = logsForTag[0];
-        // getLogsByTag doesn't have all of the information that we need (notably note hashes and the first nullifier), so
-        // we need to make a second call to the node for `getTxEffect`.
-        // TODO(#9789): bundle this information in the `getLogsByTag` call.
-        const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
-        if (txEffect == undefined) {
-            throw new Error(`Unexpected: failed to retrieve tx effects for tx ${scopedLog.txHash} which is known to exist`);
-        }
-        return new PrivateLogWithTxData(scopedLog.log.getEmittedFieldsWithoutTag(), scopedLog.txHash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
-    }
-    /**
-   * 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
-        });
-        const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        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
-                ]);
-            }
-            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);
-    }
-    loadCapsule(contractAddress, slot) {
-        return this.capsuleDataProvider.loadCapsule(contractAddress, slot);
-    }
-    deleteCapsule(contractAddress, slot) {
-        return this.capsuleDataProvider.deleteCapsule(contractAddress, slot);
-    }
-    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        return this.capsuleDataProvider.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
-    }
-    async getSharedSecret(address, ephPk) {
-        // TODO(#12656): return an app-siloed secret
-        const recipientCompleteAddress = await this.getCompleteAddress(address);
-        const ivskM = await this.keyStore.getMasterSecretKey(recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey);
-        const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
-        return deriveEcdhSharedSecret(addressSecret, ephPk);
-    }
-    // TODO(#12656): Make this a public function on the AztecNode interface and remove the original getLogsByTags. This
-    // was not done yet as we were unsure about the API and we didn't want to introduce a breaking change.
-    async #getPrivateLogsByTags(tags) {
-        const allLogs = await this.aztecNode.getLogsByTags(tags);
-        return allLogs.map((logs)=>logs.filter((log)=>!log.isFromPublic));
-    }
-    // TODO(#12656): Make this a public function on the AztecNode interface and remove the original getLogsByTags. This
-    // was not done yet as we were unsure about the API and we didn't want to introduce a breaking change.
-    async #getPublicLogsByTagsFromContract(tags, contractAddress) {
-        const allLogs = await this.aztecNode.getLogsByTags(tags);
-        const allPublicLogs = allLogs.map((logs)=>logs.filter((log)=>log.isFromPublic));
-        return allPublicLogs.map((logs)=>logs.filter((log)=>log.log.contractAddress.equals(contractAddress)));
-    }
-    getStats() {
-        const nodeRPCCalls = typeof this.aztecNode.getStats === 'function' ? this.aztecNode.getStats() : {};
-        return {
-            nodeRPCCalls
-        };
-    }
-}