@aztec/pxe 0.0.1-commit.03f7ef2 → 0.0.1-commit.0658669b3

package/src/storage/tagging_data_provider/sender_tagging_data_provider.ts

@@ -1,244 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-import { TxHash } from '@aztec/stdlib/tx';
-
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/sync/sync_sender_tagging_indexes.js';
-
-/**
- * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
- * is called RecipientTaggingDataProvider. 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.
- */
-export class SenderTaggingDataProvider {
-  #store: AztecAsyncKVStore;
-
-  // Stores the pending indexes for each directional app tagging secret. Pending here means that the tx that contained
-  // the private logs with tags corresponding to these indexes has not been finalized yet.
-  //
-  // We don't store just the highest index because if their transaction is dropped we'd then need the information about
-  // the lower pending indexes. For each secret-tx pair however we only store the largest index used in that tx, since
-  // the smaller ones are irrelevant due to tx atomicity.
-  //
-  // TODO(#17615): This assumes no logs are used in the non-revertible phase.
-  #pendingIndexes: AztecAsyncMap<string, { index: number; txHash: string }[]>;
-
-  // Stores the last (highest) finalized index for each directional app tagging secret. We care only about the last
-  // index because unlike the pending indexes, it will never happen that a finalized index would be removed and hence
-  // we don't need to store the history.
-  #lastFinalizedIndexes: AztecAsyncMap<string, number>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#pendingIndexes = this.#store.openMap('pending_indexes');
-    this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
-  }
-
-  /**
-   * Stores pending indexes.
-   * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
-   * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
-   * pending indexes already stored from previous syncs.
-   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
-   * stored in the db.
-   * @param txHash - The tx in which the pretags were used in private logs.
-   * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
-   * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
-   * bugs.
-   * @throws If the newly stored pending index is further than window length from the highest finalized index for the
-   * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
-   * window length ahead of the highest finalized index.
-   * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
-   * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
-   * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
-   * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
-   * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
-   * indexes than finalized ones.
-   */
-  async storePendingIndexes(preTags: PreTag[], txHash: TxHash) {
-    // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
-    // pair. Below we check that this is the case.
-    const secretsSet = new Set(preTags.map(preTag => preTag.secret.toString()));
-    if (secretsSet.size !== preTags.length) {
-      throw new Error(`Duplicate secrets found when storing pending indexes`);
-    }
-
-    for (const { secret, index } of preTags) {
-      // First we check that for any secret the highest used index in tx is not further than window length from
-      // the highest finalized index.
-      const finalizedIndex = (await this.getLastFinalizedIndex(secret)) ?? 0;
-      if (index > finalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
-        throw new Error(
-          `Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex}.
-          Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
-          to increase it!`,
-        );
-      }
-
-      // Throw if the new pending index is lower than or equal to the last finalized index
-      const secretStr = secret.toString();
-      const lastFinalizedIndex = await this.#lastFinalizedIndexes.getAsync(secretStr);
-      if (lastFinalizedIndex !== undefined && index <= lastFinalizedIndex) {
-        throw new Error(
-          `Cannot store pending index ${index} for secret ${secretStr}: ` +
-            `it is lower than or equal to the last finalized index ${lastFinalizedIndex}`,
-        );
-      }
-
-      // Check if this secret + txHash combination already exists
-      const txHashStr = txHash.toString();
-      const existingForSecret = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
-      const existingForSecretAndTx = existingForSecret.find(entry => entry.txHash === txHashStr);
-
-      if (existingForSecretAndTx) {
-        // If it exists with a different index, throw an error
-        if (existingForSecretAndTx.index !== index) {
-          throw new Error(
-            `Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` +
-              `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`,
-          );
-        }
-        // If it exists with the same index, ignore the update (no-op)
-      } else {
-        // If it doesn't exist, add it
-        await this.#pendingIndexes.set(secretStr, [...existingForSecret, { index, txHash: txHashStr }]);
-      }
-    }
-  }
-
-  /**
-   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
-   * for a given directional app tagging secret.
-   * @param secret - The directional app tagging secret to query pending indexes for.
-   * @param startIndex - The lower bound of the index range (inclusive).
-   * @param endIndex - The upper bound of the index range (exclusive).
-   * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
-   * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
-   */
-  async getTxHashesOfPendingIndexes(
-    secret: DirectionalAppTaggingSecret,
-    startIndex: number,
-    endIndex: number,
-  ): Promise<TxHash[]> {
-    const existing = (await this.#pendingIndexes.getAsync(secret.toString())) ?? [];
-    const txHashes = existing
-      .filter(entry => entry.index >= startIndex && entry.index < endIndex)
-      .map(entry => entry.txHash);
-    return Array.from(new Set(txHashes)).map(TxHash.fromString);
-  }
-
-  /**
-   * Returns the last (highest) finalized index for a given secret.
-   * @param secret - The secret to get the last finalized index for.
-   * @returns The last (highest) finalized index for the given secret.
-   */
-  getLastFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
-    return this.#lastFinalizedIndexes.getAsync(secret.toString());
-  }
-
-  /**
-   * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
-   * indexes.
-   * @param secret - The directional app tagging secret to query the last used index for.
-   * @returns The last used index.
-   */
-  async getLastUsedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
-    const secretStr = secret.toString();
-    const pendingTxScopedIndexes = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
-    const pendingIndexes = pendingTxScopedIndexes.map(entry => entry.index);
-
-    if (pendingTxScopedIndexes.length === 0) {
-      return this.#lastFinalizedIndexes.getAsync(secretStr);
-    }
-
-    // As the last used index we return the highest one from the pending indexes. Note that this value will be always
-    // higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
-    return Math.max(...pendingIndexes);
-  }
-
-  /**
-   * Drops all pending indexes corresponding to the given transaction hashes.
-   */
-  async dropPendingIndexes(txHashes: TxHash[]) {
-    if (txHashes.length === 0) {
-      return;
-    }
-
-    const txHashStrs = new Set<string>(txHashes.map(txHash => txHash.toString()));
-    const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
-
-    for (const secret of allSecrets) {
-      const pendingData = await this.#pendingIndexes.getAsync(secret);
-      if (pendingData) {
-        const filtered = pendingData.filter(item => !txHashStrs.has(item.txHash));
-        if (filtered.length === 0) {
-          await this.#pendingIndexes.delete(secret);
-        } else if (filtered.length !== pendingData.length) {
-          // Some items were filtered out, so update the pending data
-          await this.#pendingIndexes.set(secret, filtered);
-        }
-        // else: No items were filtered out (txHashes not found for this secret) --> no-op
-      }
-    }
-  }
-
-  /**
-   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
-   * indexes.
-   */
-  async finalizePendingIndexes(txHashes: TxHash[]) {
-    if (txHashes.length === 0) {
-      return;
-    }
-
-    for (const txHash of txHashes) {
-      const txHashStr = txHash.toString();
-
-      const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
-
-      for (const secret of allSecrets) {
-        const pendingData = await this.#pendingIndexes.getAsync(secret);
-        if (!pendingData) {
-          continue;
-        }
-
-        const matchingIndexes = pendingData.filter(item => item.txHash === txHashStr).map(item => item.index);
-        if (matchingIndexes.length === 0) {
-          continue;
-        }
-
-        if (matchingIndexes.length > 1) {
-          // We should always just store the highest pending index for a given tx hash and secret because the lower
-          // values are irrelevant.
-          throw new Error(`Multiple pending indexes found for tx hash ${txHashStr} and secret ${secret}`);
-        }
-
-        let lastFinalized = await this.#lastFinalizedIndexes.getAsync(secret);
-        const newFinalized = matchingIndexes[0];
-
-        if (newFinalized < (lastFinalized ?? 0)) {
-          // This should never happen because when last finalized index was finalized we should have pruned the lower
-          // pending indexes.
-          throw new Error(
-            `New finalized index ${newFinalized} is smaller than the current last finalized index ${lastFinalized}`,
-          );
-        }
-
-        await this.#lastFinalizedIndexes.set(secret, newFinalized);
-        lastFinalized = newFinalized;
-
-        // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
-        // cannot control the order in which transactions are finalized, there may be pending indexes that are now
-        // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
-        // outdated pending indexes.
-        const remainingItemsOfHigherIndex = pendingData.filter(item => item.index > (lastFinalized ?? 0));
-        if (remainingItemsOfHigherIndex.length === 0) {
-          await this.#pendingIndexes.delete(secret);
-        } else {
-          await this.#pendingIndexes.set(secret, remainingItemsOfHigherIndex);
-        }
-      }
-    }
-  }
-}

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;
-  }
-}