@aztec/pxe 0.0.1-commit.0b941701 → 0.0.1-commit.0c875d939

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -1,6 +1,6 @@
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
@@ -56,13 +56,16 @@ export interface PrivateKernelExecutionProverConfig {
  * inform state tree updates.
  */
 export class PrivateKernelExecutionProver {
-  private log = createLogger('pxe:private-kernel-execution-prover');
+  private log: Logger;
 
   constructor(
     private oracle: PrivateKernelOracle,
     private proofCreator: PrivateKernelProver,
     private fakeProofs = false,
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('pxe:private-kernel-execution-prover', bindings);
+  }
 
   /**
    * Generate a proof for a given transaction request and execution result.

package/src/private_kernel/private_kernel_oracle.ts

@@ -7,7 +7,7 @@ import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-type
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
+import { BlockHash } from '@aztec/stdlib/block';
 import {
   type ContractInstanceWithAddress,
   computeContractClassIdPreimage,
@@ -30,7 +30,7 @@ export class PrivateKernelOracle {
     private contractStore: ContractStore,
     private keyStore: KeyStore,
     private node: AztecNode,
-    private blockHash: L2BlockHash,
+    private blockHash: BlockHash,
   ) {}
 
   /** Retrieves the preimage of a contract address from the registered contract instances db. */

package/src/pxe.ts

@@ -1,7 +1,7 @@
 import type { PrivateEventFilter } from '@aztec/aztec.js/wallet';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
@@ -33,6 +33,7 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import {
+  BlockHeader,
   type ContractOverrides,
   type InTx,
   PrivateExecutionResult,
@@ -51,6 +52,7 @@ import {
 
 import { inspect } from 'util';
 
+import type { AccessScopes } from './access_scopes.js';
 import { BlockSynchronizer } from './block_synchronizer/index.js';
 import type { PXEConfig } from './config/index.js';
 import { BenchmarkedNodeFactory } from './contract_function_simulator/benchmarked_node.js';
@@ -59,7 +61,8 @@ import {
   generateSimulatedProvingResult,
 } from './contract_function_simulator/contract_function_simulator.js';
 import { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
-import { ensureContractSynced, readCurrentClassId } from './contract_sync/index.js';
+import { ContractSyncService } from './contract_sync/contract_sync_service.js';
+import { readCurrentClassId } from './contract_sync/helpers.js';
 import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
 import { PrivateEventFilterValidator } from './events/private_event_filter_validator.js';
@@ -84,6 +87,56 @@ export type PackedPrivateEvent = InTx & {
   eventSelector: EventSelector;
 };
 
+/** Options for PXE.profileTx. */
+export type ProfileTxOpts = {
+  /** The profiling mode to use. */
+  profileMode: 'full' | 'execution-steps' | 'gates';
+  /** If true, proof generation is skipped during profiling. Defaults to true. */
+  skipProofGeneration?: boolean;
+  /** Addresses whose private state and keys are accessible during private execution. */
+  scopes: AccessScopes;
+};
+
+/** Options for PXE.simulateTx. */
+export type SimulateTxOpts = {
+  /** Whether to simulate the public part of the transaction. */
+  simulatePublic: boolean;
+  /** If false, this function throws if the transaction is unable to be included in a block at the current state. */
+  skipTxValidation?: boolean;
+  /** If false, fees are enforced. */
+  skipFeeEnforcement?: boolean;
+  /** State overrides for the simulation, such as contract instances and artifacts. */
+  overrides?: SimulationOverrides;
+  /** Addresses whose private state and keys are accessible during private execution */
+  scopes: AccessScopes;
+};
+
+/** Options for PXE.simulateUtility. */
+export type SimulateUtilityOpts = {
+  /** The authentication witnesses required for the function call. */
+  authwits?: AuthWitness[];
+  /** The accounts whose notes we can access in this call */
+  scopes: AccessScopes;
+};
+
+/** Args for PXE.create. */
+export type PXECreateArgs = {
+  /** The Aztec node to connect to. */
+  node: AztecNode;
+  /** The key-value store for persisting PXE state. */
+  store: AztecAsyncKVStore;
+  /** The prover for generating private kernel proofs. */
+  proofCreator: PrivateKernelProver;
+  /** The circuit simulator for executing ACIR circuits. */
+  simulator: CircuitSimulator;
+  /** Provider for protocol contract artifacts and instances. */
+  protocolContractsProvider: ProtocolContractsProvider;
+  /** PXE configuration options. */
+  config: PXEConfig;
+  /** Optional logger instance or string suffix for the logger name. */
+  loggerOrSuffix?: string | Logger;
+};
+
 /**
  * Private eXecution Environment (PXE) is a library used by wallets to simulate private phase of transactions and to
  * manage private state of users.
@@ -102,6 +155,7 @@ export class PXE {
     private recipientTaggingStore: RecipientTaggingStore,
     private addressStore: AddressStore,
     private privateEventStore: PrivateEventStore,
+    private contractSyncService: ContractSyncService,
     private simulator: CircuitSimulator,
     private proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
@@ -119,21 +173,27 @@ export class PXE {
    *
    * @returns A promise that resolves PXE is ready to be used.
    */
-  public static async create(
-    node: AztecNode,
-    store: AztecAsyncKVStore,
-    proofCreator: PrivateKernelProver,
-    simulator: CircuitSimulator,
-    protocolContractsProvider: ProtocolContractsProvider,
-    config: PXEConfig,
-    loggerOrSuffix?: string | Logger,
-  ) {
+  public static async create({
+    node,
+    store,
+    proofCreator,
+    simulator,
+    protocolContractsProvider,
+    config,
+    loggerOrSuffix,
+  }: PXECreateArgs) {
+    // Extract bindings from the logger, or use empty bindings if a string suffix is provided.
+    const bindings: LoggerBindings | undefined =
+      loggerOrSuffix && typeof loggerOrSuffix !== 'string' ? loggerOrSuffix.getBindings() : undefined;
+
     const log =
       !loggerOrSuffix || typeof loggerOrSuffix === 'string'
         ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`)
         : loggerOrSuffix;
 
-    const proverEnabled = !!config.proverEnabled;
+    const info = await node.getNodeInfo();
+
+    const proverEnabled = config.proverEnabled !== undefined ? config.proverEnabled : info.realProofs;
     const addressStore = new AddressStore(store);
     const privateEventStore = new PrivateEventStore(store);
     const contractStore = new ContractStore(store);
@@ -145,6 +205,12 @@ export class PXE {
     const capsuleStore = new CapsuleStore(store);
     const keyStore = new KeyStore(store);
     const tipsStore = new L2TipsKVStore(store, 'pxe');
+    const contractSyncService = new ContractSyncService(
+      node,
+      contractStore,
+      noteStore,
+      createLogger('pxe:contract_sync', bindings),
+    );
     const synchronizer = new BlockSynchronizer(
       node,
       store,
@@ -152,20 +218,22 @@ export class PXE {
       noteStore,
       privateEventStore,
       tipsStore,
+      contractSyncService,
       config,
-      loggerOrSuffix,
+      bindings,
     );
 
-    const jobCoordinator = new JobCoordinator(store);
+    const jobCoordinator = new JobCoordinator(store, bindings);
     jobCoordinator.registerStores([
       capsuleStore,
       senderTaggingStore,
       recipientTaggingStore,
       privateEventStore,
       noteStore,
+      contractSyncService,
     ]);
 
-    const debugUtils = new PXEDebugUtils(contractStore, noteStore);
+    const debugUtils = new PXEDebugUtils(contractSyncService, noteStore, synchronizer, anchorBlockStore);
 
     const jobQueue = new SerialQueue();
 
@@ -182,6 +250,7 @@ export class PXE {
       recipientTaggingStore,
       addressStore,
       privateEventStore,
+      contractSyncService,
       simulator,
       proverEnabled,
       proofCreator,
@@ -192,12 +261,15 @@ export class PXE {
       debugUtils,
     );
 
-    debugUtils.setPXE(pxe);
+    debugUtils.setPXEHelpers(
+      pxe.#putInJobQueue.bind(pxe),
+      pxe.#getSimulatorForTx.bind(pxe),
+      pxe.#simulateUtility.bind(pxe),
+    );
 
     pxe.jobQueue.start();
 
     await pxe.#registerProtocolContracts();
-    const info = await node.getNodeInfo();
     log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
     return pxe;
   }
@@ -207,20 +279,20 @@ export class PXE {
   #getSimulatorForTx(overrides?: { contracts?: ContractOverrides }) {
     const proxyContractStore = ProxiedContractStoreFactory.create(this.contractStore, overrides?.contracts);
 
-    return new ContractFunctionSimulator(
-      proxyContractStore,
-      this.noteStore,
-      this.keyStore,
-      this.addressStore,
-      BenchmarkedNodeFactory.create(this.node),
-      this.anchorBlockStore,
-      this.senderTaggingStore,
-      this.recipientTaggingStore,
-      this.senderAddressBookStore,
-      this.capsuleStore,
-      this.privateEventStore,
-      this.simulator,
-    );
+    return new ContractFunctionSimulator({
+      contractStore: proxyContractStore,
+      noteStore: this.noteStore,
+      keyStore: this.keyStore,
+      addressStore: this.addressStore,
+      aztecNode: BenchmarkedNodeFactory.create(this.node),
+      senderTaggingStore: this.senderTaggingStore,
+      recipientTaggingStore: this.recipientTaggingStore,
+      senderAddressBookStore: this.senderAddressBookStore,
+      capsuleStore: this.capsuleStore,
+      privateEventStore: this.privateEventStore,
+      simulator: this.simulator,
+      contractSyncService: this.contractSyncService,
+    });
   }
 
   #contextualizeError(err: Error, ...context: string[]): Error {
@@ -286,7 +358,7 @@ export class PXE {
   async #executePrivate(
     contractFunctionSimulator: ContractFunctionSimulator,
     txRequest: TxExecutionRequest,
-    scopes: AztecAddress[] | undefined,
+    scopes: AccessScopes,
     jobId: string,
   ): Promise<PrivateExecutionResult> {
     const { origin: contractAddress, functionSelector } = txRequest;
@@ -294,27 +366,23 @@ export class PXE {
     try {
       const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
 
-      await ensureContractSynced(
+      await this.contractSyncService.ensureContractSynced(
         contractAddress,
         functionSelector,
-        privateSyncCall => this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
-        this.node,
-        this.contractStore,
+        (privateSyncCall, execScopes) =>
+          this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
         anchorBlockHeader,
+        jobId,
+        scopes,
       );
 
-      const result = await contractFunctionSimulator.run(
-        txRequest,
+      const result = await contractFunctionSimulator.run(txRequest, {
         contractAddress,
-        functionSelector,
-        undefined,
+        selector: functionSelector,
         anchorBlockHeader,
-        // The sender for tags is set by contracts, typically by an account
-        // contract entrypoint
-        undefined, // senderForTags
         scopes,
         jobId,
-      );
+      });
       this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
       return result;
     } catch (err) {
@@ -339,7 +407,7 @@ export class PXE {
     contractFunctionSimulator: ContractFunctionSimulator,
     call: FunctionCall,
     authWitnesses: AuthWitness[] | undefined,
-    scopes: AztecAddress[] | undefined,
+    scopes: AccessScopes,
     jobId: string,
   ) {
     try {
@@ -400,13 +468,31 @@ export class PXE {
     const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
     const anchorBlockHash = await anchorBlockHeader.hash();
     const kernelOracle = new PrivateKernelOracle(this.contractStore, this.keyStore, this.node, anchorBlockHash);
-    const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
+    const kernelTraceProver = new PrivateKernelExecutionProver(
+      kernelOracle,
+      proofCreator,
+      !this.proverEnabled,
+      this.log.getBindings(),
+    );
     this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
     return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
   }
 
   // Public API
 
+  /**
+   * Returns the block header up to which the PXE has synced.
+   * @returns The synced block header
+   */
+  public getSyncedBlockHeader(): Promise<BlockHeader> {
+    return this.anchorBlockStore.getBlockHeader();
+  }
+
+  /**
+   * Returns the contract instance for a given address, if it's registered in the PXE.
+   * @param address - The contract address.
+   * @returns The contract instance if found, undefined otherwise.
+   */
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return this.contractStore.getContractInstance(address);
   }
@@ -620,11 +706,12 @@ export class PXE {
    * (where validators prove the public portion).
    *
    * @param txRequest - An authenticated tx request ready for proving
+   * @param scopes - Addresses whose private state and keys are accessible during private execution.
    * @returns A result containing the proof and public inputs of the tail circuit.
    * @throws If contract code not found, or public simulation reverts.
    * Also throws if simulatePublic is true and public simulation reverts.
    */
-  public proveTx(txRequest: TxExecutionRequest): Promise<TxProvingResult> {
+  public proveTx(txRequest: TxExecutionRequest, scopes: AztecAddress[]): Promise<TxProvingResult> {
     let privateExecutionResult: PrivateExecutionResult;
     // We disable proving concurrently mostly out of caution, since it accesses some of our stores. Proving is so
     // computationally demanding that it'd be rare for someone to try to do it concurrently regardless.
@@ -635,7 +722,7 @@ export class PXE {
         await this.blockStateSynchronizer.sync();
         const syncTime = syncTimer.ms();
         const contractFunctionSimulator = this.#getSimulatorForTx();
-        privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, undefined, jobId);
+        privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes, jobId);
 
         const {
           publicInputs,
@@ -699,17 +786,13 @@ export class PXE {
 
   /**
    * Profiles a transaction, reporting gate counts (unless disabled) and returns an execution trace.
-   *
-   * @param txRequest - An authenticated tx request ready for simulation
-   * @param msgSender - (Optional) The message sender to use for the simulation.
-   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @param txRequest - An authenticated tx request ready for simulation.
    * @returns A trace of the program execution with gate counts.
    * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
    */
   public profileTx(
     txRequest: TxExecutionRequest,
-    profileMode: 'full' | 'execution-steps' | 'gates',
-    skipProofGeneration: boolean = true,
+    { profileMode, skipProofGeneration = true, scopes }: ProfileTxOpts,
   ): Promise<TxProfileResult> {
     // We disable concurrent profiles for consistency with simulateTx.
     return this.#putInJobQueue(async jobId => {
@@ -732,12 +815,7 @@ export class PXE {
         const syncTime = syncTimer.ms();
 
         const contractFunctionSimulator = this.#getSimulatorForTx();
-        const privateExecutionResult = await this.#executePrivate(
-          contractFunctionSimulator,
-          txRequest,
-          undefined,
-          jobId,
-        );
+        const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes, jobId);
 
         const { executionSteps, timings: { proving } = {} } = await this.#prove(
           txRequest,
@@ -794,12 +872,7 @@ export class PXE {
    * In that case, the transaction returned is only potentially ready to be sent to the network for execution.
    *
    *
-   * @param txRequest - An authenticated tx request ready for simulation
-   * @param simulatePublic - Whether to simulate the public part of the transaction.
-   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
-   * @param skipFeeEnforcement - (Optional) If false, fees are enforced.
-   * @param overrides - (Optional) State overrides for the simulation, such as msgSender, contract instances and artifacts.
-   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @param txRequest - An authenticated tx request ready for simulation.
    * @returns A simulated transaction result object that includes public and private return values.
    * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
    * Also throws if simulatePublic is true and public simulation reverts.
@@ -808,11 +881,7 @@ export class PXE {
    */
   public simulateTx(
     txRequest: TxExecutionRequest,
-    simulatePublic: boolean,
-    skipTxValidation: boolean = false,
-    skipFeeEnforcement: boolean = false,
-    overrides?: SimulationOverrides,
-    scopes?: AztecAddress[],
+    { simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes }: SimulateTxOpts,
   ): Promise<TxSimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
     // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
@@ -840,7 +909,14 @@ export class PXE {
         // Temporary: in case there are overrides, we have to skip the kernels or validations
         // will fail. Consider handing control to the user/wallet on whether they want to run them
         // or not.
-        const skipKernels = overrides?.contracts !== undefined && Object.keys(overrides.contracts ?? {}).length > 0;
+        const overriddenContracts = overrides?.contracts ? new Set(Object.keys(overrides.contracts)) : undefined;
+        const hasOverriddenContracts = overriddenContracts !== undefined && overriddenContracts.size > 0;
+        const skipKernels = hasOverriddenContracts;
+
+        // Set overridden contracts on the sync service so it knows to skip syncing them
+        if (hasOverriddenContracts) {
+          this.contractSyncService.setOverriddenContracts(jobId, overriddenContracts);
+        }
 
         // Execution of private functions only; no proving, and no kernel logic.
         const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes, jobId);
@@ -851,7 +927,8 @@ export class PXE {
         if (skipKernels) {
           ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(
             privateExecutionResult,
-            this.contractStore,
+            (addr, sel) => this.contractStore.getDebugFunctionName(addr, sel),
+            this.node,
           ));
         } else {
           // Kernel logic, plus proving of all private functions and kernels.
@@ -929,25 +1006,19 @@ export class PXE {
           inspect(txRequest),
           `simulatePublic=${simulatePublic}`,
           `skipTxValidation=${skipTxValidation}`,
-          `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+          `scopes=${scopes === 'ALL_SCOPES' ? scopes : scopes.map(s => s.toString()).join(', ')}`,
         );
       }
     });
   }
 
   /**
-   * Simulate the execution of a contract utility function.
-   *
+   * Simulates the execution of a contract utility function.
    * @param call - The function call containing the function details, arguments, and target contract address.
-   * @param authwits - (Optional) The authentication witnesses required for the function call.
-   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will
-   * default to all.
-   * @returns The result of the utility function call, structured based on the function ABI.
    */
   public simulateUtility(
     call: FunctionCall,
-    authwits?: AuthWitness[],
-    scopes?: AztecAddress[],
+    { authwits, scopes }: SimulateUtilityOpts = { scopes: 'ALL_SCOPES' },
   ): Promise<UtilitySimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
     // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
@@ -962,13 +1033,14 @@ export class PXE {
         const contractFunctionSimulator = this.#getSimulatorForTx();
 
         const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-        await ensureContractSynced(
+        await this.contractSyncService.ensureContractSynced(
           call.to,
           call.selector,
-          privateSyncCall => this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
-          this.node,
-          this.contractStore,
+          (privateSyncCall, execScopes) =>
+            this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
           anchorBlockHeader,
+          jobId,
+          scopes,
         );
 
         const executionResult = await this.#simulateUtility(
@@ -999,7 +1071,7 @@ export class PXE {
         throw this.#contextualizeError(
           err,
           `simulateUtility ${to}:${name}(${stringifiedArgs})`,
-          `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+          `scopes=${scopes === 'ALL_SCOPES' ? scopes : scopes.map(s => s.toString()).join(', ')}`,
         );
       }
     });
@@ -1032,14 +1104,14 @@ export class PXE {
 
       const contractFunctionSimulator = this.#getSimulatorForTx();
 
-      await ensureContractSynced(
+      await this.contractSyncService.ensureContractSynced(
         filter.contractAddress,
         null,
-        async privateSyncCall =>
-          await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
-        this.node,
-        this.contractStore,
+        async (privateSyncCall, execScopes) =>
+          await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
         anchorBlockHeader,
+        jobId,
+        filter.scopes,
       );
     });
 

package/src/storage/address_store/address_store.ts

@@ -43,23 +43,23 @@ export class AddressStore {
     });
   }
 
-  async #getCompleteAddress(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const index = await this.#completeAddressIndex.getAsync(address.toString());
-    if (index === undefined) {
-      return undefined;
-    }
-
-    const value = await this.#completeAddresses.atAsync(index);
-    return value ? await CompleteAddress.fromBuffer(value) : undefined;
-  }
-
   getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.#getCompleteAddress(account);
+    return this.#store.transactionAsync(async () => {
+      const index = await this.#completeAddressIndex.getAsync(account.toString());
+      if (index === undefined) {
+        return undefined;
+      }
+
+      const value = await this.#completeAddresses.atAsync(index);
+      return value ? await CompleteAddress.fromBuffer(value) : undefined;
+    });
   }
 
-  async getCompleteAddresses(): Promise<CompleteAddress[]> {
-    return await Promise.all(
-      (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
-    );
+  getCompleteAddresses(): Promise<CompleteAddress[]> {
+    return this.#store.transactionAsync(async () => {
+      return await Promise.all(
+        (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
+      );
+    });
   }
 }

package/src/storage/anchor_block_store/anchor_block_store.ts

@@ -10,6 +10,14 @@ export class AnchorBlockStore {
     this.#synchronizedHeader = this.#store.openSingleton('header');
   }
 
+  /**
+   * Sets the currently synchronized block
+   *
+   * Important: this method is only called from BlockSynchronizer, and since we need it to run atomically with other
+   * stores in the case of a reorg, it MUST NOT be wrapped in a `transactionAsync` call. Doing so would result in a
+   * deadlock when the backend is IndexedDB, because `transactionAsync` is not designed to support reentrancy.
+   *
+   */
   async setHeader(header: BlockHeader): Promise<void> {
     await this.#synchronizedHeader.set(header.toBuffer());
   }

package/src/storage/capsule_store/capsule_store.ts

@@ -57,14 +57,14 @@ export class CapsuleStore implements StagedStore {
    */
   async #getFromStage(jobId: string, dbSlotKey: string): Promise<Buffer | null | undefined> {
     const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
-    let staged: Buffer | null | undefined = jobStagedCapsules.get(dbSlotKey);
-    // Note that if staged === null, we marked it for deletion, so we don't want to
-    // re-read it from DB
-    if (staged === undefined) {
-      // If we don't have a staged version of this dbSlotKey, first we check if there's one in DB
-      staged = await this.#loadCapsuleFromDb(dbSlotKey);
-    }
-    return staged;
+    const staged: Buffer | null | undefined = jobStagedCapsules.get(dbSlotKey);
+
+    // Always issue DB read to keep IndexedDB transaction alive, even if the value is in the job staged data. This
+    // keeps IndexedDB transactions 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 (including null for deletions).
+    const dbValue = await this.#loadCapsuleFromDb(dbSlotKey);
+
+    return staged !== undefined ? staged : dbValue;
   }
 
   /**