@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/block_synchronizer/block_synchronizer.ts

@@ -0,0 +1,241 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { L2TipsKVStore } from '@aztec/kv-store/stores';
+import { BlockHash, L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { BlockSynchronizerConfig } from '../config/index.js';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractSyncService } from '../contract/contract_sync_service.js';
+import type { AnchorBlockStore } from '../storage/anchor_block_store/index.js';
+import type { FactStore } from '../storage/fact_store/fact_store.js';
+import type { NoteStore } from '../storage/note_store/index.js';
+import type { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
+
+/**
+ * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
+ * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
+ * for querying sync status.
+ */
+export class BlockSynchronizer implements L2BlockStreamEventHandler {
+  private log: Logger;
+  private isSyncing: Promise<void> | undefined;
+  private readonly eventQueue = new SerialQueue();
+  protected readonly blockStream: L2BlockStream;
+
+  constructor(
+    private readonly node: AztecNode,
+    private readonly store: AztecAsyncKVStore,
+    private readonly anchorBlockStore: AnchorBlockStore,
+    private readonly noteStore: NoteStore,
+    private readonly privateEventStore: PrivateEventStore,
+    private readonly factStore: FactStore,
+    private readonly l2TipsStore: L2TipsKVStore,
+    private readonly contractSyncService: ContractSyncService,
+    private readonly contractClassService: ContractClassService,
+    private readonly config: Partial<BlockSynchronizerConfig> = {},
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('pxe:block_synchronizer', bindings);
+    this.blockStream = this.createBlockStream();
+    this.eventQueue.start();
+  }
+
+  protected createBlockStream(): L2BlockStream {
+    return new L2BlockStream(
+      blockStreamSourceFromAztecNode(this.node),
+      this.l2TipsStore,
+      this,
+      createLogger('pxe:block_stream', this.log.getBindings()),
+      {
+        // PXE only tracks chain tips (it anchors on tip events and never replays payloads), so the stream runs
+        // in tips-only mode: no block downloads, just the tip events that move the anchor and detect reorgs.
+        tipsOnly: true,
+      },
+    );
+  }
+
+  /** Handle events emitted by the block stream. Serialized to prevent concurrent mutations to anchor state. */
+  public handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    return this.eventQueue.put(() => this.doHandleBlockStreamEvent(event));
+  }
+
+  private async doHandleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    switch (event.type) {
+      case 'chain-proposed': {
+        if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
+          // Fetch the proposed tip header by hash. By-hash is safer than by-number against a same-height reorg.
+          const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
+          if (!block) {
+            // The node served a proposed tip whose block data it cannot return — a node inconsistency, since the
+            // stream events and the block data come from the same node (same reasoning as the chain-pruned throw
+            // below). Throwing here propagates before the tips-store cursor advances, so the cursor stays put and the
+            // next sync re-emits chain-proposed (at-least-once). Were we to warn-and-skip, the cursor would advance and
+            // a quiet chain would never re-emit, leaving the anchor stale indefinitely.
+            throw new Error(
+              `Block header for proposed block ${event.block.number} and hash ${event.block.hash} not found. This ` +
+                `likely indicates a bug in the node, as we receive block stream events and fetch block headers from ` +
+                `the same node.`,
+            );
+          }
+          await this.updateAnchorBlockHeader(block.header);
+        }
+        break;
+      }
+      // Never emitted in tips-only mode; PXE anchors on chain-proposed instead. Kept for union exhaustiveness.
+      case 'blocks-added':
+        break;
+      case 'chain-checkpointed': {
+        if (this.config.syncChainTip === 'checkpointed') {
+          // Fetch the checkpointed tip header by hash. By-hash is safer than by-number against a
+          // same-height reorg; a missing result means the block was reorged out between the event
+          // and this fetch, so we skip the anchor update and let a later event correct it.
+          const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
+          if (block) {
+            await this.updateAnchorBlockHeader(block.header);
+          } else {
+            this.log.warn(
+              `Block header not found for checkpointed block ${event.block.number}, skipping anchor update`,
+            );
+          }
+        }
+        break;
+      }
+      case 'chain-proven': {
+        if (this.config.syncChainTip === 'proven') {
+          const block = await this.node.getBlock(BlockNumber(event.block.number));
+          if (block) {
+            await this.updateAnchorBlockHeader(block.header);
+          } else {
+            this.log.warn(`Block header not found for proven block ${event.block.number}, skipping anchor update`);
+          }
+        }
+        break;
+      }
+      case 'chain-finalized': {
+        if (this.config.syncChainTip === 'finalized') {
+          const block = await this.node.getBlock(BlockNumber(event.block.number));
+          if (block) {
+            await this.updateAnchorBlockHeader(block.header);
+          } else {
+            this.log.warn(`Block header not found for finalized block ${event.block.number}, skipping anchor update`);
+          }
+        }
+        break;
+      }
+      case 'chain-pruned': {
+        const currentAnchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+        const currentAnchorBlockNumber = currentAnchorBlockHeader.getBlockNumber();
+        if (currentAnchorBlockNumber <= event.block.number) {
+          this.log.verbose(
+            `Ignoring prune event to block ${event.block.number} greater than current anchor block ${currentAnchorBlockNumber}`,
+            { pruneEvent: event, currentAnchorBlockHeader: currentAnchorBlockHeader.toInspect() },
+          );
+          break;
+        }
+
+        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`, { pruneBlock: event.block });
+
+        // Note that the following is not necessarily the anchor block that will be used in the transaction - if
+        // the chain has already moved past the reorg, we'll also see blocks-added events that will push the anchor
+        // forward.
+        const newAnchorBlock = await this.node.getBlock(BlockHash.fromString(event.block.hash));
+        const newAnchorBlockHeader = newAnchorBlock?.header;
+
+        if (!newAnchorBlockHeader) {
+          throw new Error(
+            `Block header for block number ${event.block.number} and hash ${event.block.hash} not found during chain prune. This likely indicates a bug in the node, as we receive block stream events and fetch block headers from the same node.`,
+          );
+        }
+
+        // Operations are wrapped in a single transaction to ensure atomicity.
+        await this.store.transactionAsync(async () => {
+          await this.noteStore.rollback(event.block.number);
+          await this.privateEventStore.rollback(event.block.number);
+          await this.factStore.rollback(event.block.number);
+          await this.updateAnchorBlockHeader(newAnchorBlockHeader);
+        });
+        break;
+      }
+      default: {
+        const _: never = event;
+        break;
+      }
+    }
+
+    // Advance the tips store cursor only after the anchor update / prune rollback above succeeds. If that work
+    // throws, the cursor stays put and the stream re-emits this event on the next sync pass (at-least-once),
+    // matching the prover-node's handle-first/tips-last ordering. The SerialQueue makes this reorder safe.
+    await this.l2TipsStore.handleBlockStreamEvent(event);
+  }
+
+  /** Updates the anchor block header to the target block */
+  private async updateAnchorBlockHeader(blockHeader: BlockHeader) {
+    // Whenever the anchor block header is updated, we need to synchronize the private state of contracts again.
+    // Therefore, we clear the contract synchronization cache here such that the sync is re-triggered upon new
+    // execution.
+    this.contractSyncService.wipe();
+
+    // The contract class service keeps a per-block cache - since updating our anchor means it is very unlikely we'd
+    // ever re-simulate at past anchors, we wipe its cache to prevent runaway memory growth on very long-lived PXE
+    // instances.
+    this.contractClassService.wipe();
+
+    this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
+    await this.anchorBlockStore.setHeader(blockHeader);
+  }
+
+  /**
+   * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
+   * recent data (e.g. notes), and handling any reorgs that might have occurred.
+   *
+   * Note this BlockSynchronizer is designed to let its users control when a synchronization is run,
+   * so this component doesn't proactively stay up to date with the blockchain.
+   *
+   * We do this so PXE can ensure data consistency.
+   */
+  public async sync() {
+    if (this.isSyncing !== undefined) {
+      this.log.debug(`Waiting for the ongoing sync to finish`);
+      await this.isSyncing;
+      return;
+    }
+
+    this.log.debug(`Syncing PXE with the node`);
+    // Capture the promise locally so we always await the exact promise we created, even if this.isSyncing is modified
+    // between assignment and await (e.g. due to future refactors introducing a yield point).
+    const isSyncing = this.doSync();
+    this.isSyncing = isSyncing;
+    try {
+      await isSyncing;
+    } finally {
+      this.isSyncing = undefined;
+    }
+  }
+
+  /** Stops the block synchronizer, waiting for any in-progress sync and queued events to complete. */
+  public async stop() {
+    await this.isSyncing;
+    await this.blockStream.stop();
+    await this.eventQueue.end();
+  }
+
+  private async doSync() {
+    let currentHeader;
+
+    try {
+      currentHeader = await this.anchorBlockStore.getBlockHeader();
+    } catch {
+      this.log.debug('Header is not set, requesting from the node');
+    }
+    if (!currentHeader) {
+      // REFACTOR: We should know the header of the genesis block without having to request it from the node.
+      await this.anchorBlockStore.setHeader((await this.node.getBlockData(BlockNumber.ZERO))!.header);
+    }
+    await this.blockStream.sync();
+  }
+}

package/src/block_synchronizer/index.ts

@@ -0,0 +1 @@
+export * from './block_synchronizer.js';

package/src/config/index.ts

@@ -1,23 +1,16 @@
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
+  enumConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
   parseBooleanEnv,
 } from '@aztec/foundation/config';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 
 export { getPackageInfo } from './package_info.js';
-
-/**
- * Temporary configuration until WASM can be used instead of native
- */
-export interface BBProverConfig {
-  bbWorkingDirectory?: string;
-  bbBinaryPath?: string;
-  bbSkipCleanup?: boolean;
-}
+export * from '../hooks/index.js';
 
 /**
  * Configuration settings for the prover factory
@@ -28,14 +21,22 @@ export interface KernelProverConfig {
 }
 
 /**
- * Configuration settings for the synchronizer.
+ * Configuration settings for the block synchronizer.
  */
-export interface SynchronizerConfig {
+export interface BlockSynchronizerConfig {
   /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
   l2BlockBatchSize: number;
+  /** Which chain tip to sync to (proposed, checkpointed, proven, finalized) */
+  syncChainTip?: 'proposed' | 'checkpointed' | 'proven' | 'finalized';
+  /**
+   * Whether PXE should automatically sync with the node before each operation (simulate, prove, profile,
+   * execute utility, get private events, update contract). When disabled, callers (e.g. wallets) are
+   * responsible for calling `pxe.sync()` explicitly
+   */
+  autoSync: boolean;
 }
 
-export type PXEConfig = KernelProverConfig & BBProverConfig & DataStoreConfig & ChainConfig & SynchronizerConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 
 export type CliPXEOptions = {
   /** Custom Aztec Node URL to connect to  */
@@ -50,24 +51,29 @@ export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
     ...numberConfigHelper(50),
     description: 'Maximum amount of blocks to pull from the stream in one request when synchronizing',
   },
-  bbBinaryPath: {
-    env: 'BB_BINARY_PATH',
-    description: 'Path to the BB binary',
-  },
-  bbWorkingDirectory: {
-    env: 'BB_WORKING_DIRECTORY',
-    description: 'Working directory for the BB binary',
-  },
-  bbSkipCleanup: {
-    env: 'BB_SKIP_CLEANUP',
-    description: 'True to skip cleanup of temporary files for debugging purposes',
-    ...booleanConfigHelper(),
-  },
+  // TODO: We're losing this feature in moving to bb.js api.
+  // Reimplement it as a setting that dumps the msgpack data on the bb.js backend if needed.
+  // bbSkipCleanup: {
+  //   env: 'BB_SKIP_CLEANUP',
+  //   description: 'True to skip cleanup of temporary files for debugging purposes',
+  //   ...booleanConfigHelper(),
+  // },
   proverEnabled: {
     env: 'PXE_PROVER_ENABLED',
     description: 'Enable real proofs',
     ...booleanConfigHelper(true),
   },
+  syncChainTip: {
+    env: 'PXE_SYNC_CHAIN_TIP',
+    description: 'Which chain tip to sync to (proposed, checkpointed, proven, finalized)',
+    ...enumConfigHelper(['proposed', 'checkpointed', 'proven', 'finalized'], 'proposed'),
+  },
+  autoSync: {
+    env: 'PXE_AUTO_SYNC',
+    description:
+      'Whether PXE syncs with the node automatically before each operation. Disable to let the caller (e.g. a wallet) drive syncs explicitly via pxe.sync().',
+    ...booleanConfigHelper(true),
+  },
 };
 
 /**

package/src/config/package_info.ts

@@ -1,3 +1,3 @@
 export function getPackageInfo() {
-  return { version: '3.0.0', name: '@aztec/pxe' };
+  return { version: '6.0.0', name: '@aztec/pxe' };
 }

package/src/contract/contract_class_service.ts

@@ -0,0 +1,83 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Resolves the contract class id that an address runs at a given anchor block, as tracked by the chain.
+ *
+ * PXE does not store a contract's current class id: it is mutable, chain-derived state that changes when a contract is
+ * upgraded and can be undone by a reorg. Instead this service asks the node for the current class at an anchor block,
+ * falling back to a local instance if no upgrades were scheduled.
+ */
+export class ContractClassService {
+  /**
+   * Class ids are cached per `(address, anchorHash)`. This avoid unnecessary network roundtrips in scenarios where
+   * multiple executions are done on the same anchor block (e.g. simulation followed by witgen), or when the same
+   * contract is invoked multiple times in an execution (e.g. authwit checks).
+   * It also means the callers don't need to worry about caching this service's return values, simplifying callsites.
+   */
+  #cache: Map<string, Promise<Fr | undefined>> = new Map();
+
+  constructor(
+    private node: AztecNode,
+    private contractStore: ContractStore,
+  ) {}
+
+  /**
+   * Returns the class id that corresponds to `address` as of `anchorBlockHeader`, or `undefined` if no instance is
+   * registered for `address`. A missing instance is an absence the caller decides how to handle, not an error; genuine
+   * failures (e.g. the node being unreachable) still throw.
+   */
+  async getCurrentClassId(address: AztecAddress, anchorBlockHeader: BlockHeader): Promise<Fr | undefined> {
+    // Protocol contracts are not in the registry and cannot be upgraded, so their original class is always current.
+    // Short-circuiting avoids a node round-trip.
+    if (isProtocolContract(address)) {
+      const instance = await this.contractStore.getContractInstance(address);
+      return instance?.originalContractClassId;
+    }
+
+    const key = `${address.toString()}:${(await anchorBlockHeader.hash()).toString()}`;
+    let promise = this.#cache.get(key);
+    if (!promise) {
+      promise = (async () => {
+        // The node resolves the current class from the same scheduled value change the AVM enforces against the public
+        // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means
+        // no upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original
+        // class is current.
+
+        const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
+
+        if (nodeInstance) {
+          return nodeInstance.currentContractClassId;
+        } else {
+          return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
+        }
+      })().catch(err => {
+        this.#cache.delete(key);
+        throw err;
+      });
+      this.#cache.set(key, promise);
+    }
+
+    const classId = await promise;
+    if (classId === undefined) {
+      // Don't memoize a missing instance: it may be registered later in this PXE (e.g. via contract sync
+      // mid-execution), and a cached miss would then hide it. Only successful resolutions stay cached.
+      this.#cache.delete(key);
+    }
+    return classId;
+  }
+
+  /**
+   * Clears the cache.
+   *
+   * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
+   * reorgs etc. as it is based on block hashes, not block numbers. */
+  wipe(): void {
+    this.#cache.clear();
+  }
+}

package/src/contract/contract_sync_service.ts

@@ -0,0 +1,176 @@
+import type { Logger } from '@aztec/foundation/log';
+import { Semaphore } from '@aztec/foundation/queue';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { StagedStore } from '../job_coordinator/job_coordinator.js';
+import { NoteService } from '../notes/note_service.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+import type { ContractClassService } from './contract_class_service.js';
+import { syncScope } from './helpers.js';
+
+/**
+ * Maximum number of scope syncs running concurrently within a single sync call. Sized to trade off parallelism
+ * on non-ACIR work (node RPC, note store reads) against memory pressure from concurrent circuit execution.
+ */
+export const MAX_CONCURRENT_SCOPE_SYNCS = 5;
+
+/**
+ * Service for syncing the private state of contracts. It uses a cache to avoid redundant sync operations - the cache
+ * is wiped when the anchor block changes.
+ *
+ * TODO: The StagedStore naming is broken here. Figure out a better name.
+ */
+export class ContractSyncService implements StagedStore {
+  readonly storeName = 'contract_sync';
+
+  // Tracks contracts synced since last wipe. The cache is keyed per individual scope address
+  // (`contractAddress:scopeAddress`), or `contractAddress:*` for all scopes (all accounts).
+  // The value is a promise that resolves when the contract is synced.
+  private syncedContracts: Map<string, Promise<void>> = new Map();
+
+  constructor(
+    private aztecNode: AztecNode,
+    private contractStore: ContractStore,
+    private contractClassService: ContractClassService,
+    private noteStore: NoteStore,
+    private log: Logger,
+  ) {}
+
+  /**
+   * Ensures a contract's private state is synchronized.
+   * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+   * @param contractAddress - The address of the contract to sync.
+   * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
+   * not sync_state itself).
+   * @param utilityExecutor - Executor function for running the sync_state utility function.
+   * @param scopes - Access scopes to pass through to the utility executor (affects whose account's private state is discovered).
+   */
+  async ensureContractSynced(
+    contractAddress: AztecAddress,
+    functionToInvokeAfterSync: FunctionSelector | null,
+    utilityExecutor: (call: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
+    anchorBlockHeader: BlockHeader,
+    jobId: string,
+    scopes: AztecAddress[],
+  ): Promise<void> {
+    this.#startSyncIfNeeded(contractAddress, scopes, anchorBlockHeader, jobId, scope =>
+      syncScope(
+        contractAddress,
+        this.contractStore,
+        this.contractClassService,
+        anchorBlockHeader,
+        functionToInvokeAfterSync,
+        utilityExecutor,
+        scope,
+      ),
+    );
+
+    await this.#awaitSync(contractAddress, scopes);
+  }
+
+  /** Clears sync cache entries for the given scopes of a contract. */
+  invalidateContractForScopes(contractAddress: AztecAddress, scopes: AztecAddress[]): void {
+    if (scopes.length === 0) {
+      return;
+    }
+    scopes.forEach(scope => this.syncedContracts.delete(toKey(contractAddress, scope)));
+  }
+
+  /** Clears sync cache. Called by BlockSynchronizer when anchor block changes. */
+  wipe(): void {
+    this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
+    this.syncedContracts.clear();
+  }
+
+  commit(_jobId: string): Promise<void> {
+    return Promise.resolve();
+  }
+
+  discardStaged(_jobId: string): Promise<void> {
+    // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
+    // the sync are also undone.
+    this.syncedContracts.clear();
+    return Promise.resolve();
+  }
+
+  /**
+   * For each unsynced scope, creates a promise that waits on:
+   *  1. Note nullifier sync (shared, batched across all unsynced scopes).
+   *  2. Per-scope sync (individual, semaphore-bounded).
+   */
+  #startSyncIfNeeded(
+    contractAddress: AztecAddress,
+    scopes: AztecAddress[],
+    anchorBlockHeader: BlockHeader,
+    jobId: string,
+    syncScopeFn: (scope: AztecAddress) => Promise<void>,
+  ): void {
+    const scopesToSync = scopes.filter(scope => !this.syncedContracts.has(toKey(contractAddress, scope)));
+    if (scopesToSync.length === 0) {
+      return;
+    }
+
+    this.log.debug(`Syncing contract ${contractAddress} for ${scopesToSync.length} scope(s)`);
+
+    const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopesToSync);
+
+    // We build a new semaphore for each sync call, so it rate-limits the scopes within that single call. We do
+    // this so that if these scope syncs trigger nested syncs, the nested ones can execute without causing a deadlock.
+    const syncSlot = new Semaphore(MAX_CONCURRENT_SCOPE_SYNCS);
+
+    for (const scope of scopesToSync) {
+      const key = toKey(contractAddress, scope);
+      const promise = Promise.all([syncNullifiersPromise, runBounded(syncSlot, () => syncScopeFn(scope))])
+        .then(() => {})
+        .catch(err => {
+          this.syncedContracts.delete(key);
+          throw err;
+        });
+      this.syncedContracts.set(key, promise);
+    }
+  }
+
+  /** Syncs note nullifiers across all unsynced scopes in a single batched call. */
+  async #syncNoteNullifiers(
+    contractAddress: AztecAddress,
+    anchorBlockHeader: BlockHeader,
+    jobId: string,
+    scopes: AztecAddress[],
+  ): Promise<void> {
+    // Protocol contracts don't have private state to sync
+    if (isProtocolContract(contractAddress)) {
+      return;
+    }
+    // This runs in parallel with per-scope sync (which also writes to the note store). That's safe because
+    // the note store handles concurrent operations.
+    const noteService = new NoteService(this.noteStore, this.aztecNode, anchorBlockHeader, jobId);
+    await noteService.syncNoteNullifiers(contractAddress, scopes);
+  }
+
+  /** Collects all relevant scope promises (including in-flight ones from concurrent calls) and awaits them. */
+  async #awaitSync(contractAddress: AztecAddress, scopes: AztecAddress[]): Promise<void> {
+    const promises = scopes
+      .map(scope => this.syncedContracts.get(toKey(contractAddress, scope)))
+      .filter(p => p !== undefined);
+    await Promise.all(promises);
+  }
+}
+
+function toKey(contract: AztecAddress, scope: AztecAddress) {
+  return `${contract.toString()}:${scope.toString()}`;
+}
+
+/** Runs fn while holding a slot in the given semaphore, bounding concurrent scope syncs within a single call. */
+async function runBounded<T>(syncSlot: Semaphore, fn: () => Promise<T>): Promise<T> {
+  await syncSlot.acquire();
+  try {
+    return await fn();
+  } finally {
+    syncSlot.release();
+  }
+}

package/src/contract/helpers.ts

@@ -0,0 +1,35 @@
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { ContractClassService } from './contract_class_service.js';
+
+export async function syncScope(
+  contractAddress: AztecAddress,
+  contractStore: ContractStore,
+  contractClassService: ContractClassService,
+  anchorBlockHeader: BlockHeader,
+  functionToInvokeAfterSync: FunctionSelector | null,
+  utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
+  scope: AztecAddress,
+) {
+  // Protocol contracts don't have private state to sync
+  if (isProtocolContract(contractAddress)) {
+    return;
+  }
+
+  const classId = await contractClassService.getCurrentClassId(contractAddress, anchorBlockHeader);
+  if (!classId) {
+    throw new Error(`Cannot sync contract ${contractAddress}: its instance is not registered nor published.`);
+  }
+  const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [scope], contractAddress, classId);
+  if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
+    throw new Error(
+      'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
+    );
+  }
+
+  await utilityExecutor(syncStateFunctionCall, [scope]);
+}