@aztec/pxe 0.0.1-commit.e61ad554 → 0.0.1-commit.ec5f612

package/src/storage/note_store/note_store.ts

@@ -1,12 +1,12 @@
-import { toArray } from '@aztec/foundation/iterable';
 import { Semaphore } from '@aztec/foundation/queue';
 import type { Fr } from '@aztec/foundation/schemas';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { DataInBlock } from '@aztec/stdlib/block';
-import { NoteDao, NoteStatus, type NotesFilter } from '@aztec/stdlib/note';
+import { NoteDao, NoteStatus } from '@aztec/stdlib/note';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
+import type { NotesFilter } from '../../notes_filter.js';
 import { StoredNote } from './stored_note.js';
 
 /**
@@ -68,32 +68,26 @@ export class NoteStore implements StagedStore {
    * @param jobId - The job context for staged writes
    */
   public addNotes(notes: NoteDao[], scope: AztecAddress, jobId: string): Promise<void[]> {
-    return this.#withJobLock(jobId, () => Promise.all(notes.map(noteDao => this.#addNote(noteDao, scope, jobId))));
-  }
-
-  async #addNote(note: NoteDao, scope: AztecAddress, jobId: string) {
-    const noteForJob =
-      (await this.#readNote(note.siloedNullifier.toString(), jobId)) ?? new StoredNote(note, new Set());
-
-    // Make sure the note is linked to the scope and staged for this job
-    noteForJob.addScope(scope.toString());
-    this.#writeNote(noteForJob, jobId);
+    return this.#withJobLock(jobId, () =>
+      this.#store.transactionAsync(() =>
+        Promise.all(
+          notes.map(async note => {
+            const noteForJob =
+              (await this.#readNote(note.siloedNullifier.toString(), jobId)) ?? new StoredNote(note, new Set());
+            noteForJob.addScope(scope.toString());
+            this.#writeNote(noteForJob, jobId);
+          }),
+        ),
+      ),
+    );
   }
 
   async #readNote(nullifier: string, jobId: string): Promise<StoredNote | undefined> {
-    // First check staged notes for this job
-    const noteForJob = this.#getNotesForJob(jobId).get(nullifier);
-    if (noteForJob) {
-      return noteForJob;
-    }
-
-    // Then check persistent storage
+    // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+    // are no pending read requests). The staged value still takes precedence if it exists.
     const noteBuffer = await this.#notes.getAsync(nullifier);
-    if (noteBuffer) {
-      return StoredNote.fromBuffer(noteBuffer);
-    }
-
-    return undefined;
+    const noteForJob = this.#getNotesForJob(jobId).get(nullifier);
+    return noteForJob ?? (noteBuffer ? StoredNote.fromBuffer(noteBuffer) : undefined);
   }
 
   #writeNote(note: StoredNote, jobId: string) {
@@ -110,59 +104,102 @@ export class NoteStore implements StagedStore {
    * @params jobId - the job context to read from.
    * @returns Filtered and deduplicated notes (a note might be present in multiple scopes - we ensure it is only
    * returned once if this is the case)
-   * @throws If filtering by an empty scopes array. Scopes have to be set to undefined or to a non-empty array.
    */
-  async getNotes(filter: NotesFilter, jobId: string): Promise<NoteDao[]> {
-    if (filter.scopes !== undefined && filter.scopes.length === 0) {
-      throw new Error('Trying to get notes with an empty scopes array');
+  getNotes(filter: NotesFilter, jobId: string): Promise<NoteDao[]> {
+    if (filter.scopes !== 'ALL_SCOPES' && filter.scopes.length === 0) {
+      return Promise.resolve([]);
     }
 
-    const targetStatus = filter.status ?? NoteStatus.ACTIVE;
+    return this.#store.transactionAsync(async () => {
+      const targetStatus = filter.status ?? NoteStatus.ACTIVE;
+
+      // The code below might read a bit unnatural, the reason is that we need to be careful in how we use `await` inside
+      // `transactionAsync`, otherwise browsers might choose to auto-commit the IndexedDB transaction forcing us to
+      // explicitly handle that condition. The rule we need to honor is: do not await unless you generate a database
+      // read or write or you're done using the DB for the remainder of the transaction. The following sequence is
+      // unsafe in IndexedDB:
+      //
+      // 1. start transactionAsync()
+      // 2. await readDb() <-- OK, transaction alive because we issued DB ops
+      // 3. run a bunch of computations (no await involved) <-- OK, tx alive because we are in the same microtask
+      // 4. await doSthNotInDb() <-- no DB ops issued in this task, browser's free to decide to commit the tx
+      // 5. await readDb() <-- BOOM, TransactionInactiveError
+      //
+      // Note that the real issue is in step number 5: we try to continue using a transaction that the browser might
+      // have already committed.
+      //
+      // We need to read candidate notes which are either indexed by contract address in the DB (in
+      // #nullifiersByContractAddress), or lie in memory for the not yet committed `jobId`.
+      // So we collect promises based on both sources without awaiting for them.
+      const noteReadPromises: Map<string, Promise<StoredNote | undefined>> = new Map();
+
+      // Awaiting the getValuesAsync iterator is fine because it's reading from the DB
+      for await (const nullifier of this.#nullifiersByContractAddress.getValuesAsync(
+        filter.contractAddress.toString(),
+      )) {
+        // Each #readNote will perform a DB read
+        noteReadPromises.set(nullifier, this.#readNote(nullifier, jobId));
+      }
 
-    const foundNotes: Map<string, NoteDao> = new Map();
+      // Add staged nullifiers from job, no awaits involved, so we are fine
+      for (const storedNote of this.#getNotesForJob(jobId).values()) {
+        if (storedNote.noteDao.contractAddress.equals(filter.contractAddress)) {
+          const nullifier = storedNote.noteDao.siloedNullifier.toString();
+          if (!noteReadPromises.has(nullifier)) {
+            noteReadPromises.set(nullifier, Promise.resolve(storedNote));
+          }
+        }
+      }
 
-    const nullifiersOfContract = await this.#nullifiersOfContract(filter.contractAddress, jobId);
-    for (const nullifier of nullifiersOfContract) {
-      const note = await this.#readNote(nullifier, jobId);
+      // By now we have pending DB requests from all the #readNote calls. Await them all together.
+      const notes = await Promise.all(noteReadPromises.values());
 
-      // Defensive: hitting this case means we're mishandling contract indices or in-memory job data
-      if (!note) {
-        throw new Error('PXE note database is corrupted.');
-      }
+      // The rest of the function is await-free, and just deals with filtering and sorting our findings.
+      const foundNotes: Map<string, NoteDao> = new Map();
 
-      // Apply filters
-      if (targetStatus === NoteStatus.ACTIVE && note.isNullified()) {
-        continue;
-      }
+      for (const note of notes) {
+        // Defensive: hitting this case means we're mishandling contract indices or in-memory job data
+        if (!note) {
+          throw new Error('PXE note database is corrupted.');
+        }
 
-      if (filter.owner && !note.noteDao.owner.equals(filter.owner)) {
-        continue;
-      }
+        // Apply filters
+        if (targetStatus === NoteStatus.ACTIVE && note.isNullified()) {
+          continue;
+        }
 
-      if (filter.storageSlot && !note.noteDao.storageSlot.equals(filter.storageSlot)) {
-        continue;
-      }
+        if (filter.owner && !note.noteDao.owner.equals(filter.owner)) {
+          continue;
+        }
 
-      if (filter.siloedNullifier && !note.noteDao.siloedNullifier.equals(filter.siloedNullifier)) {
-        continue;
-      }
+        if (filter.storageSlot && !note.noteDao.storageSlot.equals(filter.storageSlot)) {
+          continue;
+        }
 
-      if (filter.scopes && note.scopes.intersection(new Set(filter.scopes.map(s => s.toString()))).size === 0) {
-        continue;
-      }
+        if (filter.siloedNullifier && !note.noteDao.siloedNullifier.equals(filter.siloedNullifier)) {
+          continue;
+        }
 
-      foundNotes.set(note.noteDao.siloedNullifier.toString(), note.noteDao);
-    }
+        if (
+          filter.scopes !== 'ALL_SCOPES' &&
+          note.scopes.intersection(new Set(filter.scopes.map(s => s.toString()))).size === 0
+        ) {
+          continue;
+        }
 
-    // Sort by block number, then by tx index within block, then by note index within tx
-    return [...foundNotes.values()].sort((a, b) => {
-      if (a.l2BlockNumber !== b.l2BlockNumber) {
-        return a.l2BlockNumber - b.l2BlockNumber;
-      }
-      if (a.txIndexInBlock !== b.txIndexInBlock) {
-        return a.txIndexInBlock - b.txIndexInBlock;
+        foundNotes.set(note.noteDao.siloedNullifier.toString(), note.noteDao);
       }
-      return a.noteIndexInTx - b.noteIndexInTx;
+
+      // Sort by block number, then by tx index within block, then by note index within tx
+      return [...foundNotes.values()].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.noteIndexInTx - b.noteIndexInTx;
+      });
     });
   }
 
@@ -182,12 +219,16 @@ export class NoteStore implements StagedStore {
    * @throws Error if any nullifier is not found in this notes store
    */
   applyNullifiers(nullifiers: DataInBlock<Fr>[], jobId: string): Promise<NoteDao[]> {
+    if (nullifiers.length === 0) {
+      return Promise.resolve([]);
+    }
+
+    if (nullifiers.some(n => n.l2BlockNumber === 0)) {
+      return Promise.reject(new Error('applyNullifiers: nullifiers cannot have been emitted at block 0'));
+    }
+
     return this.#withJobLock(jobId, () =>
       this.#store.transactionAsync(async () => {
-        if (nullifiers.length === 0) {
-          return [];
-        }
-
         const notesToNullify = await Promise.all(
           nullifiers.map(async nullifierInBlock => {
             const nullifier = nullifierInBlock.data.toString();
@@ -197,14 +238,13 @@ export class NoteStore implements StagedStore {
               throw new Error(`Attempted to mark a note as nullified which does not exist in PXE DB`);
             }
 
-            return { storedNote: await this.#readNote(nullifier, jobId), blockNumber: nullifierInBlock.l2BlockNumber };
+            return { storedNote, blockNumber: nullifierInBlock.l2BlockNumber };
           }),
         );
 
         const notesNullifiedInThisCall: Map<string, NoteDao> = new Map();
         for (const noteToNullify of notesToNullify) {
-          // Safe to coerce (!) because we throw if we find any undefined above
-          const note = noteToNullify.storedNote!;
+          const note = noteToNullify.storedNote;
 
           // Skip already nullified notes
           if (note.isNullified()) {
@@ -249,18 +289,23 @@ export class NoteStore implements StagedStore {
    * @param blockNumber - Notes created after this block number will be deleted
    */
   async #deleteActiveNotesAfterBlock(blockNumber: number): Promise<void> {
-    const notes = await toArray(this.#notes.valuesAsync());
-    for (const noteBuffer of notes) {
+    // Collect notes to delete during iteration to keep IndexedDB transaction alive.
+    const notesToDelete: { nullifier: string; contractAddress: string }[] = [];
+    for await (const noteBuffer of this.#notes.valuesAsync()) {
       const storedNote = StoredNote.fromBuffer(noteBuffer);
       if (storedNote.noteDao.l2BlockNumber > blockNumber) {
-        const noteNullifier = storedNote.noteDao.siloedNullifier.toString();
-        await this.#notes.delete(noteNullifier);
-        await this.#nullifiersByContractAddress.deleteValue(
-          storedNote.noteDao.contractAddress.toString(),
-          noteNullifier,
-        );
+        notesToDelete.push({
+          nullifier: storedNote.noteDao.siloedNullifier.toString(),
+          contractAddress: storedNote.noteDao.contractAddress.toString(),
+        });
       }
     }
+
+    // Delete all collected notes. Each delete is a DB operation that keeps the transaction alive.
+    for (const { nullifier, contractAddress } of notesToDelete) {
+      await this.#notes.delete(nullifier);
+      await this.#nullifiersByContractAddress.deleteValue(contractAddress, nullifier);
+    }
   }
 
   /**
@@ -273,62 +318,69 @@ export class NoteStore implements StagedStore {
    * @param anchorBlockNumber - Upper bound for the block range to process
    */
   async #rewindNullifiedNotesAfterBlock(blockNumber: number, anchorBlockNumber: number): Promise<void> {
-    const currentBlockNumber = blockNumber + 1;
-    for (let i = currentBlockNumber; i <= anchorBlockNumber; i++) {
-      const noteNullifiersToReinsert: string[] = await toArray(
-        this.#nullifiersByNullificationBlockNumber.getValuesAsync(i),
-      );
-
-      const nullifiedNoteBuffers = await Promise.all(
-        noteNullifiersToReinsert.map(async noteNullifier => {
-          const note = await this.#notes.getAsync(noteNullifier);
-
-          if (!note) {
-            throw new Error(`PXE DB integrity error: no note found with nullifier ${noteNullifier}`);
-          }
-
-          return note;
-        }),
-      );
-
-      const storedNotes = nullifiedNoteBuffers.map(buffer => StoredNote.fromBuffer(buffer));
+    // First pass: collect all nullifiers for all blocks, starting reads during iteration to keep tx alive.
+    const nullifiersByBlock: Map<number, { nullifier: string; noteReadPromise: Promise<Buffer | undefined> }[]> =
+      new Map();
+
+    for (let i = blockNumber + 1; i <= anchorBlockNumber; i++) {
+      const blockNullifiers: { nullifier: string; noteReadPromise: Promise<Buffer | undefined> }[] = [];
+      for await (const nullifier of this.#nullifiersByNullificationBlockNumber.getValuesAsync(i)) {
+        // Start read immediately during iteration to keep IndexedDB transaction alive
+        blockNullifiers.push({ nullifier, noteReadPromise: this.#notes.getAsync(nullifier) });
+      }
+      if (blockNullifiers.length > 0) {
+        nullifiersByBlock.set(i, blockNullifiers);
+      }
+    }
 
-      for (const storedNote of storedNotes) {
-        const noteNullifier = storedNote.noteDao.siloedNullifier.toString();
-        const scopes = storedNote.scopes;
+    // Second pass: await reads and perform writes
+    for (const [block, nullifiers] of nullifiersByBlock) {
+      for (const { nullifier, noteReadPromise } of nullifiers) {
+        const noteBuffer = await noteReadPromise;
+        if (!noteBuffer) {
+          throw new Error(`PXE DB integrity error: no note found with nullifier ${nullifier}`);
+        }
 
-        if (scopes.size === 0) {
-          // We should never run into this error because notes always have a scope assigned to them - either on initial
-          // insertion via `addNotes` or when removing their nullifiers.
-          throw new Error(`No scopes found for nullified note with nullifier ${noteNullifier}`);
+        const storedNote = StoredNote.fromBuffer(noteBuffer);
+        if (storedNote.scopes.size === 0) {
+          throw new Error(`No scopes found for nullified note with nullifier ${nullifier}`);
         }
 
         storedNote.markAsActive();
 
         await Promise.all([
-          this.#notes.set(noteNullifier, storedNote.toBuffer()),
-          this.#nullifiersByNullificationBlockNumber.deleteValue(i, noteNullifier),
+          this.#notes.set(nullifier, storedNote.toBuffer()),
+          this.#nullifiersByNullificationBlockNumber.deleteValue(block, nullifier),
         ]);
       }
     }
   }
 
-  commit(jobId: string): Promise<void> {
-    return this.#withJobLock(jobId, async () => {
-      for (const [nullifier, storedNote] of this.#getNotesForJob(jobId)) {
-        await this.#notes.set(nullifier, storedNote.toBuffer());
-        await this.#nullifiersByContractAddress.set(storedNote.noteDao.contractAddress.toString(), nullifier);
-        if (storedNote.nullifiedAt !== undefined) {
-          await this.#nullifiersByNullificationBlockNumber.set(storedNote.nullifiedAt, nullifier);
-        }
+  /**
+   * 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
+   */
+  async commit(jobId: string): Promise<void> {
+    for (const [nullifier, storedNote] of this.#getNotesForJob(jobId)) {
+      await this.#notes.set(nullifier, storedNote.toBuffer());
+      await this.#nullifiersByContractAddress.set(storedNote.noteDao.contractAddress.toString(), nullifier);
+      if (storedNote.nullifiedAt !== undefined) {
+        await this.#nullifiersByNullificationBlockNumber.set(storedNote.nullifiedAt, nullifier);
       }
+    }
 
-      this.#clearJobData(jobId);
-    });
+    this.#clearJobData(jobId);
   }
 
   discardStaged(jobId: string): Promise<void> {
-    return this.#withJobLock(jobId, () => Promise.resolve(this.#clearJobData(jobId)));
+    this.#clearJobData(jobId);
+    return Promise.resolve();
   }
 
   #clearJobData(jobId: string) {
@@ -363,19 +415,4 @@ export class NoteStore implements StagedStore {
     }
     return notesForJob;
   }
-
-  async #nullifiersOfContract(contractAddress: AztecAddress, jobId: string): Promise<Set<string>> {
-    // Collect persisted nullifiers for this contract
-    const persistedNullifiers: string[] = await toArray(
-      this.#nullifiersByContractAddress.getValuesAsync(contractAddress.toString()),
-    );
-
-    // Collect staged nullifiers from the job where the note's contract matches
-    const stagedNullifiers = this.#getNotesForJob(jobId)
-      .values()
-      .filter(storedNote => storedNote.noteDao.contractAddress.equals(contractAddress))
-      .map(storedNote => storedNote.noteDao.siloedNullifier.toString());
-
-    return new Set([...persistedNullifiers, ...stagedNullifiers]);
-  }
 }

package/src/storage/private_event_store/private_event_store.ts

@@ -1,6 +1,5 @@
 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 { Semaphore } from '@aztec/foundation/queue';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
@@ -81,43 +80,45 @@ export class PrivateEventStore implements StagedStore {
     metadata: PrivateEventMetadata,
     jobId: string,
   ) {
-    return this.#withJobLock(jobId, async () => {
-      const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
-      const eventId = siloedEventCommitment.toString();
-
-      this.logger.verbose('storing private event log (job stage)', {
-        eventId,
-        contractAddress,
-        scope,
-        msgContent,
-        l2BlockNumber,
-      });
-
-      const existing = await this.#readEvent(eventId, jobId);
+    return this.#withJobLock(jobId, () =>
+      this.#store.transactionAsync(async () => {
+        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
+        const eventId = siloedEventCommitment.toString();
 
-      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(
+        this.logger.verbose('storing private event log (job stage)', {
           eventId,
-          new StoredPrivateEvent(
-            randomness,
-            msgContent,
-            l2BlockNumber,
-            l2BlockHash,
-            txHash,
-            txIndexInBlock,
-            eventIndexInTx,
-            contractAddress,
-            eventSelector,
-            new Set([scope.toString()]),
-          ),
-          jobId,
-        );
-      }
-    });
+          contractAddress,
+          scope,
+          msgContent,
+          l2BlockNumber,
+        });
+
+        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,
+          );
+        }
+      }),
+    );
   }
 
   /**
@@ -136,6 +137,20 @@ export class PrivateEventStore implements StagedStore {
     filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
     return this.#store.transactionAsync(async () => {
+      const key = this.#keyFor(filter.contractAddress, eventSelector);
+      const targetScopes = new Set(filter.scopes.map(s => s.toString()));
+
+      // Map from eventId to the promise that reads the event buffer.
+      // We start reads during iteration to keep DB requests pending and avoid IndexedDB auto-commit.
+      const eventReadPromises: Map<string, Promise<Buffer | undefined>> = new Map();
+
+      for await (const eventId of this.#eventsByContractAndEventSelector.getValuesAsync(key)) {
+        eventReadPromises.set(eventId, this.#events.getAsync(eventId));
+      }
+
+      const eventIds = [...eventReadPromises.keys()];
+      const eventBuffers = await Promise.all(eventReadPromises.values());
+
       const events: Array<{
         l2BlockNumber: number;
         txIndexInBlock: number;
@@ -143,13 +158,9 @@ export class PrivateEventStore implements StagedStore {
         event: PackedPrivateEvent;
       }> = [];
 
-      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 eventBuffer = await this.#events.getAsync(eventId);
+      for (let i = 0; i < eventIds.length; i++) {
+        const eventId = eventIds[i];
+        const eventBuffer = eventBuffers[i];
 
         // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
         if (!eventBuffer) {
@@ -223,29 +234,39 @@ export class PrivateEventStore implements StagedStore {
    * IMPORTANT: This method must be called within a transaction to ensure atomicity.
    */
   public async rollback(blockNumber: number, synchedBlockNumber: number): Promise<void> {
-    let removedCount = 0;
+    // First pass: collect all event IDs for all blocks, starting reads during iteration to keep tx alive.
+    const eventsByBlock: Map<number, { eventId: string; eventReadPromise: Promise<Buffer | undefined> }[]> = new Map();
 
     for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
-      const eventIds: string[] = await toArray(this.#eventsByBlockNumber.getValuesAsync(block));
+      const blockEvents: { eventId: string; eventReadPromise: Promise<Buffer | undefined> }[] = [];
+      for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(block)) {
+        // Start read immediately during iteration to keep IndexedDB transaction alive
+        blockEvents.push({ eventId, eventReadPromise: this.#events.getAsync(eventId) });
+      }
+      if (blockEvents.length > 0) {
+        eventsByBlock.set(block, blockEvents);
+      }
+    }
 
-      if (eventIds.length > 0) {
-        await this.#eventsByBlockNumber.delete(block);
+    // Second pass: await reads and perform deletes
+    let removedCount = 0;
+    for (const [block, events] of eventsByBlock) {
+      await this.#eventsByBlockNumber.delete(block);
 
-        for (const eventId of eventIds) {
-          const buffer = await this.#events.getAsync(eventId);
-          if (!buffer) {
-            throw new Error(`Event not found for eventId ${eventId}`);
-          }
+      for (const { eventId, eventReadPromise } of events) {
+        const buffer = await eventReadPromise;
+        if (!buffer) {
+          throw new Error(`Event not found for eventId ${eventId}`);
+        }
 
-          const entry = StoredPrivateEvent.fromBuffer(buffer);
-          await this.#events.delete(eventId);
-          await this.#eventsByContractAndEventSelector.deleteValue(
-            this.#keyFor(entry.contractAddress, entry.eventSelector),
-            eventId,
-          );
+        const entry = StoredPrivateEvent.fromBuffer(buffer);
+        await this.#events.delete(eventId);
+        await this.#eventsByContractAndEventSelector.deleteValue(
+          this.#keyFor(entry.contractAddress, entry.eventSelector),
+          eventId,
+        );
 
-          removedCount++;
-        }
+        removedCount++;
       }
     }
 
@@ -262,28 +283,30 @@ export class PrivateEventStore implements StagedStore {
    *
    * @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),
-        ]);
-      }
+  async commit(jobId: string): Promise<void> {
+    // Note: Don't use #withJobLock here - commit runs within JobCoordinator's transactionAsync,
+    // and awaiting the lock would create a microtask boundary with no pending DB request,
+    // causing IndexedDB to auto-commit the transaction.
+    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);
-    });
+    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)));
+    this.#clearJobData(jobId);
+    return Promise.resolve();
   }
 
   /**
@@ -292,13 +315,11 @@ export class PrivateEventStore implements StagedStore {
    * 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;
-    }
-
+    // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+    // are no pending read requests). The staged value still takes precedence if it exists.
     const buffer = await this.#events.getAsync(eventId);
-    return buffer ? StoredPrivateEvent.fromBuffer(buffer) : undefined;
+    const eventForJob = this.#getEventsForJob(jobId).get(eventId);
+    return eventForJob ?? (buffer ? StoredPrivateEvent.fromBuffer(buffer) : undefined);
   }
 
   /**