@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/src/storage/tagging_store/sender_address_book_store.ts

@@ -1,42 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-/**
- * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
- * to derive directional app tagging secrets that are then used to sync the logs.
- */
-export class SenderAddressBookStore {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-  }
-
-  async addSender(address: AztecAddress): Promise<boolean> {
-    if (await this.#addressBook.hasAsync(address.toString())) {
-      return false;
-    }
-
-    await this.#addressBook.set(address.toString(), true);
-
-    return true;
-  }
-
-  async getSenders(): Promise<AztecAddress[]> {
-    return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-  }
-
-  async removeSender(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/load_private_logs_for_sender_recipient_pair.ts

@@ -1,133 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
-
-import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { findHighestIndexes } from './utils/find_highest_indexes.js';
-import { loadLogsForRange } from './utils/load_logs_for_range.js';
-
-/**
- * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
- * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
- *
- * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
- * in the tagging data provider is indexed by the secret and hence completely disjoint.
- */
-export async function loadPrivateLogsForSenderRecipientPair(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
-  aztecNode: AztecNode,
-  taggingStore: RecipientTaggingStore,
-  anchorBlockNumber: BlockNumber,
-  jobId: string,
-): Promise<TxScopedL2Log[]> {
-  // # Explanation of how the algorithm works
-  // When we perform the sync we will look at logs that correspond to the tagging index range
-  // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
-  //
-  // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
-  //                  `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds ago.
-  // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
-  //
-  // "(" denotes an open end of the range - the index is not included in the range.
-  // "]" denotes a closed end of the range - the index is included in the range.
-  //
-  // ## Explanation of highestAgedIndex
-  //
-  // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
-  // ever appear.
-  //
-  // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
-  // - a transaction's maximum inclusion timestamp is at most `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds after
-  //   the timestamp of its anchor block; and
-  // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
-  //
-  // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
-  // least `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds in the past. Then there is no possibility of any *other* device
-  // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
-  // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
-  // chosen a larger index.
-  //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
-  // because it would already have been expired.
-  //
-  // Therefore, once we see that index `I` has been used in a block that is at least `MAX_INCLUDE_BY_TIMESTAMP_DURATION`
-  // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
-  //
-  // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
-  //
-  // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
-  // the highest finalized index. If that index was already used, they will throw an error. For this reason we
-  // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
-
-  let finalizedBlockNumber: number, currentTimestamp: bigint;
-  {
-    const [l2Tips, latestBlockHeader] = await Promise.all([aztecNode.getL2Tips(), aztecNode.getBlockHeader('latest')]);
-
-    if (!latestBlockHeader) {
-      throw new Error('Node failed to return latest block header when syncing logs');
-    }
-
-    [finalizedBlockNumber, currentTimestamp] = [
-      l2Tips.finalized.block.number,
-      latestBlockHeader.globalVariables.timestamp,
-    ];
-  }
-
-  let start: number, end: number;
-  {
-    const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
-    const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-
-    // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
-    start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
-
-    // The highest index a sender can choose is "highest finalized index + window length" but given that
-    // `loadLogsForRange` expects an exclusive `end` we add 1.
-    end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
-  }
-
-  const logs: TxScopedL2Log[] = [];
-
-  while (true) {
-    // Get private logs with their block timestamps and corresponding tagging indexes
-    const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber);
-
-    if (privateLogsWithIndexes.length === 0) {
-      break;
-    }
-
-    logs.push(...privateLogsWithIndexes.map(({ log }) => log));
-
-    const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(
-      privateLogsWithIndexes,
-      currentTimestamp,
-      finalizedBlockNumber,
-    );
-
-    // Store updates in data provider and update local variables
-    if (highestAgedIndex !== undefined) {
-      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
-    }
-
-    if (highestFinalizedIndex === undefined) {
-      // We have not found a new highest finalized index, so there is no need to move the window forward.
-      break;
-    }
-
-    if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
-      // This is just a sanity check as this should never happen.
-      throw new Error('Highest aged index lower than highest finalized index invariant violated');
-    }
-
-    await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex, jobId);
-
-    // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
-    // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
-    start = end;
-    end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
-  }
-
-  return logs;
-}

package/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -1,43 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
-import { SiloedTag, Tag } from '@aztec/stdlib/logs';
-
-/**
- * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
- * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
- * exclusive.
- */
-export async function loadLogsForRange(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
-  aztecNode: AztecNode,
-  start: number,
-  end: number,
-  anchorBlockNumber: BlockNumber,
-): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
-  // Derive tags for the window
-  const preTags: PreTag[] = Array(end - start)
-    .fill(0)
-    .map((_, i) => ({ secret, index: start + i }));
-  const siloedTags = await Promise.all(preTags.map(preTag => Tag.compute(preTag))).then(tags =>
-    Promise.all(tags.map(tag => SiloedTag.compute(tag, app))),
-  );
-
-  const logs = await aztecNode.getPrivateLogsByTags(siloedTags);
-
-  // Pair logs with their corresponding tagging indexes
-  const logsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }> = [];
-  for (let i = 0; i < logs.length; i++) {
-    const logsForTag = logs[i];
-    const taggingIndex = preTags[i].index;
-    for (const log of logsForTag) {
-      if (log.blockNumber <= anchorBlockNumber) {
-        logsWithIndexes.push({ log, taggingIndex });
-      }
-    }
-  }
-
-  return logsWithIndexes;
-}

package/src/tree_membership/tree_membership_service.ts

@@ -1,97 +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 { L2BlockHash } 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';
-
-// TODO: REmove this class as it no longer seems valuable. The only somewhat real functionality in this class is in
-// the `getMembershipWitness` method that is used by `utilityGetMembershipWitness` oracle by then in Aztec.nr we
-// have helper functions around that oracle for archive and note hash tree and the generic method itself is not used
-// anywhere else - make sense to just have simple specific handlers for the archive and note hash trees and drop this.
-export class TreeMembershipService {
-  constructor(private readonly aztecNode: AztecNode) {}
-
-  /**
-   * 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 async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
-    const [leafIndex] = await this.aztecNode.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [nullifier]);
-    return leafIndex?.data;
-  }
-
-  /**
-   * Fetches the index and sibling path of a leaf at a given block from a given tree.
-   * @param blockHash - The block hash 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(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    const witness = await this.#tryGetMembershipWitness(blockHash, treeId, leafValue);
-    if (!witness) {
-      throw new Error(
-        `Leaf value ${leafValue} not found in tree ${MerkleTreeId[treeId]} at block hash ${blockHash.toString()}`,
-      );
-    }
-    return witness;
-  }
-
-  /**
-   * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param blockHash - The block hash 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 getLowNullifierMembershipWitness(
-    blockHash: L2BlockHash,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    return this.aztecNode.getLowNullifierMembershipWitness(blockHash, nullifier);
-  }
-
-  /**
-   * Returns a witness for a given slot of the public data tree at a given block.
-   * @param blockHash - The block hash at which to get the witness.
-   * @param leafSlot - The slot of the public data in the public data tree.
-   */
-  public getPublicDataWitness(blockHash: L2BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    return this.aztecNode.getPublicDataWitness(blockHash, 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(blockHash: L2BlockHash, treeId: MerkleTreeId, value: Fr): Promise<Fr[] | undefined> {
-    switch (treeId) {
-      case MerkleTreeId.NULLIFIER_TREE:
-        return (await this.aztecNode.getNullifierMembershipWitness(blockHash, value))?.withoutPreimage().toFields();
-      case MerkleTreeId.NOTE_HASH_TREE:
-        return (await this.aztecNode.getNoteHashMembershipWitness(blockHash, value))?.toFields();
-      case MerkleTreeId.PUBLIC_DATA_TREE:
-        return (await this.aztecNode.getPublicDataWitness(blockHash, value))?.withoutPreimage().toFields();
-      case MerkleTreeId.ARCHIVE:
-        return (await this.aztecNode.getArchiveMembershipWitness(blockHash, value))?.toFields();
-      default:
-        throw new Error('Not implemented');
-    }
-  }
-}