@aztec/pxe 3.0.0-nightly.20251222 → 3.0.0-nightly.20251223

package/dest/logs/log_service.d.ts

@@ -0,0 +1,43 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { KeyStore } from '@aztec/key-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { DirectionalAppTaggingSecret, PrivateLogWithTxData, PublicLogWithTxData } from '@aztec/stdlib/logs';
+import type { LogRetrievalRequest } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
+import { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
+import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
+import { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
+import { RecipientTaggingDataProvider } from '../storage/tagging_data_provider/recipient_tagging_data_provider.js';
+export declare class LogService {
+    #private;
+    private readonly aztecNode;
+    private readonly anchorBlockDataProvider;
+    private readonly keyStore;
+    private readonly capsuleDataProvider;
+    private readonly recipientTaggingDataProvider;
+    private readonly addressDataProvider;
+    constructor(aztecNode: AztecNode, anchorBlockDataProvider: AnchorBlockDataProvider, keyStore: KeyStore, capsuleDataProvider: CapsuleDataProvider, recipientTaggingDataProvider: RecipientTaggingDataProvider, addressDataProvider: AddressDataProvider);
+    bulkRetrieveLogs(logRetrievalRequests: LogRetrievalRequest[]): Promise<(LogRetrievalResponse | null)[]>;
+    getPublicLogByTag(tag: Fr, contractAddress: AztecAddress): Promise<PublicLogWithTxData | null>;
+    getPrivateLogByTag(siloedTag: Fr): Promise<PrivateLogWithTxData | null>;
+    syncTaggedLogs(contractAddress: AztecAddress, pendingTaggedLogArrayBaseSlot: Fr, scopes?: AztecAddress[]): Promise<void>;
+    /**
+     * 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(#17775): The naming here is broken as the function name does not reflect the return type. Make sure this gets
+     * fixed when implementing the linked issue.
+     */
+    protected getLastUsedTaggingIndexesForSenders(contractAddress: AztecAddress, recipient: AztecAddress): Promise<{
+        secret: DirectionalAppTaggingSecret;
+        index: number | undefined;
+    }[]>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/logs/log_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_service.d.ts","sourceRoot":"","sources":["../../src/logs/log_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EACL,2BAA2B,EAE3B,oBAAoB,EAEpB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sEAAsE,CAAC;AAChH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uEAAuE,CAAC;AAC7G,OAAO,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAChG,OAAO,EAAE,uBAAuB,EAAE,MAAM,qEAAqE,CAAC;AAC9G,OAAO,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAChG,OAAO,EAAE,4BAA4B,EAAE,MAAM,qEAAqE,CAAC;AAMnH,qBAAa,UAAU;;IAEnB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,4BAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IANtC,YACmB,SAAS,EAAE,SAAS,EACpB,uBAAuB,EAAE,uBAAuB,EAChD,QAAQ,EAAE,QAAQ,EAClB,mBAAmB,EAAE,mBAAmB,EACxC,4BAA4B,EAAE,4BAA4B,EAC1D,mBAAmB,EAAE,mBAAmB,EACvD;IAES,gBAAgB,CAAC,oBAAoB,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,CAAC,oBAAoB,GAAG,IAAI,CAAC,EAAE,CAAC,CAkCnH;IAGY,iBAAiB,CAAC,GAAG,EAAE,EAAE,EAAE,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA6B1G;IAGY,kBAAkB,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CA6BnF;IAsBY,cAAc,CACzB,eAAe,EAAE,YAAY,EAC7B,6BAA6B,EAAE,EAAE,EACjC,MAAM,CAAC,EAAE,YAAY,EAAE,iBAuIxB;IAED;;;;;;;;;;;;OAYG;IACH,UAAgB,mCAAmC,CACjD,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC;QAAE,MAAM,EAAE,2BAA2B,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAAE,CAAC,CA8B/E;CA2CF"}

package/dest/logs/log_service.js

@@ -0,0 +1,258 @@
+import { siloPrivateLog } from '@aztec/stdlib/hash';
+import { DirectionalAppTaggingSecret, PendingTaggedLog, PrivateLogWithTxData, PublicLogWithTxData } from '@aztec/stdlib/logs';
+import { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
+import { WINDOW_HALF_SIZE } from '../tagging/constants.js';
+import { SiloedTag } from '../tagging/siloed_tag.js';
+import { Tag } from '../tagging/tag.js';
+import { getInitialIndexesMap, getPreTagsForTheWindow } from '../tagging/utils.js';
+export class LogService {
+    aztecNode;
+    anchorBlockDataProvider;
+    keyStore;
+    capsuleDataProvider;
+    recipientTaggingDataProvider;
+    addressDataProvider;
+    constructor(aztecNode, anchorBlockDataProvider, keyStore, capsuleDataProvider, recipientTaggingDataProvider, addressDataProvider){
+        this.aztecNode = aztecNode;
+        this.anchorBlockDataProvider = anchorBlockDataProvider;
+        this.keyStore = keyStore;
+        this.capsuleDataProvider = capsuleDataProvider;
+        this.recipientTaggingDataProvider = recipientTaggingDataProvider;
+        this.addressDataProvider = addressDataProvider;
+    }
+    async bulkRetrieveLogs(logRetrievalRequests) {
+        return 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 {
+                return null;
+            }
+        }));
+    }
+    // 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];
+        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];
+        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]);
+    }
+    // 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)));
+    }
+    // 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(#17775): Replace this implementation of this function with one implementing an approach similar
+    // to syncSenderTaggingIndexes. Not done yet due to re-prioritization to devex and this doesn't directly affect
+    // devex.
+    async syncTaggedLogs(contractAddress, pendingTaggedLogArrayBaseSlot, scopes) {
+        const maxBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).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();
+        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);
+                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;
+                        }
+                    }
+                }
+                // 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.recipientTaggingDataProvider.setLastUsedIndexes(Object.entries(newLargestIndexMapToStore).map(([directionalAppTaggingSecret, index])=>({
+                    secret: DirectionalAppTaggingSecret.fromString(directionalAppTaggingSecret),
+                    index: index - 1
+                })));
+        }
+    }
+    /**
+   * 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(#17775): The naming here is broken as the function name does not reflect the return type. Make sure this gets
+   * fixed when implementing the linked issue.
+   */ 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.recipientTaggingDataProvider.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.recipientTaggingDataProvider.getLastUsedIndexes(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 #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();
+        }));
+        // TODO: This looks like it could belong more at the oracle interface level
+        return this.capsuleDataProvider.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs);
+    }
+    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;
+    }
+}

package/dest/notes/index.d.ts

@@ -0,0 +1,2 @@
+export { NoteService } from './note_service.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ub3Rlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/notes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/notes/index.js

@@ -0,0 +1 @@
+export { NoteService } from './note_service.js';

package/dest/notes/note_service.d.ts

@@ -0,0 +1,48 @@
+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 { TxHash } from '@aztec/stdlib/tx';
+import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+export declare class NoteService {
+    private readonly noteDataProvider;
+    private readonly aztecNode;
+    private readonly anchorBlockDataProvider;
+    constructor(noteDataProvider: NoteDataProvider, aztecNode: AztecNode, anchorBlockDataProvider: AnchorBlockDataProvider);
+    /**
+     * Retrieves a set of notes stored in the database for a given contract address and storage slot.
+     * The query result is paginated using 'limit' and 'offset' values.
+     * Returns an object containing an array of note data.
+     *
+     * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
+     * @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?: AztecAddress[]): Promise<{
+        contractAddress: AztecAddress;
+        owner: AztecAddress;
+        storageSlot: Fr;
+        randomness: Fr;
+        noteNonce: Fr;
+        note: Note;
+        noteHash: Fr;
+        siloedNullifier: Fr;
+        index: bigint;
+    }[]>;
+    /**
+     * 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.
+     */
+    syncNoteNullifiers(contractAddress: AztecAddress): Promise<void>;
+    deliverNote(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr, randomness: Fr, noteNonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: TxHash, recipient: AztecAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUdoRSxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsSUFBSSxFQUFXLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DLE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLE1BQU0scUVBQXFFLENBQUM7QUFDbkgsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxREFBcUQsQ0FBQztBQUU1RixxQkFBYSxXQUFXO0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0JBQWdCO0lBQ2pDLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLHVCQUF1QjtJQUgxQyxZQUNtQixnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFDbEMsU0FBUyxFQUFFLFNBQVMsRUFDcEIsdUJBQXVCLEVBQUUsdUJBQXVCLEVBQy9EO0lBRUo7Ozs7Ozs7O09BUUc7SUFDVSxRQUFRLENBQ25CLGVBQWUsRUFBRSxZQUFZLEVBQzdCLEtBQUssRUFBRSxZQUFZLEdBQUcsU0FBUyxFQUMvQixXQUFXLEVBQUUsRUFBRSxFQUNmLE1BQU0sRUFBRSxVQUFVLEVBQ2xCLE1BQU0sQ0FBQyxFQUFFLFlBQVksRUFBRTs7Ozs7Ozs7OztTQXVCeEI7SUFFRDs7Ozs7Ozs7Ozs7T0FXRztJQUNVLGtCQUFrQixDQUFDLGVBQWUsRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNDNUU7SUFFWSxXQUFXLENBQ3RCLGVBQWUsRUFBRSxZQUFZLEVBQzdCLEtBQUssRUFBRSxZQUFZLEVBQ25CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsVUFBVSxFQUFFLEVBQUUsRUFDZCxTQUFTLEVBQUUsRUFBRSxFQUNiLE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFDYixRQUFRLEVBQUUsRUFBRSxFQUNaLFNBQVMsRUFBRSxFQUFFLEVBQ2IsTUFBTSxFQUFFLE1BQU0sRUFDZCxTQUFTLEVBQUUsWUFBWSxHQUN0QixPQUFPLENBQUMsSUFBSSxDQUFDLENBNkVmO0NBQ0YifQ==

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

@@ -0,0 +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,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qEAAqE,CAAC;AACnH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAE5F,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IAH1C,YACmB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,SAAS,EACpB,uBAAuB,EAAE,uBAAuB,EAC/D;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,CAAC,EAAE,YAAY,EAAE;;;;;;;;;;SAuBxB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsC5E;IAEY,WAAW,CACtB,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,CA6Ef;CACF"}

package/dest/notes/note_service.js

@@ -0,0 +1,152 @@
+import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
+import { Note, NoteDao } from '@aztec/stdlib/note';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+export class NoteService {
+    noteDataProvider;
+    aztecNode;
+    anchorBlockDataProvider;
+    constructor(noteDataProvider, aztecNode, anchorBlockDataProvider){
+        this.noteDataProvider = noteDataProvider;
+        this.aztecNode = aztecNode;
+        this.anchorBlockDataProvider = anchorBlockDataProvider;
+    }
+    /**
+   * Retrieves a set of notes stored in the database for a given contract address and storage slot.
+   * The query result is paginated using 'limit' and 'offset' values.
+   * Returns an object containing an array of note data.
+   *
+   * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
+   * @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.
+   */ async getNotes(contractAddress, owner, storageSlot, status, scopes) {
+        const noteDaos = await this.noteDataProvider.getNotes({
+            contractAddress,
+            owner,
+            storageSlot,
+            status,
+            scopes
+        });
+        return noteDaos.map(({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index })=>({
+                contractAddress,
+                owner,
+                storageSlot,
+                randomness,
+                noteNonce,
+                note,
+                noteHash,
+                siloedNullifier,
+                // PXE can use this index to get full MembershipWitness
+                index
+            }));
+    }
+    /**
+   * 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) {
+        const syncedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).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);
+        await this.noteDataProvider.applyNullifiers(foundNullifiers);
+    }
+    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
+        //  - 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.anchorBlockDataProvider.getBlockHeader()).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);
+        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.
+        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, 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);
+        if (nullifierIndex !== undefined) {
+            const { data: _, ...blockHashAndNum } = nullifierIndex;
+            await this.noteDataProvider.applyNullifiers([
+                {
+                    data: siloedNullifier,
+                    ...blockHashAndNum
+                }
+            ]);
+        }
+    }
+}

package/dest/private_kernel/private_kernel_oracle_impl.d.ts

@@ -10,7 +10,7 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-import type { ContractDataProvider } from '../storage/index.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 import type { PrivateKernelOracle } from './private_kernel_oracle.js';
 /**
  * A data oracle that provides information needed for simulating a transaction.
@@ -43,4 +43,4 @@ export declare class PrivateKernelOracleImpl implements PrivateKernelOracle {
     getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
     getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/private_kernel/private_kernel_oracle_impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private_kernel_oracle_impl.d.ts","sourceRoot":"","sources":["../../src/private_kernel/private_kernel_oracle_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAA2C,MAAM,kBAAkB,CAAC;AAClG,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAG/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAKtE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAE/D,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,GAAG;IALb,YACU,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,WAAW,GAAE,cAAyB,EACtC,GAAG,yCAAoC,EAC7C;IAES,0BAA0B,CAAC,OAAO,EAAE,YAAY;;;;;;;;;;OAS5D;IAEY,0BAA0B,CAAC,eAAe,EAAE,EAAE,qEAM1D;IAEY,4BAA4B,CAAC,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB,iCAQxF;IAEM,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,iCAGxD;IAEK,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAO9G;IAED,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAE5F;IAEK,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC,CAMvC;IAEM,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,CAEzE;IAEM,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAEtG;IAEY,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8B/F;CACF"}
+{"version":3,"file":"private_kernel_oracle_impl.d.ts","sourceRoot":"","sources":["../../src/private_kernel/private_kernel_oracle_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAA2C,MAAM,kBAAkB,CAAC;AAClG,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAG/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC;AACxG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAKtE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAE/D,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,GAAG;IALb,YACU,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,WAAW,GAAE,cAAyB,EACtC,GAAG,yCAAoC,EAC7C;IAES,0BAA0B,CAAC,OAAO,EAAE,YAAY;;;;;;;;;;OAS5D;IAEY,0BAA0B,CAAC,eAAe,EAAE,EAAE,qEAM1D;IAEY,4BAA4B,CAAC,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB,iCAQxF;IAEM,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,iCAGxD;IAEK,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAO9G;IAED,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAE5F;IAEK,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC,CAMvC;IAEM,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,CAEzE;IAEM,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAEtG;IAEY,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8B/F;CACF"}

package/dest/public_storage/public_storage_service.d.ts

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockParameter } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+export declare class PublicStorageService {
+    private readonly anchorBlockDataProvider;
+    private readonly aztecNode;
+    constructor(anchorBlockDataProvider: AnchorBlockDataProvider, aztecNode: AztecNode);
+    /**
+     * Gets the storage value at the given contract storage slot.
+     *
+     * @remarks The storage slot here refers to the slot as it is defined in Noir not the index in the merkle tree.
+     * Aztec's version of `eth_getStorageAt`.
+     *
+     * @param blockNumber - The block number at which to get the data.
+     * @param contract - Address of the contract to query.
+     * @param slot - Slot to query.
+     * @returns Storage value at the given contract slot.
+     * @throws If the contract is not deployed.
+     */
+    getPublicStorageAt(blockNumber: BlockParameter, contract: AztecAddress, slot: Fr): Promise<Fr>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3N0b3JhZ2Vfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpY19zdG9yYWdlL3B1YmxpY19zdG9yYWdlX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFakUsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxxRUFBcUUsQ0FBQztBQUVuSCxxQkFBYSxvQkFBb0I7SUFFN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyx1QkFBdUI7SUFDeEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBRjVCLFlBQ21CLHVCQUF1QixFQUFFLHVCQUF1QixFQUNoRCxTQUFTLEVBQUUsU0FBUyxFQUNuQztJQUVKOzs7Ozs7Ozs7OztPQVdHO0lBQ1Usa0JBQWtCLENBQUMsV0FBVyxFQUFFLGNBQWMsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQU0xRztDQUNGIn0=

package/dest/public_storage/public_storage_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_storage_service.d.ts","sourceRoot":"","sources":["../../src/public_storage/public_storage_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qEAAqE,CAAC;AAEnH,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAF5B,YACmB,uBAAuB,EAAE,uBAAuB,EAChD,SAAS,EAAE,SAAS,EACnC;IAEJ;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAM1G;CACF"}

package/dest/public_storage/public_storage_service.js

@@ -0,0 +1,26 @@
+export class PublicStorageService {
+    anchorBlockDataProvider;
+    aztecNode;
+    constructor(anchorBlockDataProvider, aztecNode){
+        this.anchorBlockDataProvider = anchorBlockDataProvider;
+        this.aztecNode = aztecNode;
+    }
+    /**
+   * Gets the storage value at the given contract storage slot.
+   *
+   * @remarks The storage slot here refers to the slot as it is defined in Noir not the index in the merkle tree.
+   * Aztec's version of `eth_getStorageAt`.
+   *
+   * @param blockNumber - The block number at which to get the data.
+   * @param contract - Address of the contract to query.
+   * @param slot - Slot to query.
+   * @returns Storage value at the given contract slot.
+   * @throws If the contract is not deployed.
+   */ async getPublicStorageAt(blockNumber, contract, slot) {
+        const anchorBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+        if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
+        }
+        return await this.aztecNode.getPublicStorageAt(blockNumber, contract, slot);
+    }
+}