@aztec/pxe 0.0.1-commit.6d3c34e → 0.0.1-commit.7035c9bd6

package/src/tagging/get_all_logs_by_tags.ts

@@ -0,0 +1,92 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import { MAX_LOGS_PER_TAG, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
+
+/**
+ * Generic pagination helper that fetches all pages of results.
+ * @param numTags - The number of tags being queried (determines result array size).
+ * @param fetchPage - Function that fetches a single page of results given a page number.
+ * @returns An array of arrays, one per tag, containing all results across all pages.
+ */
+async function getAllPages<T>(numTags: number, fetchPage: (page: number) => Promise<T[][]>): Promise<T[][]> {
+  const allResultsPerTag: T[][] = Array.from({ length: numTags }, () => []);
+  let page = 0;
+  let hasMore = true;
+
+  while (hasMore) {
+    const resultsPage = await fetchPage(page);
+    hasMore = false;
+
+    for (let i = 0; i < resultsPage.length; i++) {
+      allResultsPerTag[i].push(...resultsPage[i]);
+      if (resultsPage[i].length === MAX_LOGS_PER_TAG) {
+        hasMore = true;
+      }
+    }
+    page++;
+  }
+
+  return allResultsPerTag;
+}
+
+/**
+ * Splits tags into chunks of MAX_RPC_LEN, fetches logs for each chunk using getAllPages, then stitches the results
+ * back into a single array preserving the original tag order.
+ */
+async function getAllPagesInBatches<Tag, T>(
+  tags: Tag[],
+  fetchAllPagesForBatch: (batch: Tag[]) => Promise<T[][]>,
+): Promise<T[][]> {
+  if (tags.length <= MAX_RPC_LEN) {
+    return fetchAllPagesForBatch(tags);
+  }
+
+  const batches: Tag[][] = [];
+  for (let i = 0; i < tags.length; i += MAX_RPC_LEN) {
+    batches.push(tags.slice(i, i + MAX_RPC_LEN));
+  }
+  const batchResults = await Promise.all(batches.map(fetchAllPagesForBatch));
+  return batchResults.flat();
+}
+
+/**
+ * Fetches all private logs for the given tags, automatically paginating through all pages.
+ * @param aztecNode - The Aztec node to query.
+ * @param tags - The siloed tags to search for.
+ * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
+ * because of reorgs).
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export function getAllPrivateLogsByTags(
+  aztecNode: AztecNode,
+  tags: SiloedTag[],
+  anchorBlockHash: BlockHash,
+): Promise<TxScopedL2Log[][]> {
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page => aztecNode.getPrivateLogsByTags(batch, page, anchorBlockHash)),
+  );
+}
+
+/**
+ * Fetches all public logs for the given tags from a contract, automatically paginating through all pages.
+ * @param aztecNode - The Aztec node to query.
+ * @param contractAddress - The contract address to search logs for.
+ * @param tags - The tags to search for.
+ * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
+ * because of reorgs).
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export function getAllPublicLogsByTagsFromContract(
+  aztecNode: AztecNode,
+  contractAddress: AztecAddress,
+  tags: Tag[],
+  anchorBlockHash: BlockHash,
+): Promise<TxScopedL2Log[][]> {
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page =>
+      aztecNode.getPublicLogsByTagsFromContract(contractAddress, batch, page, anchorBlockHash),
+    ),
+  );
+}

package/src/tagging/index.ts

@@ -12,7 +12,8 @@
 export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
 export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
+export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 
 // Re-export tagging-related types from stdlib
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
+export { ExtendedDirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,7 +1,7 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, 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';
@@ -9,25 +9,26 @@ 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
+ * Loads private logs for the app-sender-recipient triplet 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,
+  secret: ExtendedDirectionalAppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
+  anchorBlockHash: BlockHash,
+  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.
+  //                  `MAX_TX_LIFETIME` 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.
@@ -39,19 +40,19 @@ export async function loadPrivateLogsForSenderRecipientPair(
   // 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
+  // - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` 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
+  // least `MAX_TX_LIFETIME` 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`
+  // Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
   // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
   //
   // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
@@ -76,8 +77,8 @@ export async function loadPrivateLogsForSenderRecipientPair(
 
   let start: number, end: number;
   {
-    const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret);
-    const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret);
+    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;
@@ -91,7 +92,14 @@ export async function loadPrivateLogsForSenderRecipientPair(
 
   while (true) {
     // Get private logs with their block timestamps and corresponding tagging indexes
-    const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber);
+    const privateLogsWithIndexes = await loadLogsForRange(
+      secret,
+      aztecNode,
+      start,
+      end,
+      anchorBlockNumber,
+      anchorBlockHash,
+    );
 
     if (privateLogsWithIndexes.length === 0) {
       break;
@@ -107,7 +115,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
 
     // Store updates in data provider and update local variables
     if (highestAgedIndex !== undefined) {
-      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex);
+      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
     }
 
     if (highestFinalizedIndex === undefined) {
@@ -120,7 +128,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
       throw new Error('Highest aged index lower than highest finalized index invariant violated');
     }
 
-    await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex);
+    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.

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

@@ -1,4 +1,4 @@
-import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import { MAX_TX_LIFETIME } from '@aztec/constants';
 import type { TxScopedL2Log } from '@aztec/stdlib/logs';
 
 /**
@@ -16,7 +16,7 @@ export function findHighestIndexes(
     const ageInSeconds = currentTimestamp - log.blockTimestamp;
 
     if (
-      ageInSeconds >= BigInt(MAX_INCLUDE_BY_TIMESTAMP_DURATION) &&
+      ageInSeconds >= BigInt(MAX_TX_LIFETIME) &&
       (highestAgedIndex === undefined || taggingIndex > highestAgedIndex)
     ) {
       highestAgedIndex = taggingIndex;

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

@@ -1,37 +1,38 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
-import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { SiloedTag } from '@aztec/stdlib/logs';
+
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 
 /**
- * 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.
+ * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range and
+ * `extendedSecret`. 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,
+  extendedSecret: ExtendedDirectionalAppTaggingSecret,
   aztecNode: AztecNode,
   start: number,
   end: number,
   anchorBlockNumber: BlockNumber,
+  anchorBlockHash: BlockHash,
 ): 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))),
+  // Derive siloed tags for the window
+  const siloedTags = await Promise.all(
+    Array.from({ length: end - start }, (_, i) => SiloedTag.compute({ extendedSecret, index: start + i })),
   );
 
-  const logs = await aztecNode.getPrivateLogsByTags(siloedTags);
+  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
+  // pagination here.
+  const logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
 
   // 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;
+    const taggingIndex = start + i;
     for (const log of logsForTag) {
       if (log.blockNumber <= anchorBlockNumber) {
         logsWithIndexes.push({ log, taggingIndex });

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -1,6 +1,6 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
 import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
 import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
@@ -10,11 +10,8 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
 /**
  * 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
+ * @param secret - The secret that's unique for (sender, recipient, app) 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).
@@ -22,10 +19,11 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
  * updates its status accordingly.
  */
 export async function syncSenderTaggingIndexes(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
+  secret: ExtendedDirectionalAppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
+  anchorBlockHash: BlockHash,
+  jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works
   //
@@ -45,7 +43,7 @@ export async function syncSenderTaggingIndexes(
   // 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 taggingStore.getLastFinalizedIndex(secret);
+  const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
 
   let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
   let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
@@ -56,21 +54,39 @@ export async function syncSenderTaggingIndexes(
   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, taggingStore);
+    await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId);
 
     // Retrieve all indexes within the current window from storage and update their status accordingly.
-    const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end);
+    const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
     if (pendingTxHashes.length === 0) {
       break;
     }
 
-    const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+    const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = await getStatusChangeOfPending(
+      pendingTxHashes,
+      aztecNode,
+    );
 
-    await taggingStore.dropPendingIndexes(txHashesToDrop);
-    await taggingStore.finalizePendingIndexes(txHashesToFinalize);
+    await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
+    await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
+
+    if (txHashesWithExecutionReverted.length > 0) {
+      const indexedTxEffects = await Promise.all(
+        txHashesWithExecutionReverted.map(txHash => aztecNode.getTxEffect(txHash)),
+      );
+      for (const indexedTxEffect of indexedTxEffects) {
+        if (indexedTxEffect === undefined) {
+          throw new Error(
+            'TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.',
+          );
+        }
+
+        await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(indexedTxEffect.data, jobId);
+      }
+    }
 
     // We check if the finalized index has been updated.
-    newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret);
+    newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
     if (previousFinalizedIndex !== newFinalizedIndex) {
       // A new finalized index was found, so we'll run the loop again. For example:
       // - Previous finalized index: 10

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

@@ -2,47 +2,50 @@ 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.
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
+ * dropped, or execution-reverted (but mined).
  */
 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, tips] = await Promise.all([
-    Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash))),
-    aztecNode.getL2Tips(),
-  ]);
+): Promise<{
+  txHashesToFinalize: TxHash[];
+  txHashesToDrop: TxHash[];
+  txHashesWithExecutionReverted: TxHash[];
+}> {
+  // Get receipts for all pending tx hashes.
+  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
 
   const txHashesToFinalize: TxHash[] = [];
   const txHashesToDrop: TxHash[] = [];
+  const txHashesWithExecutionReverted: 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 <= tips.finalized.block.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.
+    if (receipt.status === TxStatus.FINALIZED) {
+      // Tx has been included in a block and the corresponding block is finalized
+      if (receipt.hasExecutionSucceeded()) {
+        // No part of execution reverted - we just finalize all the indexes.
+        txHashesToFinalize.push(txHash);
+      } else if (receipt.hasExecutionReverted()) {
+        // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+        // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+        txHashesWithExecutionReverted.push(txHash);
+      } else {
+        // Defensive check - this branch should never be triggered
+        throw new Error(
+          'Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.',
+        );
+      }
+    } else if (receipt.isDropped()) {
+      // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
       txHashesToDrop.push(txHash);
     } else {
-      // Tx is still pending or the corresponding block is not yet finalized --> we don't do anything.
+      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
     }
   }
 
-  return { txHashesToFinalize, txHashesToDrop };
+  return { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted };
 }

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

@@ -1,72 +1,85 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import { SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.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 extendedSecret - The extended directional app tagging secret that's unique for (sender, recipient, app) tuple.
  * @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 taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
  */
 export async function loadAndStoreNewTaggingIndexes(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
+  extendedSecret: ExtendedDirectionalAppTaggingSecret,
   start: number,
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
+  anchorBlockHash: BlockHash,
+  jobId: string,
 ) {
   // 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)),
+    Array.from({ length: end - start }, (_, i) => SiloedTag.compute({ extendedSecret, index: start + i })),
   );
 
-  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode);
-  const highestIndexMap = getTxHighestIndexMap(txsForTags, preTagsForWindow);
+  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
+  const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
 
-  // 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()) {
+  // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+  for (const [txHashStr, indexes] of txIndexesMap.entries()) {
     const txHash = TxHash.fromString(txHashStr);
-    await taggingStore.storePendingIndexes([{ secret, index: highestIndex }], txHash);
+    const ranges = [{ extendedSecret, lowestIndex: Math.min(...indexes), highestIndex: Math.max(...indexes) }];
+    await taggingStore.storePendingIndexes(ranges, txHash, jobId);
   }
 }
 
 // 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 allLogs = await aztecNode.getPrivateLogsByTags(tags);
+async function getTxsContainingTags(
+  tags: SiloedTag[],
+  aztecNode: AztecNode,
+  anchorBlockHash: BlockHash,
+): Promise<TxHash[][]> {
+  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
+  // pagination here.
+  const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
   return allLogs.map(logs => logs.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}`,
-    );
+// Returns a map of txHash to all indexes for that txHash.
+function getTxIndexesMap(txHashesForTags: TxHash[][], start: number, count: number): Map<string, number[]> {
+  if (txHashesForTags.length !== count) {
+    throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
   }
 
-  const highestIndexMap = new Map<string, number>();
+  const indexesMap = new Map<string, number[]>();
+  // Iterate over indexes
   for (let i = 0; i < txHashesForTags.length; i++) {
-    const taggingIndex = preTagsForWindow[i].index;
+    const taggingIndex = start + i;
     const txHashesForTag = txHashesForTags[i];
+    // iterate over tx hashes that used that index (tag)
     for (const txHash of txHashesForTag) {
       const key = txHash.toString();
-      highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+      const existing = indexesMap.get(key);
+      // Add the index to the tx's indexes
+      if (existing) {
+        existing.push(taggingIndex);
+      } else {
+        indexesMap.set(key, [taggingIndex]);
+      }
     }
   }
-  return highestIndexMap;
+  return indexesMap;
 }

package/dest/contract_function_simulator/proxied_node.d.ts

@@ -1,9 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { NodeStats } from '@aztec/stdlib/tx';
-export type ProxiedNode = AztecNode & {
-    getStats(): NodeStats;
-};
-export declare class ProxiedNodeFactory {
-    static create(node: AztecNode): ProxiedNode;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveGllZF9ub2RlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL3Byb3hpZWRfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUtsRCxNQUFNLE1BQU0sV0FBVyxHQUFHLFNBQVMsR0FBRztJQUFFLFFBQVEsSUFBSSxTQUFTLENBQUE7Q0FBRSxDQUFDO0FBRWhFLHFCQUFhLGtCQUFrQjtJQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxTQUFTLGVBcUI1QjtDQUNGIn0=

package/dest/contract_function_simulator/proxied_node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxied_node.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/proxied_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG;IAAE,QAAQ,IAAI,SAAS,CAAA;CAAE,CAAC;AAEhE,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,eAqB5B;CACF"}

package/dest/contract_function_simulator/proxied_node.js

@@ -1,27 +0,0 @@
-import { Timer } from '@aztec/foundation/timer';
-export class ProxiedNodeFactory {
-    static create(node) {
-        const stats = {};
-        return new Proxy(node, {
-            get (target, prop) {
-                if (prop === 'getStats') {
-                    return ()=>{
-                        return stats;
-                    };
-                } else {
-                    return async function(...args) {
-                        if (!stats[prop]) {
-                            stats[prop] = {
-                                times: []
-                            };
-                        }
-                        const timer = new Timer();
-                        const result = await target[prop].apply(target, args);
-                        stats[prop].times.push(timer.ms());
-                        return result;
-                    };
-                }
-            }
-        });
-    }
-}

package/dest/private_kernel/hints/build_private_kernel_reset_private_inputs.d.ts

@@ -1,28 +0,0 @@
-import { type PrivateKernelCircuitPublicInputs, PrivateKernelResetCircuitPrivateInputs, type PrivateKernelSimulateOutput } from '@aztec/stdlib/kernel';
-import { type PrivateCallExecutionResult } from '@aztec/stdlib/tx';
-import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
-export declare class PrivateKernelResetPrivateInputsBuilder {
-    private previousKernelOutput;
-    private executionStack;
-    private noteHashNullifierCounterMap;
-    private splitCounter;
-    private previousKernel;
-    private nextIteration?;
-    private noteHashResetActions;
-    private nullifierResetActions;
-    private numTransientData?;
-    private transientDataSquashingHints;
-    private requestedDimensions;
-    constructor(previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>, executionStack: PrivateCallExecutionResult[], noteHashNullifierCounterMap: Map<number, number>, splitCounter: number);
-    needsReset(): boolean;
-    build(oracle: PrivateKernelOracle): Promise<PrivateKernelResetCircuitPrivateInputs>;
-    private reduceReadRequestActions;
-    private needsResetNoteHashReadRequests;
-    private needsResetNullifierReadRequests;
-    private needsResetNullifierKeys;
-    private needsResetTransientData;
-    private needsSiloNoteHashes;
-    private needsSiloNullifiers;
-    private needsSiloPrivateLogs;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGRfcHJpdmF0ZV9rZXJuZWxfcmVzZXRfcHJpdmF0ZV9pbnB1dHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9oaW50cy9idWlsZF9wcml2YXRlX2tlcm5lbF9yZXNldF9wcml2YXRlX2lucHV0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFlQSxPQUFPLEVBS0wsS0FBSyxnQ0FBZ0MsRUFFckMsc0NBQXNDLEVBR3RDLEtBQUssMkJBQTJCLEVBZWpDLE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUFFLEtBQUssMEJBQTBCLEVBQWlCLE1BQU0sa0JBQWtCLENBQUM7QUFHbEYsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQTRDdkUscUJBQWEsc0NBQXNDO0lBWS9DLE9BQU8sQ0FBQyxvQkFBb0I7SUFDNUIsT0FBTyxDQUFDLGNBQWM7SUFDdEIsT0FBTyxDQUFDLDJCQUEyQjtJQUNuQyxPQUFPLENBQUMsWUFBWTtJQWR0QixPQUFPLENBQUMsY0FBYyxDQUFtQztJQUV6RCxPQUFPLENBQUMsYUFBYSxDQUFDLENBQTZCO0lBRW5ELE9BQU8sQ0FBQyxvQkFBb0IsQ0FBcUU7SUFDakcsT0FBTyxDQUFDLHFCQUFxQixDQUFxRTtJQUNsRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBUztJQUNsQyxPQUFPLENBQUMsMkJBQTJCLENBQWtFO0lBQ3JHLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBK0I7SUFFMUQsWUFDVSxvQkFBb0IsRUFBRSwyQkFBMkIsQ0FBQyxnQ0FBZ0MsQ0FBQyxFQUNuRixjQUFjLEVBQUUsMEJBQTBCLEVBQUUsRUFDNUMsMkJBQTJCLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFDaEQsWUFBWSxFQUFFLE1BQU0sRUFXN0I7SUFFRCxVQUFVLElBQUksT0FBTyxDQXNCcEI7SUFFSyxLQUFLLENBQUMsTUFBTSxFQUFFLG1CQUFtQixtREFtRXRDO0lBRUQsT0FBTyxDQUFDLHdCQUF3QjtJQTJCaEMsT0FBTyxDQUFDLDhCQUE4QjtJQXVEdEMsT0FBTyxDQUFDLCtCQUErQjtJQXVEdkMsT0FBTyxDQUFDLHVCQUF1QjtJQWEvQixPQUFPLENBQUMsdUJBQXVCO0lBc0UvQixPQUFPLENBQUMsbUJBQW1CO0lBYzNCLE9BQU8sQ0FBQyxtQkFBbUI7SUFrQjNCLE9BQU8sQ0FBQyxvQkFBb0I7Q0FxQjdCIn0=