@aztec/pxe 0.0.1-commit.3469e52 → 0.0.1-commit.59e663cd

package/src/storage/note_store/stored_note.ts

@@ -0,0 +1,48 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { NoteDao } from '@aztec/stdlib/note';
+
+export class StoredNote {
+  constructor(
+    readonly noteDao: NoteDao,
+    readonly scopes: Set<string>,
+    private _nullifiedAt: BlockNumber | undefined = undefined,
+  ) {}
+
+  static fromBuffer(buffer: Buffer) {
+    const reader = BufferReader.asReader(buffer);
+
+    const noteDao = NoteDao.fromBuffer(reader);
+    const scopes = reader.readVector({ fromBuffer: (r: BufferReader) => r.readString() });
+
+    const nullifiedAtRaw = reader.readNumber();
+    const nullifiedAt = nullifiedAtRaw === 0 ? undefined : (nullifiedAtRaw as BlockNumber);
+
+    return new StoredNote(noteDao, new Set(scopes), nullifiedAt);
+  }
+
+  toBuffer(): Buffer {
+    const scopesArray = [...this.scopes];
+    return serializeToBuffer(this.noteDao, scopesArray.length, ...scopesArray, this._nullifiedAt ?? 0);
+  }
+
+  addScope(scope: string) {
+    this.scopes.add(scope);
+  }
+
+  markAsNullified(blockNumber: BlockNumber) {
+    this._nullifiedAt = blockNumber;
+  }
+
+  markAsActive() {
+    this._nullifiedAt = undefined;
+  }
+
+  isNullified() {
+    return this._nullifiedAt !== undefined;
+  }
+
+  get nullifiedAt() {
+    return this._nullifiedAt;
+  }
+}

package/src/storage/private_event_store/private_event_store.ts

@@ -1,15 +1,16 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { Semaphore } from '@aztec/foundation/queue';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import type { EventSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
-import { type InTx, TxHash } from '@aztec/stdlib/tx';
+import type { InTx, TxHash } from '@aztec/stdlib/tx';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 import type { PackedPrivateEvent } from '../../pxe.js';
+import { StoredPrivateEvent } from './stored_private_event.js';
 
 export type PrivateEventStoreFilter = {
   contractAddress: AztecAddress;
@@ -19,20 +20,6 @@ export type PrivateEventStoreFilter = {
   txHash?: TxHash;
 };
 
-type PrivateEventEntry = {
-  randomness: Fr; // Note that this value is currently not being returned on queries and is therefore temporarily unused
-  msgContent: Buffer;
-  l2BlockNumber: number;
-  l2BlockHash: Buffer;
-  txHash: Buffer;
-  /** The index of the tx within the block, used for ordering events */
-  txIndexInBlock: number;
-  /** The index of the event within the tx (based on nullifier position), used for ordering events */
-  eventIndexInTx: number;
-  /** The lookup key for #eventsByContractScopeSelector, used for cleanup during rollback */
-  lookupKey: string;
-};
-
 type PrivateEventMetadata = InTx & {
   contractAddress: AztecAddress;
   scope: AztecAddress;
@@ -49,104 +36,29 @@ export class PrivateEventStore implements StagedStore {
   readonly storeName: string = 'private_event';
 
   #store: AztecAsyncKVStore;
-  /** Map storing the actual private event log entries, keyed by siloedEventCommitment */
-  #eventLogs: AztecAsyncMap<string, PrivateEventEntry>;
-  /** Multi-map from contractAddress_scope_eventSelector to siloedEventCommitment for efficient lookup */
-  #eventsByContractScopeSelector: AztecAsyncMultiMap<string, string>;
+  /** Actual private event log entries, keyed by siloedEventCommitment */
+  #events: AztecAsyncMap<string, Buffer>;
+  /** Multi-map from contractAddress_eventSelector to siloedEventCommitment for efficient lookup */
+  #eventsByContractAndEventSelector: AztecAsyncMultiMap<string, string>;
   /** Multi-map from block number to siloedEventCommitment for rollback support */
   #eventsByBlockNumber: AztecAsyncMultiMap<number, string>;
-  /** Map from siloedEventCommitment to boolean indicating if log has been seen. */
-  #seenLogs: AztecAsyncMap<string, boolean>;
 
-  /** jobId => eventId (event siloed nullifier)  => PrivateEventEntry */
-  #eventLogsInJobStage: Map<string, Map<string, PrivateEventEntry>>;
+  /** jobId => eventId (event siloed nullifier) => StoredPrivateEvent */
+  #eventsForJob: Map<string, Map<string, StoredPrivateEvent>>;
+
+  /** Per-job locks to prevent concurrent writes from affecting each other. */
+  #jobLocks: Map<string, Semaphore>;
 
   logger = createLogger('private_event_store');
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
-    this.#eventLogs = this.#store.openMap('private_event_logs');
-    this.#eventsByContractScopeSelector = this.#store.openMultiMap('events_by_contract_scope_selector');
-    this.#seenLogs = this.#store.openMap('seen_logs');
+    this.#events = this.#store.openMap('private_event_logs');
+    this.#eventsByContractAndEventSelector = this.#store.openMultiMap('events_by_contract_selector');
     this.#eventsByBlockNumber = this.#store.openMultiMap('events_by_block_number');
 
-    this.#eventLogsInJobStage = new Map();
-  }
-
-  #keyFor(contractAddress: AztecAddress, scope: AztecAddress, eventSelector: EventSelector): string {
-    return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
-  }
-
-  async commit(jobId: string): Promise<void> {
-    await Promise.all(
-      [...this.#getEventLogsInJobStage(jobId).entries()].map(async ([eventId, eventEntry]) => {
-        this.logger.verbose('storing private event log (KV store)', eventEntry);
-
-        await Promise.all([
-          this.#eventLogs.set(eventId, eventEntry),
-          this.#eventsByContractScopeSelector.set(eventEntry.lookupKey, eventId),
-          this.#eventsByBlockNumber.set(eventEntry.l2BlockNumber, eventId),
-          this.#seenLogs.set(eventId, true),
-        ]);
-      }),
-    );
-
-    return this.discardStaged(jobId);
-  }
-
-  discardStaged(jobId: string): Promise<void> {
-    this.#eventLogsInJobStage.delete(jobId);
-    return Promise.resolve();
-  }
-
-  #getEventLogsInJobStage(jobId: string): Map<string, PrivateEventEntry> {
-    let jobStage = this.#eventLogsInJobStage.get(jobId);
-    if (jobStage === undefined) {
-      jobStage = new Map();
-      this.#eventLogsInJobStage.set(jobId, jobStage);
-    }
-    return jobStage;
-  }
-
-  async #isSeenLog(jobId: string, eventId: string): Promise<boolean> {
-    const eventLogsInJobStage = this.#getEventLogsInJobStage(jobId).get(eventId);
-    return !!eventLogsInJobStage || !!(await this.#seenLogs.getAsync(eventId));
-  }
-
-  #addEventLogToStage(jobId: string, eventId: string, eventEntry: PrivateEventEntry) {
-    this.#getEventLogsInJobStage(jobId).set(eventId, eventEntry);
-  }
-
-  async #getEventSiloedNullifiers(
-    contractAddress: AztecAddress,
-    scope: AztecAddress,
-    eventSelector: EventSelector,
-    jobId?: string,
-  ): Promise<string[]> {
-    const key = this.#keyFor(contractAddress, scope, eventSelector);
-    const eventSiloedNullifiersInStorage: string[] = [];
-    for await (const eventId of this.#eventsByContractScopeSelector.getValuesAsync(key)) {
-      eventSiloedNullifiersInStorage.push(eventId);
-    }
-
-    if (!jobId) {
-      return eventSiloedNullifiersInStorage;
-    }
-
-    const eventSiloedNullifiersInJobStage = new Set(
-      [...this.#getEventLogsInJobStage(jobId).entries()]
-        .filter(([_, entry]) => entry.lookupKey === key)
-        .map(([idx, _]) => idx),
-    );
-    return [...new Set(eventSiloedNullifiersInStorage).union(eventSiloedNullifiersInJobStage)];
-  }
-
-  async #getEventLogBySiloedNullifier(eventId: string, jobId?: string): Promise<PrivateEventEntry | undefined> {
-    if (jobId) {
-      return this.#getEventLogsInJobStage(jobId).get(eventId) ?? (await this.#eventLogs.getAsync(eventId));
-    } else {
-      return await this.#eventLogs.getAsync(eventId);
-    }
+    this.#eventsForJob = new Map();
+    this.#jobLocks = new Map();
   }
 
   /**
@@ -168,39 +80,43 @@ export class PrivateEventStore implements StagedStore {
     siloedEventCommitment: Fr,
     metadata: PrivateEventMetadata,
     jobId: string,
-  ): Promise<void> {
-    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
-
-    return this.#store.transactionAsync(async () => {
-      const key = this.#keyFor(contractAddress, scope, eventSelector);
-
-      // The siloed event commitment is guaranteed to be unique as it's inserted into the nullifier tree. For this
-      // reason we use it as id.
+  ) {
+    return this.#withJobLock(jobId, async () => {
+      const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
       const eventId = siloedEventCommitment.toString();
 
-      const hasBeenSeen = await this.#isSeenLog(jobId, eventId);
-      if (hasBeenSeen) {
-        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), siloedEventCommitment });
-        return;
-      }
-
       this.logger.verbose('storing private event log (job stage)', {
+        eventId,
         contractAddress,
         scope,
         msgContent,
         l2BlockNumber,
       });
 
-      this.#addEventLogToStage(jobId, eventId, {
-        randomness,
-        msgContent: serializeToBuffer(msgContent),
-        l2BlockNumber,
-        l2BlockHash: l2BlockHash.toBuffer(),
-        txHash: txHash.toBuffer(),
-        txIndexInBlock,
-        eventIndexInTx,
-        lookupKey: key,
-      });
+      const existing = await this.#readEvent(eventId, jobId);
+
+      if (existing) {
+        // If we already stored this event, we still want to make sure to track it for the given scope
+        existing.addScope(scope.toString());
+        this.#writeEvent(eventId, existing, jobId);
+      } else {
+        this.#writeEvent(
+          eventId,
+          new StoredPrivateEvent(
+            randomness,
+            msgContent,
+            l2BlockNumber,
+            l2BlockHash,
+            txHash,
+            txIndexInBlock,
+            eventIndexInTx,
+            contractAddress,
+            eventSelector,
+            new Set([scope.toString()]),
+          ),
+          jobId,
+        );
+      }
     });
   }
 
@@ -215,64 +131,78 @@ export class PrivateEventStore implements StagedStore {
    * @returns - The event log contents, augmented with metadata about the transaction and block in which the event was
    * included.
    */
-  public async getPrivateEvents(
+  public getPrivateEvents(
     eventSelector: EventSelector,
     filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
-    const events: Array<{
-      l2BlockNumber: number;
-      txIndexInBlock: number;
-      eventIndexInTx: number;
-      event: PackedPrivateEvent;
-    }> = [];
+    return this.#store.transactionAsync(async () => {
+      const events: Array<{
+        l2BlockNumber: number;
+        txIndexInBlock: number;
+        eventIndexInTx: number;
+        event: PackedPrivateEvent;
+      }> = [];
 
-    for (const scope of filter.scopes) {
-      const eventIds = await this.#getEventSiloedNullifiers(filter.contractAddress, scope, eventSelector);
+      const key = this.#keyFor(filter.contractAddress, eventSelector);
+      const targetScopes = new Set(filter.scopes.map(s => s.toString()));
+
+      const eventIds: string[] = await toArray(this.#eventsByContractAndEventSelector.getValuesAsync(key));
 
       for (const eventId of eventIds) {
-        const entry = await this.#getEventLogBySiloedNullifier(eventId);
+        const eventBuffer = await this.#events.getAsync(eventId);
+
+        // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
+        if (!eventBuffer) {
+          this.logger.verbose(
+            `EventId ${eventId} does not exist in main index but it is referenced from contract event selector index`,
+          );
+          continue;
+        }
+
+        const storedPrivateEvent = StoredPrivateEvent.fromBuffer(eventBuffer);
 
-        if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
+        // Filter by block range
+        if (storedPrivateEvent.l2BlockNumber < filter.fromBlock || storedPrivateEvent.l2BlockNumber >= filter.toBlock) {
           continue;
         }
 
-        // Convert buffer back to Fr array
-        const reader = BufferReader.asReader(entry.msgContent);
-        const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
-        const msgContent = reader.readArray(numFields, Fr);
-        const txHash = TxHash.fromBuffer(entry.txHash);
-        const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
+        // Filter by scopes
+        if (storedPrivateEvent.scopes.intersection(targetScopes).size === 0) {
+          continue;
+        }
 
-        if (filter.txHash && !txHash.equals(filter.txHash)) {
+        // Filter by txHash
+        if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
           continue;
         }
 
         events.push({
-          l2BlockNumber: entry.l2BlockNumber,
-          txIndexInBlock: entry.txIndexInBlock,
-          eventIndexInTx: entry.eventIndexInTx,
+          l2BlockNumber: storedPrivateEvent.l2BlockNumber,
+          txIndexInBlock: storedPrivateEvent.txIndexInBlock,
+          eventIndexInTx: storedPrivateEvent.eventIndexInTx,
           event: {
-            packedEvent: msgContent,
-            l2BlockNumber: BlockNumber(entry.l2BlockNumber),
-            txHash,
-            l2BlockHash,
+            packedEvent: storedPrivateEvent.msgContent,
+            l2BlockNumber: BlockNumber(storedPrivateEvent.l2BlockNumber),
+            txHash: storedPrivateEvent.txHash,
+            l2BlockHash: storedPrivateEvent.l2BlockHash,
             eventSelector,
           },
         });
       }
-    }
 
-    // Sort by block number, then by tx index within block, then by event index within tx
-    events.sort((a, b) => {
-      if (a.l2BlockNumber !== b.l2BlockNumber) {
-        return a.l2BlockNumber - b.l2BlockNumber;
-      }
-      if (a.txIndexInBlock !== b.txIndexInBlock) {
-        return a.txIndexInBlock - b.txIndexInBlock;
-      }
-      return a.eventIndexInTx - b.eventIndexInTx;
+      // Sort by block number, then by tx index within block, then by event index within tx
+      events.sort((a, b) => {
+        if (a.l2BlockNumber !== b.l2BlockNumber) {
+          return a.l2BlockNumber - b.l2BlockNumber;
+        }
+        if (a.txIndexInBlock !== b.txIndexInBlock) {
+          return a.txIndexInBlock - b.txIndexInBlock;
+        }
+        return a.eventIndexInTx - b.eventIndexInTx;
+      });
+
+      return events.map(ev => ev.event);
     });
-    return events.map(ev => ev.event);
   }
 
   /**
@@ -296,23 +226,23 @@ export class PrivateEventStore implements StagedStore {
     let removedCount = 0;
 
     for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
-      const eventIds: string[] = [];
-      for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(block)) {
-        eventIds.push(eventId);
-      }
+      const eventIds: string[] = await toArray(this.#eventsByBlockNumber.getValuesAsync(block));
 
       if (eventIds.length > 0) {
         await this.#eventsByBlockNumber.delete(block);
 
         for (const eventId of eventIds) {
-          const entry = await this.#eventLogs.getAsync(eventId);
-          if (!entry) {
-            throw new Error(`Event log not found for eventId ${eventId}`);
+          const buffer = await this.#events.getAsync(eventId);
+          if (!buffer) {
+            throw new Error(`Event not found for eventId ${eventId}`);
           }
 
-          await this.#eventLogs.delete(eventId);
-          await this.#seenLogs.delete(eventId);
-          await this.#eventsByContractScopeSelector.deleteValue(entry.lookupKey, eventId);
+          const entry = StoredPrivateEvent.fromBuffer(buffer);
+          await this.#events.delete(eventId);
+          await this.#eventsByContractAndEventSelector.deleteValue(
+            this.#keyFor(entry.contractAddress, entry.eventSelector),
+            eventId,
+          );
 
           removedCount++;
         }
@@ -321,4 +251,113 @@ export class PrivateEventStore implements StagedStore {
 
     this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
   }
+
+  /**
+   * Commits in memory job data to persistent storage.
+   *
+   * Called by JobCoordinator when a job completes successfully.
+   *
+   * Note: JobCoordinator wraps all commits in a single transaction, so we don't need our own transactionAsync here
+   * (and using one would throw on IndexedDB as it does not support nested txs).
+   *
+   * @param jobId - The jobId identifying which staged data to commit
+   */
+  commit(jobId: string): Promise<void> {
+    return this.#withJobLock(jobId, async () => {
+      for (const [eventId, entry] of this.#getEventsForJob(jobId).entries()) {
+        const lookupKey = this.#keyFor(entry.contractAddress, entry.eventSelector);
+        this.logger.verbose('storing private event log', { eventId, lookupKey });
+
+        await Promise.all([
+          this.#events.set(eventId, entry.toBuffer()),
+          this.#eventsByContractAndEventSelector.set(lookupKey, eventId),
+          this.#eventsByBlockNumber.set(entry.l2BlockNumber, eventId),
+        ]);
+      }
+
+      this.#clearJobData(jobId);
+    });
+  }
+
+  /**
+   * Discards in memory job data without persisting it.
+   */
+  discardStaged(jobId: string): Promise<void> {
+    return this.#withJobLock(jobId, () => Promise.resolve(this.#clearJobData(jobId)));
+  }
+
+  /**
+   * Reads an event from in-memory job data first, falling back to persistent storage if not found.
+   *
+   * Returns undefined if the event does not exist in the store overall.
+   */
+  async #readEvent(eventId: string, jobId: string): Promise<StoredPrivateEvent | undefined> {
+    const eventForJob = this.#getEventsForJob(jobId).get(eventId);
+    if (eventForJob) {
+      return eventForJob;
+    }
+
+    const buffer = await this.#events.getAsync(eventId);
+    return buffer ? StoredPrivateEvent.fromBuffer(buffer) : undefined;
+  }
+
+  /**
+   * Writes an event to in-memory job data.
+   *
+   * Writes are only allowed in a job context. Events modified during a job will only be persisted when `commit` is
+   * called.
+   */
+  #writeEvent(eventId: string, entry: StoredPrivateEvent, jobId: string) {
+    this.#getEventsForJob(jobId).set(eventId, entry);
+  }
+
+  /**
+   * Get in-memory data only visible to @param jobId
+   */
+  #getEventsForJob(jobId: string): Map<string, StoredPrivateEvent> {
+    let eventsForJob = this.#eventsForJob.get(jobId);
+    if (eventsForJob === undefined) {
+      eventsForJob = new Map();
+      this.#eventsForJob.set(jobId, eventsForJob);
+    }
+    return eventsForJob;
+  }
+
+  /**
+   * Clear data structures supporting a specific job.
+   */
+  #clearJobData(jobId: string) {
+    this.#eventsForJob.delete(jobId);
+    this.#jobLocks.delete(jobId);
+  }
+
+  /**
+   * Ensures a function can only run once it acquires a unique per-job lock, and handles proper lock release after it
+   * runs.
+   *
+   * This primitive allows concurrent writes on this store without risking data corruption due to unsound write
+   * interleaving.
+   */
+  async #withJobLock<T>(jobId: string, fn: () => Promise<T>): Promise<T> {
+    let lock = this.#jobLocks.get(jobId);
+    if (!lock) {
+      lock = new Semaphore(1);
+      this.#jobLocks.set(jobId, lock);
+    }
+    await lock.acquire();
+    try {
+      return await fn();
+    } finally {
+      lock.release();
+    }
+  }
+
+  /**
+   * Returns a string key based on @param contractAddress and @param eventSelector.
+   *
+   * The returned key is meant to be used when interacting with index #eventsByContractAndEventSelector.
+   */
+  #keyFor(contractAddress: AztecAddress, eventSelector: EventSelector): string {
+    return `${contractAddress.toString()}_${eventSelector.toString()}`;
+  }
 }

package/src/storage/private_event_store/stored_private_event.ts

@@ -0,0 +1,73 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { EventSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { TxHash } from '@aztec/stdlib/tx';
+
+/** Serializable private event entry with scope tracking. */
+export class StoredPrivateEvent {
+  constructor(
+    readonly randomness: Fr,
+    readonly msgContent: Fr[],
+    readonly l2BlockNumber: number,
+    readonly l2BlockHash: BlockHash,
+    readonly txHash: TxHash,
+    readonly txIndexInBlock: number,
+    readonly eventIndexInTx: number,
+    readonly contractAddress: AztecAddress,
+    readonly eventSelector: EventSelector,
+    readonly scopes: Set<string>,
+  ) {}
+
+  addScope(scope: string) {
+    this.scopes.add(scope);
+  }
+
+  toBuffer(): Buffer {
+    const scopesArray = [...this.scopes];
+    return serializeToBuffer(
+      this.randomness,
+      this.msgContent.length,
+      ...this.msgContent,
+      this.l2BlockNumber,
+      this.l2BlockHash,
+      this.txHash,
+      this.txIndexInBlock,
+      this.eventIndexInTx,
+      this.contractAddress,
+      this.eventSelector.toBuffer(),
+      scopesArray.length,
+      ...scopesArray,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer): StoredPrivateEvent {
+    const reader = BufferReader.asReader(buffer);
+
+    const randomness = Fr.fromBuffer(reader);
+    const msgContentLength = reader.readNumber();
+    const msgContent = reader.readArray(msgContentLength, Fr);
+    const l2BlockNumber = reader.readNumber();
+    const l2BlockHash = BlockHash.fromBuffer(reader);
+    const txHash = TxHash.fromBuffer(reader);
+    const txIndexInBlock = reader.readNumber();
+    const eventIndexInTx = reader.readNumber();
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const eventSelector = EventSelector.fromBuffer(reader);
+    const scopes = reader.readVector({ fromBuffer: (r: BufferReader) => r.readString() });
+
+    return new StoredPrivateEvent(
+      randomness,
+      msgContent,
+      l2BlockNumber,
+      l2BlockHash,
+      txHash,
+      txIndexInBlock,
+      eventIndexInTx,
+      contractAddress,
+      eventSelector,
+      new Set(scopes),
+    );
+  }
+}

package/src/tagging/get_all_logs_by_tags.ts

@@ -0,0 +1,68 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import { MAX_LOGS_PER_TAG } 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;
+}
+
+/**
+ * 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 getAllPages(tags.length, page => aztecNode.getPrivateLogsByTags(tags, 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 getAllPages(tags.length, page =>
+    aztecNode.getPublicLogsByTagsFromContract(contractAddress, tags, page, anchorBlockHash),
+  );
+}

package/src/tagging/index.ts

@@ -12,6 +12,7 @@
 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';