@aztec/pxe 0.0.1-commit.03f7ef2 → 0.0.1-commit.0b941701

package/src/storage/private_event_data_provider/private_event_data_provider.ts

@@ -1,162 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { EventSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
-import { type InTx, TxHash } from '@aztec/stdlib/tx';
-
-import type { PackedPrivateEvent } from '../../pxe.js';
-
-export type PrivateEventDataProviderFilter = {
-  contractAddress: AztecAddress;
-  fromBlock: number;
-  toBlock: number;
-  scopes: AztecAddress[];
-  txHash?: TxHash;
-};
-
-type PrivateEventEntry = {
-  msgContent: Buffer;
-  eventCommitmentIndex: number;
-  l2BlockNumber: number;
-  l2BlockHash: Buffer;
-  txHash: Buffer;
-};
-
-type PrivateEventMetadata = InTx & {
-  contractAddress: AztecAddress;
-  scope: AztecAddress;
-};
-
-/**
- * Stores decrypted private event logs.
- */
-export class PrivateEventDataProvider {
-  #store: AztecAsyncKVStore;
-  /** Array storing the actual private event log entries containing the log content and block number */
-  #eventLogs: AztecAsyncArray<PrivateEventEntry>;
-  /** Map from contract_address_scope_eventSelector to array of indices into #eventLogs for efficient lookup */
-  #eventLogIndex: AztecAsyncMap<string, number[]>;
-  /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
-  #seenLogs: AztecAsyncMap<number, boolean>;
-
-  logger = createLogger('private_event_data_provider');
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-    this.#eventLogs = this.#store.openArray('private_event_logs');
-    this.#eventLogIndex = this.#store.openMap('private_event_log_index');
-    this.#seenLogs = this.#store.openMap('seen_logs');
-  }
-
-  #keyFor(contractAddress: AztecAddress, scope: AztecAddress, eventSelector: EventSelector): string {
-    return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
-  }
-
-  /**
-   * Store a private event log.
-   * @param eventSelector - The event selector of the event.
-   * @param msgContent - The content of the event.
-   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
-   * @param metadata
-   *  contractAddress - The address of the contract that emitted the event.
-   *  scope - The address to which the event is scoped.
-   *  txHash - The transaction hash of the event log.
-   *  blockNumber - The block number in which the event was emitted.
-   */
-  storePrivateEventLog(
-    eventSelector: EventSelector,
-    msgContent: Fr[],
-    eventCommitmentIndex: number,
-    metadata: PrivateEventMetadata,
-  ): Promise<void> {
-    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
-
-    return this.#store.transactionAsync(async () => {
-      const key = this.#keyFor(contractAddress, scope, eventSelector);
-
-      // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
-      const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
-      if (hasBeenSeen) {
-        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), eventCommitmentIndex });
-        return;
-      }
-
-      this.logger.verbose('storing private event log', { contractAddress, scope, msgContent, l2BlockNumber });
-
-      const index = await this.#eventLogs.lengthAsync();
-      await this.#eventLogs.push({
-        msgContent: serializeToBuffer(msgContent),
-        l2BlockNumber,
-        l2BlockHash: l2BlockHash.toBuffer(),
-        eventCommitmentIndex,
-        txHash: txHash.toBuffer(),
-      });
-
-      const existingIndices = (await this.#eventLogIndex.getAsync(key)) || [];
-      await this.#eventLogIndex.set(key, [...existingIndices, index]);
-
-      // Mark this log as seen using eventCommitmentIndex
-      await this.#seenLogs.set(eventCommitmentIndex, true);
-    });
-  }
-
-  /**
-   * Returns the private events given search parameters.
-   * @param eventSelector - The event selector to filter by.
-   * @param filter - Filtering criteria:
-   *  contractAddress: The address of the contract to get events from.
-   *  fromBlock: The block number to search from (inclusive).
-   *  toBlock: The block number to search upto (exclusive).
-   *  scope: - The addresses that decrypted the logs.
-   * @returns - The event log contents, augmented with metadata about
-   *  the transaction and block it the event was included in .
-   */
-  public async getPrivateEvents(
-    eventSelector: EventSelector,
-    filter: PrivateEventDataProviderFilter,
-  ): Promise<PackedPrivateEvent[]> {
-    const events: Array<{ eventCommitmentIndex: number; event: PackedPrivateEvent }> = [];
-
-    for (const scope of filter.scopes) {
-      const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
-      const indices = (await this.#eventLogIndex.getAsync(key)) || [];
-
-      for (const index of indices) {
-        const entry = await this.#eventLogs.atAsync(index);
-        if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
-          continue;
-        }
-
-        // Convert buffer back to Fr array
-        const reader = BufferReader.asReader(entry.msgContent);
-        const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
-        const msgContent = reader.readArray(numFields, Fr);
-        const txHash = TxHash.fromBuffer(entry.txHash);
-        const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
-
-        if (filter.txHash && !txHash.equals(filter.txHash)) {
-          continue;
-        }
-
-        events.push({
-          eventCommitmentIndex: entry.eventCommitmentIndex,
-          event: {
-            packedEvent: msgContent,
-            l2BlockNumber: BlockNumber(entry.l2BlockNumber),
-            txHash,
-            l2BlockHash,
-            eventSelector,
-          },
-        });
-      }
-    }
-
-    // Sort by eventCommitmentIndex only
-    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
-    return events.map(ev => ev.event);
-  }
-}

package/src/storage/tagging_data_provider/index.ts

@@ -1,2 +0,0 @@
-export { SenderTaggingDataProvider } from './sender_tagging_data_provider.js';
-export { RecipientTaggingDataProvider } from './recipient_tagging_data_provider.js';

package/src/storage/tagging_data_provider/recipient_tagging_data_provider.ts

@@ -1,86 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-
-/**
- * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class is
- * called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
- * the algorithms are completely disjoint and there is not data reuse between the 2.
- */
-export class RecipientTaggingDataProvider {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  // Stores the last used index for each directional app tagging secret.
-  #lastUsedIndexes: AztecAsyncMap<string, number>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-    this.#lastUsedIndexes = this.#store.openMap('last_used_indexes');
-  }
-
-  /**
-   * Sets the last used indexes when looking for logs.
-   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
-   * updated in the db.
-   * @throws If any two pre-tags contain the same directional app tagging secret
-   */
-  setLastUsedIndexes(preTags: PreTag[]) {
-    // Non-unique secrets would indicate a bug in the caller function.
-    const secretsSet = new Set(preTags.map(preTag => preTag.secret.toString()));
-    if (secretsSet.size !== preTags.length) {
-      throw new Error(`Duplicate secrets found when setting last used indexes`);
-    }
-
-    return Promise.all(preTags.map(({ secret, index }) => this.#lastUsedIndexes.set(secret.toString(), index)));
-  }
-
-  /**
-   * Returns the last used indexes when looking for logs.
-   * @param secrets - The directional app tagging secrets to obtain the indexes for.
-   * @returns The last used indexes for the given directional app tagging secrets, or undefined if have never yet found
-   * a log for a given secret.
-   */
-  getLastUsedIndexes(secrets: DirectionalAppTaggingSecret[]): Promise<(number | undefined)[]> {
-    return Promise.all(secrets.map(secret => this.#lastUsedIndexes.getAsync(secret.toString())));
-  }
-
-  resetNoteSyncData(): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      const keys = await toArray(this.#lastUsedIndexes.keysAsync());
-      await Promise.all(keys.map(secret => this.#lastUsedIndexes.delete(secret)));
-    });
-  }
-
-  // It might seem weird that the following 3 methods are in RecipientTaggingDataProvider and not
-  // in SenderTaggingDataProvider but that is because this data is truly only used for the purposes of syncing logs
-  // as a recipient. When sending logs or when syncing sender tagging indexes we only receive directional app tagging
-  // secret from Aztec.nr via an oracle and we don't need to access sender addresses.
-
-  async addSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (await this.#addressBook.hasAsync(address.toString())) {
-      return false;
-    }
-
-    await this.#addressBook.set(address.toString(), true);
-
-    return true;
-  }
-
-  async getSenderAddresses(): Promise<AztecAddress[]> {
-    return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-  }
-
-  async removeSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (!(await this.#addressBook.hasAsync(address.toString()))) {
-      return false;
-    }
-
-    await this.#addressBook.delete(address.toString());
-
-    return true;
-  }
-}

package/src/tagging/recipient_sync/new_recipient_tagging_data_provider.ts

@@ -1,53 +0,0 @@
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
-
-/**
- * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
- * is called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
- * the algorithms are completely disjoint and there is not data reuse between the two.
- *
- * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
- * blocks, which by definition cannot be affected by reorgs.
- *
- * TODO(benesjan): Rename as to RecipientTaggingDataProvider and relocate once the old tagging sync is purged.
- */
-export class NewRecipientTaggingDataProvider {
-  #store: AztecAsyncKVStore;
-
-  #highestAgedIndex: AztecAsyncMap<string, number>;
-  #highestFinalizedIndex: AztecAsyncMap<string, number>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
-    this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
-  }
-
-  getHighestAgedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
-    return this.#highestAgedIndex.getAsync(secret.toString());
-  }
-
-  async updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
-    const currentIndex = await this.#highestAgedIndex.getAsync(secret.toString());
-    if (currentIndex !== undefined && index <= currentIndex) {
-      // Log sync should never set a lower highest aged index.
-      throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
-    }
-    await this.#highestAgedIndex.set(secret.toString(), index);
-  }
-
-  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
-    return this.#highestFinalizedIndex.getAsync(secret.toString());
-  }
-
-  async updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
-    const currentIndex = await this.#highestFinalizedIndex.getAsync(secret.toString());
-    if (currentIndex !== undefined && index < currentIndex) {
-      // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
-      // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
-      throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
-    }
-    await this.#highestFinalizedIndex.set(secret.toString(), index);
-  }
-}

package/src/tagging/utils.ts

@@ -1,32 +0,0 @@
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-
-// TODO(#17775): If this does not get dropped when implementing the linked issue make this return tags instead. This
-// will move some complexity from syncTaggedLogs to here.
-export function getPreTagsForTheWindow(
-  secretsAndWindows: { secret: DirectionalAppTaggingSecret; leftMostIndex: number; rightMostIndex: number }[],
-): PreTag[] {
-  const secrets = [];
-  for (const secretAndWindow of secretsAndWindows) {
-    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
-      secrets.push({ secret: secretAndWindow.secret, index: i });
-    }
-  }
-  return secrets;
-}
-
-/**
- * Creates a map from directional app tagging secret to initial index.
- * @param preTags - The pre-tags to get the initial indexes map from.
- * @returns The map from directional app tagging secret to initial index.
- */
-export function getInitialIndexesMap(preTags: { secret: DirectionalAppTaggingSecret; index: number | undefined }[]): {
-  [k: string]: number;
-} {
-  const initialIndexes: { [k: string]: number } = {};
-
-  for (const preTag of preTags) {
-    initialIndexes[preTag.secret.toString()] = preTag.index ?? 0;
-  }
-
-  return initialIndexes;
-}

package/src/tree_membership/tree_membership_service.ts

@@ -1,112 +0,0 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { SiblingPath } from '@aztec/foundation/trees';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockParameter } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
-import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-
-import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
-
-export class TreeMembershipService {
-  constructor(
-    private readonly aztecNode: AztecNode,
-    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
-  ) {}
-
-  /**
-   * Gets the index of a nullifier in the nullifier tree.
-   * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
-   */
-  public getNullifierIndex(nullifier: Fr) {
-    return this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
-  }
-
-  /**
-   * Fetches the index and sibling path of a leaf at a given block from a given tree.
-   * @param blockNumber - The block number at which to get the membership witness.
-   * @param treeId - Id of the tree to get the sibling path from.
-   * @param leafValue - The leaf value
-   * @returns The index and sibling path concatenated [index, sibling_path]
-   */
-  public async getMembershipWitness(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    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;
-  }
-
-  /**
-   * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
-   * @param nullifier - Nullifier we try to find the low nullifier witness for.
-   * @returns The low nullifier membership witness (if found).
-   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
-   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
-   * we are trying to prove non-inclusion for.
-   */
-  public async getLowNullifierMembershipWitness(
-    blockNumber: BlockParameter,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    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 this.aztecNode.getLowNullifierMembershipWitness(blockNumber, nullifier);
-  }
-
-  /**
-   * Returns a witness for a given slot of the public data tree at a given block.
-   * @param blockNumber - The block number at which to get the witness.
-   * @param leafSlot - The slot of the public data in the public data tree.
-   */
-  public async getPublicDataWitness(blockNumber: BlockParameter, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    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.getPublicDataWitness(blockNumber, leafSlot);
-  }
-
-  /**
-   * Looks for the L1 to L2 membership witness of a message at the Aztec node, given its hash.
-   * @param contractAddress - Address of a contract by which the message was emitted.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages.
-   * The message nullifier is computed locally, so the secret is not sent to the node.
-   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */
-  public getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-    return getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
-  }
-
-  async #tryGetMembershipWitness(
-    blockNumber: BlockParameter,
-    treeId: MerkleTreeId,
-    value: Fr,
-  ): Promise<Fr[] | undefined> {
-    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 #findLeafIndex(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
-    const [leafIndex] = await this.aztecNode.findLeavesIndexes(blockNumber, treeId, [leafValue]);
-    return leafIndex?.data;
-  }
-}