@aztec/pxe 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/src/storage/note_store/stored_note.ts

@@ -1,48 +1,26 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { NoteDao } from '@aztec/stdlib/note';
 
+/** A note as stored by the PXE: the note DAO plus the scopes that observed it. Append-only — never mutated. */
 export class StoredNote {
   constructor(
     readonly noteDao: NoteDao,
     readonly scopes: Set<string>,
-    private _nullifiedAt: BlockNumber | undefined = undefined,
   ) {}
 
-  static fromBuffer(buffer: Buffer) {
+  static fromBuffer(buffer: Buffer): StoredNote {
     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);
+    return new StoredNote(noteDao, new Set(scopes));
   }
 
   toBuffer(): Buffer {
     const scopesArray = [...this.scopes];
-    return serializeToBuffer(this.noteDao, scopesArray.length, ...scopesArray, this._nullifiedAt ?? 0);
+    return serializeToBuffer(this.noteDao, scopesArray.length, ...scopesArray);
   }
 
-  addScope(scope: string) {
+  addScope(scope: string): void {
     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/open_pxe_stores.ts

@@ -0,0 +1,52 @@
+import { KeyStore } from '@aztec/key-store';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { L2TipsKVStore } from '@aztec/kv-store/stores';
+import type { BlockHash } from '@aztec/stdlib/block';
+
+import { AddressStore } from './address_store/address_store.js';
+import { AnchorBlockStore } from './anchor_block_store/anchor_block_store.js';
+import { CapsuleStore } from './capsule_store/capsule_store.js';
+import { ContractStore } from './contract_store/contract_store.js';
+import { FactStore } from './fact_store/fact_store.js';
+import { NoteStore } from './note_store/note_store.js';
+import { PrivateEventStore } from './private_event_store/private_event_store.js';
+import { RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore } from './tagging_store/index.js';
+
+/**
+ * The set of sub-stores opened against a single `AztecAsyncKVStore` to back PXE state.
+ */
+export type PxeStores = {
+  addressStore: AddressStore;
+  privateEventStore: PrivateEventStore;
+  contractStore: ContractStore;
+  noteStore: NoteStore;
+  anchorBlockStore: AnchorBlockStore;
+  senderTaggingStore: SenderTaggingStore;
+  taggingSecretSourcesStore: TaggingSecretSourcesStore;
+  recipientTaggingStore: RecipientTaggingStore;
+  capsuleStore: CapsuleStore;
+  keyStore: KeyStore;
+  l2TipsStore: L2TipsKVStore;
+  factStore: FactStore;
+};
+
+/**
+ * Opens every PXE sub-store against the given backing store. The `initialBlockHash` seeds the
+ * `L2TipsKVStore` so it agrees with the node's archiver on the dynamic genesis header hash.
+ */
+export function openPxeStores(store: AztecAsyncKVStore, initialBlockHash: BlockHash): PxeStores {
+  return {
+    addressStore: new AddressStore(store),
+    privateEventStore: new PrivateEventStore(store),
+    contractStore: new ContractStore(store),
+    noteStore: new NoteStore(store),
+    anchorBlockStore: new AnchorBlockStore(store),
+    senderTaggingStore: new SenderTaggingStore(store),
+    taggingSecretSourcesStore: new TaggingSecretSourcesStore(store),
+    recipientTaggingStore: new RecipientTaggingStore(store),
+    capsuleStore: new CapsuleStore(store),
+    keyStore: new KeyStore(store),
+    l2TipsStore: new L2TipsKVStore(store, 'pxe', initialBlockHash),
+    factStore: new FactStore(store),
+  };
+}

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';
@@ -29,25 +28,35 @@ type PrivateEventMetadata = InTx & {
   eventIndexInTx: number;
 };
 
+/// Alias types for kv map readability
+type EventId = string; // the siloedEventCommitment, stringified
+type JobId = string;
+type ContractAndSelectorKey = string;
+type BlockNum = number;
+type StoredEventBuffer = Buffer;
+
 /**
  * Stores decrypted private event logs.
+ *
+ * Append-only: events are never deleted during normal operation. Reorgs are handled by delete-on-prune, which removes
+ * every event originating on a reorg'd block.
  */
 export class PrivateEventStore implements StagedStore {
   readonly storeName: string = 'private_event';
 
   #store: AztecAsyncKVStore;
   /** Actual private event log entries, keyed by siloedEventCommitment */
-  #events: AztecAsyncMap<string, Buffer>;
+  #events: AztecAsyncMap<EventId, StoredEventBuffer>;
   /** 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>;
+  #eventsByContractAndEventSelector: AztecAsyncMultiMap<ContractAndSelectorKey, EventId>;
+  /** Multi-map from block number to siloedEventCommitment, for delete-on-prune. */
+  #eventsByBlockNumber: AztecAsyncMultiMap<BlockNum, EventId>;
 
   /** jobId => eventId (event siloed nullifier) => StoredPrivateEvent */
-  #eventsForJob: Map<string, Map<string, StoredPrivateEvent>>;
+  #eventsForJob: Map<JobId, Map<EventId, StoredPrivateEvent>>;
 
   /** Per-job locks to prevent concurrent writes from affecting each other. */
-  #jobLocks: Map<string, Semaphore>;
+  #jobLocks: Map<JobId, Semaphore>;
 
   logger = createLogger('private_event_store');
 
@@ -81,43 +90,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();
+    return this.#withJobLock(jobId, () =>
+      this.#store.transactionAsync(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,
-      });
+        this.logger.verbose('storing private event log (job stage)', {
+          eventId,
+          contractAddress,
+          scope,
+          msgContent,
+          l2BlockNumber,
+        });
 
-      const existing = await this.#readEvent(eventId, jobId);
+        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,
-        );
-      }
-    });
+        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 +147,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 +168,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) {
@@ -205,51 +226,49 @@ export class PrivateEventStore implements StagedStore {
     });
   }
 
+  /** Returns the ids (siloed event commitments) of all events emitted at the given block number. Used by delete-on-prune. */
+  public async eventIdsAtBlock(blockNumber: number): Promise<string[]> {
+    const eventIds: string[] = [];
+    for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(blockNumber)) {
+      eventIds.push(eventId);
+    }
+    return eventIds;
+  }
+
   /**
-   * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
-   * number up to which PXE managed to sync before the reorg happened).
-   *
-   * We don't need staged writes for a rollback since it's handled in the context of a blockchain rewind.
-   *
-   * Rollbacks are handled by the BlockSynchronizer, which runs a DB transaction across stores when it detects a
-   * re-org, including setting the new anchor block after rolling back.
+   * Rolls the store back to `toBlock`: deletes every event anchored to a block strictly above it, as if nothing past
+   * that block height ever happened. Used by the reorg (`chain-pruned`) path to truncate the orphaned tail. Scanning
+   * from `toBlock + 1` upward covers everything above the rollback target without needing to know the chain tip.
    *
-   * So if anything fails in the process of rolling back any store, all DB changes occurring during rollbacks will be
-   * lost and the anchor block will not be updated; which means this code will eventually need to run again
-   * (i.e.: PXE will detect it's basing it work on an invalid block hash, then which re-triggers rewind).
-   *
-   * For further details, refer to `BlockSynchronizer#handleBlockStreamEvent`.
-   *
-   * IMPORTANT: This method must be called within a transaction to ensure atomicity.
+   * Must be called inside a transaction owned by the caller (it issues no `transactionAsync` of its own, the reorg
+   * path wraps it together with the anchor update, and IndexedDB has no nested transactions). Throws if any job has
+   * uncommitted staged writes, since rolling back mid-job could later re-introduce events anchored to deleted blocks.
    */
-  public async rollback(blockNumber: number, synchedBlockNumber: number): Promise<void> {
+  public async rollback(toBlock: number): Promise<void> {
+    if (this.#eventsForJob.size > 0) {
+      throw new Error('PXE private event store rollback is not allowed while jobs are running');
+    }
+    // Snapshot before mutating so we never delete from the multimap we are iterating.
+    const orphaned: { block: number; eventId: string }[] = [];
+    for await (const [block, eventId] of this.#eventsByBlockNumber.entriesAsync({ start: toBlock + 1 })) {
+      orphaned.push({ block, eventId });
+    }
     let removedCount = 0;
-
-    for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
-      const eventIds: string[] = await toArray(this.#eventsByBlockNumber.getValuesAsync(block));
-
-      if (eventIds.length > 0) {
-        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}`);
-          }
-
-          const entry = StoredPrivateEvent.fromBuffer(buffer);
-          await this.#events.delete(eventId);
-          await this.#eventsByContractAndEventSelector.deleteValue(
-            this.#keyFor(entry.contractAddress, entry.eventSelector),
-            eventId,
-          );
-
-          removedCount++;
-        }
+    for (const { block, eventId } of orphaned) {
+      const buf = await this.#events.getAsync(eventId);
+      if (!buf) {
+        throw new Error(`Event not found for eventId ${eventId}`);
       }
+      const stored = StoredPrivateEvent.fromBuffer(buf);
+      await this.#events.delete(eventId);
+      await this.#eventsByContractAndEventSelector.deleteValue(
+        this.#keyFor(stored.contractAddress, stored.eventSelector),
+        eventId,
+      );
+      await this.#eventsByBlockNumber.deleteValue(block, eventId);
+      removedCount++;
     }
-
-    this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
+    this.logger.verbose('rolled back private events', { removedCount, toBlock });
   }
 
   /**
@@ -262,28 +281,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 +313,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);
   }
 
   /**

package/src/storage/private_event_store/stored_private_event.ts

@@ -2,7 +2,7 @@ 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 { L2BlockHash } from '@aztec/stdlib/block';
+import { BlockHash } from '@aztec/stdlib/block';
 import { TxHash } from '@aztec/stdlib/tx';
 
 /** Serializable private event entry with scope tracking. */
@@ -11,7 +11,7 @@ export class StoredPrivateEvent {
     readonly randomness: Fr,
     readonly msgContent: Fr[],
     readonly l2BlockNumber: number,
-    readonly l2BlockHash: L2BlockHash,
+    readonly l2BlockHash: BlockHash,
     readonly txHash: TxHash,
     readonly txIndexInBlock: number,
     readonly eventIndexInTx: number,
@@ -49,7 +49,7 @@ export class StoredPrivateEvent {
     const msgContentLength = reader.readNumber();
     const msgContent = reader.readArray(msgContentLength, Fr);
     const l2BlockNumber = reader.readNumber();
-    const l2BlockHash = L2BlockHash.fromBuffer(reader);
+    const l2BlockHash = BlockHash.fromBuffer(reader);
     const txHash = TxHash.fromBuffer(reader);
     const txIndexInBlock = reader.readNumber();
     const eventIndexInTx = reader.readNumber();

package/src/storage/tagging_store/index.ts

@@ -1,3 +1,3 @@
 export { SenderTaggingStore } from './sender_tagging_store.js';
-export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { TaggingSecretSourcesStore } from './tagging_secret_sources_store.js';
 export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/src/storage/tagging_store/recipient_tagging_store.ts

@@ -1,5 +1,5 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { AppTaggingSecret } from '@aztec/stdlib/logs';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 
@@ -45,7 +45,11 @@ export class RecipientTaggingStore implements StagedStore {
   }
 
   async #readHighestAgedIndex(jobId: string, secret: string): Promise<number | undefined> {
-    return this.#getHighestAgedIndexForJob(jobId).get(secret) ?? (await this.#highestAgedIndex.getAsync(secret));
+    // 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 dbValue = await this.#highestAgedIndex.getAsync(secret);
+    const staged = this.#getHighestAgedIndexForJob(jobId).get(secret);
+    return staged ?? dbValue;
   }
 
   #writeHighestAgedIndex(jobId: string, secret: string, index: number) {
@@ -62,9 +66,11 @@ export class RecipientTaggingStore implements StagedStore {
   }
 
   async #readHighestFinalizedIndex(jobId: string, secret: string): Promise<number | undefined> {
-    return (
-      this.#getHighestFinalizedIndexForJob(jobId).get(secret) ?? (await this.#highestFinalizedIndex.getAsync(secret))
-    );
+    // 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 dbValue = await this.#highestFinalizedIndex.getAsync(secret);
+    const staged = this.#getHighestFinalizedIndexForJob(jobId).get(secret);
+    return staged ?? dbValue;
   }
 
   #writeHighestFinalizedIndex(jobId: string, secret: string, index: number) {
@@ -100,30 +106,34 @@ export class RecipientTaggingStore implements StagedStore {
     return Promise.resolve();
   }
 
-  getHighestAgedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
-    return this.#readHighestAgedIndex(jobId, secret.toString());
+  getHighestAgedIndex(secret: AppTaggingSecret, jobId: string): Promise<number | undefined> {
+    return this.#store.transactionAsync(() => this.#readHighestAgedIndex(jobId, secret.toString()));
   }
 
-  async updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
-    const currentIndex = await this.#readHighestAgedIndex(jobId, secret.toString());
-    if (currentIndex !== undefined && index <= currentIndex) {
-      // Log sync should never set a lower highest aged index.
-      throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
-    }
-    this.#writeHighestAgedIndex(jobId, secret.toString(), index);
+  updateHighestAgedIndex(secret: AppTaggingSecret, index: number, jobId: string): Promise<void> {
+    return this.#store.transactionAsync(async () => {
+      const currentIndex = await this.#readHighestAgedIndex(jobId, secret.toString());
+      if (currentIndex !== undefined && index <= currentIndex) {
+        // Log sync should never set a lower highest aged index.
+        throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
+      }
+      this.#writeHighestAgedIndex(jobId, secret.toString(), index);
+    });
   }
 
-  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
-    return this.#readHighestFinalizedIndex(jobId, secret.toString());
+  getHighestFinalizedIndex(secret: AppTaggingSecret, jobId: string): Promise<number | undefined> {
+    return this.#store.transactionAsync(() => this.#readHighestFinalizedIndex(jobId, secret.toString()));
   }
 
-  async updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
-    const currentIndex = await this.#readHighestFinalizedIndex(jobId, secret.toString());
-    if (currentIndex !== undefined && index < currentIndex) {
-      // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
-      // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
-      throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
-    }
-    this.#writeHighestFinalizedIndex(jobId, secret.toString(), index);
+  updateHighestFinalizedIndex(secret: AppTaggingSecret, index: number, jobId: string): Promise<void> {
+    return this.#store.transactionAsync(async () => {
+      const currentIndex = await this.#readHighestFinalizedIndex(jobId, secret.toString());
+      if (currentIndex !== undefined && index < currentIndex) {
+        // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
+        // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
+        throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
+      }
+      this.#writeHighestFinalizedIndex(jobId, secret.toString(), index);
+    });
   }
 }