@aztec/pxe 3.0.0-nightly.20251216 → 3.0.0-nightly.20251217

package/src/storage/tagging_data_provider/sender_tagging_data_provider.ts

@@ -0,0 +1,244 @@
+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 { WINDOW_LEN as SENDER_TAGGING_INDEXES_SYNC_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 + SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN) {
+        throw new Error(
+          `Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex}.
+          Tagging window length ${SENDER_TAGGING_INDEXES_SYNC_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/constants.ts

@@ -1,2 +1,3 @@
 // Half the size of the window we slide over the tagging indexes.
+// TODO(#17775): Move this to the recipient log sync function once it's implemented in this directory.
 export const WINDOW_HALF_SIZE = 10;

package/src/tagging/sync/sync_sender_tagging_indexes.ts

@@ -0,0 +1,112 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+
+import type { SenderTaggingDataProvider } from '../../storage/tagging_data_provider/sender_tagging_data_provider.js';
+import { getStatusChangeOfPending } from './utils/get_status_change_of_pending.js';
+import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_tagging_indexes.js';
+
+// This window has to be as large as the largest expected number of logs emitted in a tx for a given directional app
+// tagging secret. If we get more tag indexes consumed than this window, an error is thrown in `PXE::proveTx` function.
+// This is set to a larger value than MAX_PRIVATE_LOGS_PER_TX (currently 64) because there could be more than
+// MAX_PRIVATE_LOGS_PER_TX indexes consumed in case the logs are squashed. This happens when the log contains a note
+// and the note is nullified in the same tx.
+//
+// Rationale for value 95:
+// - The `e2e_pending_note_hashes_contract` test's "Should handle overflowing the kernel data structures in nested
+//   calls" test case hits 95 tagging indexes emitted in a single transaction. This test creates and nullifies many
+//   notes recursively to test kernel reset circuit behavior, which causes logs to be squashed but still consume
+//   tagging indexes during the sync process. Since this is testing MAX_PRIVATE_LOGS_PER_TX overflow we can be
+//   reasonably certain that this value is large enough for standard use cases.
+// - This value is below MAX_RPC_LEN (100) which is the limit for array parameters in the JSON RPC schema for
+//   `getLogsByTags`. Any test that would perform sync over JSON RPC (not by having access to the Aztec node instance
+//   directly) would error out if that maximum was hit (docs_examples.test.ts is an example of this).
+export const WINDOW_LEN = 95;
+
+/**
+ * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
+ *
+ * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction of
+ * sender -> recipient matters.
+ * @param app - The address of the contract that the logs are tagged for. Needs to be provided because we perform
+ * second round of siloing in this function which is necessary because kernels do it as well (they silo first field
+ * of the private log which corresponds to the tag).
+ * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
+ * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
+ * is simply the highest pending index plus one (or finalized if pending is undefined).
+ * @dev This function looks for new indexes, adds them to pending, then it checks status of each pending index and
+ * updates its status accordingly.
+ */
+export async function syncSenderTaggingIndexes(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  aztecNode: AztecNode,
+  taggingDataProvider: SenderTaggingDataProvider,
+): Promise<void> {
+  // # Explanation of how syncing works
+  //
+  // When choosing an index, we select: highest pending index + 1 (or highest finalized index + 1 if no pending).
+  // If the chosen index is more than WINDOW_LEN from the highest finalized index, we throw an error. By having this
+  // hard limit we give a guarantee to a recipient that he doesn't need to look further than WINDOW_LEN ahead of the
+  // highest finalized index.
+  //
+  // This function synchronizes the finalized and pending indexes by iteratively querying the node for a window of
+  // indexes at a time, storing all those indexes as pending, and then checking the status of each pending index to
+  // update its finalization status accordingly. If we stumble upon a window with no indexes, we stop the loop.
+  //
+  // Stopping at that point is safe because of the limit described above - there can never be an index that is more
+  // than WINDOW_LEN from the highest finalized index.
+  //
+  // # Note on performance
+  // Each window advance requires two queries (logs + tx status). For example, syncing indexes 0–500 with a window of
+  // 100 takes at least 10 round trips (5 windows × 2 queries).
+
+  const finalizedIndex = await taggingDataProvider.getLastFinalizedIndex(secret);
+
+  let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
+  let end = start + WINDOW_LEN;
+
+  let previousFinalizedIndex = finalizedIndex;
+  let newFinalizedIndex = undefined;
+
+  while (true) {
+    // Load and store indexes for the current window. These indexes may already exist in the database if txs using
+    // them were previously sent from this PXE. Any duplicates are handled by the tagging data provider.
+    await loadAndStoreNewTaggingIndexes(secret, app, start, end, aztecNode, taggingDataProvider);
+
+    // Retrieve all indexes within the current window from storage and update their status accordingly.
+    const pendingTxHashes = await taggingDataProvider.getTxHashesOfPendingIndexes(secret, start, end);
+    if (pendingTxHashes.length === 0) {
+      break;
+    }
+
+    const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+
+    await taggingDataProvider.dropPendingIndexes(txHashesToDrop);
+    await taggingDataProvider.finalizePendingIndexes(txHashesToFinalize);
+
+    // We check if the finalized index has been updated.
+    newFinalizedIndex = await taggingDataProvider.getLastFinalizedIndex(secret);
+    if (previousFinalizedIndex !== newFinalizedIndex) {
+      // A new finalized index was found, so we'll run the loop again. For example:
+      // - Previous finalized index: 10
+      // - New finalized index: 13
+      // - Window length: 10
+      //
+      // In the last iteration, we processed indexes 11-20. To avoid reprocessing the same logs,
+      // we'll only look at the new indexes 21-23:
+      //
+      //    Previous window: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+      //    New window:                                             [21, 22, 23]
+
+      const previousEnd = end;
+      // Add 1 because `end` is exclusive and the known finalized index is not included in the window.
+      end = newFinalizedIndex! + WINDOW_LEN + 1;
+      start = previousEnd;
+      previousFinalizedIndex = newFinalizedIndex;
+    } else {
+      // No new finalized index was found, so we don't need to process the next window.
+      break;
+    }
+  }
+}

package/src/tagging/sync/utils/get_status_change_of_pending.ts

@@ -0,0 +1,44 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash, TxStatus } from '@aztec/stdlib/tx';
+
+/**
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
+ * dropped.
+ */
+export async function getStatusChangeOfPending(
+  pending: TxHash[],
+  aztecNode: AztecNode,
+): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
+  // Get receipts for all pending tx hashes and the finalized block number.
+  const [receipts, { finalized }] = await Promise.all([
+    Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash))),
+    aztecNode.getL2Tips(),
+  ]);
+
+  const txHashesToFinalize: TxHash[] = [];
+  const txHashesToDrop: TxHash[] = [];
+
+  for (let i = 0; i < receipts.length; i++) {
+    const receipt = receipts[i];
+    const txHash = pending[i];
+
+    if (receipt.status === TxStatus.SUCCESS && receipt.blockNumber && receipt.blockNumber <= finalized.number) {
+      // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
+      // finalized.
+      txHashesToFinalize.push(txHash);
+    } else if (
+      receipt.status === TxStatus.DROPPED ||
+      receipt.status === TxStatus.APP_LOGIC_REVERTED ||
+      receipt.status === TxStatus.TEARDOWN_REVERTED ||
+      receipt.status === TxStatus.BOTH_REVERTED
+    ) {
+      // Tx was dropped or reverted --> we drop the corresponding pending indexes.
+      // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
+      txHashesToDrop.push(txHash);
+    } else {
+      // Tx is still pending or the corresponding block is not yet finalized --> we don't do anything.
+    }
+  }
+
+  return { txHashesToFinalize, txHashesToDrop };
+}

package/src/tagging/sync/utils/load_and_store_new_tagging_indexes.ts

@@ -0,0 +1,74 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import type { SenderTaggingDataProvider } from '../../../storage/tagging_data_provider/sender_tagging_data_provider.js';
+import { SiloedTag } from '../../siloed_tag.js';
+import { Tag } from '../../tag.js';
+
+/**
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
+ * place is when a tx is being sent from this PXE.
+ * @param secret - The directional app tagging secret that's unique for (sender, recipient, contract) tuple.
+ * @param app - The address of the contract that the logs are tagged for. Used for siloing tags to match
+ * kernel circuit behavior.
+ * @param start - The starting index (inclusive) of the window to process.
+ * @param end - The ending index (exclusive) of the window to process.
+ * @param aztecNode - The Aztec node instance to query for logs.
+ * @param taggingDataProvider - The data provider to store pending indexes.
+ */
+export async function loadAndStoreNewTaggingIndexes(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  start: number,
+  end: number,
+  aztecNode: AztecNode,
+  taggingDataProvider: SenderTaggingDataProvider,
+) {
+  // We compute the tags for the current window of indexes
+  const preTagsForWindow: PreTag[] = Array(end - start)
+    .fill(0)
+    .map((_, i) => ({ secret, index: start + i }));
+  const siloedTagsForWindow = await Promise.all(
+    preTagsForWindow.map(async preTag => SiloedTag.compute(await Tag.compute(preTag), app)),
+  );
+
+  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode);
+  const highestIndexMap = getTxHighestIndexMap(txsForTags, preTagsForWindow);
+
+  // Now we iterate over the map, reconstruct the preTags and tx hash and store them in the db.
+  for (const [txHashStr, highestIndex] of highestIndexMap.entries()) {
+    const txHash = TxHash.fromString(txHashStr);
+    await taggingDataProvider.storePendingIndexes([{ secret, index: highestIndex }], txHash);
+  }
+}
+
+// Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
+// an array for each tag.
+async function getTxsContainingTags(tags: SiloedTag[], aztecNode: AztecNode): Promise<TxHash[][]> {
+  const tagsAsFr = tags.map(tag => tag.value);
+  const allLogs = await aztecNode.getLogsByTags(tagsAsFr);
+  return allLogs.map(logs => logs.filter(log => !log.isFromPublic).map(log => log.txHash));
+}
+
+// Returns a map of txHash to the highest index for that txHash.
+function getTxHighestIndexMap(txHashesForTags: TxHash[][], preTagsForWindow: PreTag[]): Map<string, number> {
+  if (txHashesForTags.length !== preTagsForWindow.length) {
+    throw new Error(
+      `Number of tx hashes arrays does not match number of pre-tags. ${txHashesForTags.length} !== ${preTagsForWindow.length}`,
+    );
+  }
+
+  const highestIndexMap = new Map<string, number>();
+  for (let i = 0; i < txHashesForTags.length; i++) {
+    const taggingIndex = preTagsForWindow[i].index;
+    const txHashesForTag = txHashesForTags[i];
+    for (const txHash of txHashesForTag) {
+      const key = txHash.toString();
+      highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+    }
+  }
+  return highestIndexMap;
+}

package/src/tagging/utils.ts

@@ -1,6 +1,7 @@
 import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 
-// TODO(benesjan): Make this return tags instead - this will moves some complexity from syncTaggedLogs
+// 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[] {
@@ -15,7 +16,7 @@ export function getPreTagsForTheWindow(
 
 /**
  * Creates a map from directional app tagging secret to initial index.
- * @param preTags - The pre tags to get the initial indexes map from.
+ * @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 }[]): {

package/dest/storage/sync_data_provider/index.d.ts

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

package/dest/storage/sync_data_provider/index.d.ts.map

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

package/dest/storage/sync_data_provider/index.js

@@ -1 +0,0 @@
-export { SyncDataProvider } from './sync_data_provider.js';

package/dest/storage/sync_data_provider/sync_data_provider.d.ts

@@ -1,11 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { BlockHeader } from '@aztec/stdlib/tx';
-export declare class SyncDataProvider {
-    #private;
-    constructor(store: AztecAsyncKVStore);
-    setHeader(header: BlockHeader): Promise<void>;
-    getBlockNumber(): Promise<BlockNumber>;
-    getBlockHeader(): Promise<BlockHeader>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19kYXRhX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9zeW5jX2RhdGFfcHJvdmlkZXIvc3luY19kYXRhX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUF1QixNQUFNLGlCQUFpQixDQUFDO0FBQzlFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxxQkFBYSxnQkFBZ0I7O0lBSTNCLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUduQztJQUVLLFNBQVMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFbEQ7SUFFSyxjQUFjLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQU8zQztJQUVLLGNBQWMsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLENBTzNDO0NBQ0YifQ==

package/dest/storage/sync_data_provider/sync_data_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/sync_data_provider/sync_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,gBAAgB;;IAI3B,YAAY,KAAK,EAAE,iBAAiB,EAGnC;IAEK,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAElD;IAEK,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAO3C;IAEK,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAO3C;CACF"}

package/dest/storage/tagging_data_provider/tagging_data_provider.d.ts

@@ -1,40 +0,0 @@
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-export declare class TaggingDataProvider {
-    #private;
-    constructor(store: AztecAsyncKVStore);
-    /**
-     * Sets the last used indexes when sending a log.
-     * @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
-     */
-    setLastUsedIndexesAsSender(preTags: PreTag[]): Promise<void[]>;
-    /**
-     * 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
-     */
-    setLastUsedIndexesAsRecipient(preTags: PreTag[]): Promise<void[]>;
-    /**
-     * Returns the last used index when sending a log with a given secret.
-     * @param secret - The directional app tagging secret.
-     * @returns The last used index for the given directional app tagging secret, or undefined if not found.
-     */
-    getLastUsedIndexesAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
-    /**
-     * Returns the last used indexes when looking for logs as a recipient.
-     * @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.
-     */
-    getLastUsedIndexesAsRecipient(secrets: DirectionalAppTaggingSecret[]): Promise<(number | undefined)[]>;
-    resetNoteSyncData(): Promise<void>;
-    addSenderAddress(address: AztecAddress): Promise<boolean>;
-    getSenderAddresses(): Promise<AztecAddress[]>;
-    removeSenderAddress(address: AztecAddress): Promise<boolean>;
-    getSize(): Promise<number>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19kYXRhX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS90YWdnaW5nX2RhdGFfcHJvdmlkZXIvdGFnZ2luZ19kYXRhX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RSxxQkFBYSxtQkFBbUI7O0lBUzlCLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQU9uQztJQUVEOzs7OztPQUtHO0lBQ0gsMEJBQTBCLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxtQkFNM0M7SUFFRDs7Ozs7T0FLRztJQUNILDZCQUE2QixDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsbUJBTTlDO0lBYUQ7Ozs7T0FJRztJQUNHLDBCQUEwQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVqRztJQUVEOzs7OztPQUtHO0lBQ0gsNkJBQTZCLENBQUMsT0FBTyxFQUFFLDJCQUEyQixFQUFFLEdBQUcsT0FBTyxDQUFDLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FFckc7SUFFRCxpQkFBaUIsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBT2pDO0lBRUssZ0JBQWdCLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBUTlEO0lBRUssa0JBQWtCLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBRWxEO0lBRUssbUJBQW1CLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBUWpFO0lBRUssT0FBTyxvQkFJWjtDQUNGIn0=

package/dest/storage/tagging_data_provider/tagging_data_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_data_provider/tagging_data_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE9E,qBAAa,mBAAmB;;IAS9B,YAAY,KAAK,EAAE,iBAAiB,EAOnC;IAED;;;;;OAKG;IACH,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,mBAM3C;IAED;;;;;OAKG;IACH,6BAA6B,CAAC,OAAO,EAAE,MAAM,EAAE,mBAM9C;IAaD;;;;OAIG;IACG,0BAA0B,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEjG;IAED;;;;;OAKG;IACH,6BAA6B,CAAC,OAAO,EAAE,2BAA2B,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAErG;IAED,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAOjC;IAEK,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ9D;IAEK,kBAAkB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAElD;IAEK,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQjE;IAEK,OAAO,oBAIZ;CACF"}