@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/events/event_service.ts

@@ -0,0 +1,77 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
+
+export class EventService {
+  constructor(
+    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly aztecNode: AztecNode,
+    private readonly privateEventDataProvider: PrivateEventDataProvider,
+  ) {}
+
+  public async deliverEvent(
+    contractAddress: AztecAddress,
+    selector: EventSelector,
+    content: Fr[],
+    eventCommitment: Fr,
+    txHash: TxHash,
+    scope: AztecAddress,
+  ): Promise<void> {
+    // 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 [syncedBlockHeader, siloedEventCommitment, txEffect] = await Promise.all([
+      this.anchorBlockDataProvider.getBlockHeader(),
+      siloNullifier(contractAddress, eventCommitment),
+      this.aztecNode.getTxEffect(txHash),
+    ]);
+
+    const syncedBlockNumber = syncedBlockHeader.getBlockNumber();
+
+    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(
+      selector,
+      content,
+      Number(nullifierIndex.data), // Index of the event commitment in the nullifier tree
+      {
+        contractAddress,
+        scope,
+        txHash,
+        l2BlockNumber: nullifierIndex.l2BlockNumber, // Block number in which the event was emitted
+        l2BlockHash: nullifierIndex.l2BlockHash, // Block hash in which the event was emitted
+      },
+    );
+  }
+}

package/src/events/index.ts

@@ -0,0 +1 @@
+export * from './private_event_filter_validator.js';

package/src/events/private_event_filter_validator.ts

@@ -0,0 +1,48 @@
+import type { PrivateEventFilter } from '@aztec/aztec.js/wallet';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+
+import { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import type { PrivateEventDataProviderFilter } from '../storage/private_event_data_provider/private_event_data_provider.js';
+
+export class PrivateEventFilterValidator {
+  constructor(private anchorBlockDataProvider: AnchorBlockDataProvider) {}
+
+  async validate(filter: PrivateEventFilter): Promise<PrivateEventDataProviderFilter> {
+    let { fromBlock, toBlock } = filter;
+
+    // Block range filters in Aztec Node are defined as closed-open intervals [fromBlock, toBlock), so
+    // we respect that convention here for consistency.
+    // We then default to [INITIAL_L2_BLOCK_NUM, latestKnownBlock + 1), ie: by default return events from
+    // the first block to the latest known block.
+    if (!fromBlock || !toBlock) {
+      const lastKnownBlock = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+      fromBlock = fromBlock ?? BlockNumber(INITIAL_L2_BLOCK_NUM);
+      toBlock = toBlock ?? BlockNumber(lastKnownBlock + 1);
+    }
+
+    if (filter.scopes.length === 0) {
+      throw new Error('At least one scope is required to get private events');
+    }
+
+    if (fromBlock < 1) {
+      throw new Error('fromBlock must be greater than or equal to 1');
+    }
+
+    if (toBlock < 1) {
+      throw new Error('toBlock must be greater than or equal to 1');
+    }
+
+    if (fromBlock >= toBlock) {
+      throw new Error('toBlock must be strictly greater than fromBlock');
+    }
+
+    return {
+      contractAddress: filter.contractAddress,
+      scopes: filter.scopes,
+      txHash: filter.txHash,
+      toBlock,
+      fromBlock,
+    };
+  }
+}

package/src/logs/log_service.ts

@@ -0,0 +1,364 @@
+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 { CompleteAddress } from '@aztec/stdlib/contract';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import {
+  DirectionalAppTaggingSecret,
+  PendingTaggedLog,
+  PrivateLogWithTxData,
+  PublicLogWithTxData,
+  SiloedTag,
+  Tag,
+  TxScopedL2Log,
+} 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';
+import { WINDOW_HALF_SIZE } from '../tagging/constants.js';
+import { getInitialIndexesMap, getPreTagsForTheWindow } from '../tagging/utils.js';
+
+export class LogService {
+  constructor(
+    private readonly aztecNode: AztecNode,
+    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly keyStore: KeyStore,
+    private readonly capsuleDataProvider: CapsuleDataProvider,
+    private readonly recipientTaggingDataProvider: RecipientTaggingDataProvider,
+    private readonly addressDataProvider: AddressDataProvider,
+  ) {}
+
+  public async bulkRetrieveLogs(logRetrievalRequests: LogRetrievalRequest[]): Promise<(LogRetrievalResponse | null)[]> {
+    return await Promise.all(
+      logRetrievalRequests.map(async request => {
+        // TODO(F-231): remove these internal functions and have node endpoints that do this instead
+        const [publicLog, privateLog] = await Promise.all([
+          this.getPublicLogByTag(request.tag, request.contractAddress),
+          this.getPrivateLogByTag(await SiloedTag.compute(request.tag, request.contractAddress)),
+        ]);
+
+        if (publicLog !== null) {
+          if (privateLog !== null) {
+            throw new Error(
+              `Found both a public and private log when searching for tag ${request.tag} 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(F-231): delete this function and implement this behavior in the node instead
+  public async getPublicLogByTag(tag: Tag, contractAddress: AztecAddress): Promise<PublicLogWithTxData | null> {
+    const logs = await this.aztecNode.getPublicLogsByTagsFromContract(contractAddress, [tag]);
+    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(F-231): delete this function and implement this behavior in the node instead
+  public async getPrivateLogByTag(siloedTag: SiloedTag): Promise<PrivateLogWithTxData | null> {
+    const logs = await this.aztecNode.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(#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.
+  public async syncTaggedLogs(
+    contractAddress: AztecAddress,
+    pendingTaggedLogArrayBaseSlot: Fr,
+    scopes?: AztecAddress[],
+  ) {
+    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: { [k: string]: number } = {};
+
+      // 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: { [k: string]: number } = {};
+
+        // Fetch the private logs for the tags and iterate over them
+        const logsByTags = await this.aztecNode.getPrivateLogsByTags(tagsForTheWholeWindow);
+
+        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.
+   */
+  protected async getLastUsedTaggingIndexesForSenders(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<{ secret: DirectionalAppTaggingSecret; index: number | undefined }[]> {
+    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: AztecAddress,
+    capsuleArrayBaseSlot: Fr,
+    recipient: AztecAddress,
+    privateLogs: TxScopedL2Log[],
+  ) {
+    // 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: AztecAddress): Promise<CompleteAddress> {
+    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/src/notes/index.ts

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