@aztec/pxe 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/bin/oracle_version_helpers.ts

@@ -0,0 +1,311 @@
+/* eslint-disable import-x/no-named-as-default-member */
+import { readFileSync } from 'fs';
+import ts from 'typescript';
+
+/**
+ * Extracts method signatures from TypeScript classes or interfaces and returns a deterministic string representation.
+ *
+ * This is used to detect when an oracle interface changes so that the oracle version can be bumped. It works with both
+ * class declarations (e.g. PXE's `Oracle` class) and interface declarations (e.g. TXE's `IAvmExecutionOracle`).
+ *
+ * @param sourcePath - Absolute path to the TypeScript source file to parse.
+ * @param targets - Names of classes or interfaces to extract methods from.
+ * @param excludedMembers - Method names to skip (e.g. non-oracle helpers like `constructor`).
+ */
+export function getOracleInterfaceSignature(sourcePath: string, targets: string[], excludedMembers: string[]): string {
+  const sourceCode = readFileSync(sourcePath, 'utf-8');
+  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  const methodSignatures: string[] = [];
+
+  function visit(node: ts.Node) {
+    const isTarget =
+      (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && targets.includes(node.name?.text ?? '');
+
+    if (isTarget) {
+      node.members.forEach(member => {
+        if (
+          (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) &&
+          member.name &&
+          ts.isIdentifier(member.name)
+        ) {
+          const methodName = member.name.text;
+
+          if (excludedMembers.includes(methodName)) {
+            return;
+          }
+
+          const paramSignatures: string[] = [];
+          member.parameters.forEach(param => {
+            const paramName = extractParameterName(param, sourceFile);
+            const paramType = extractTypeString(param.type, sourceFile);
+            paramSignatures.push(`${paramName}: ${paramType}`);
+          });
+
+          const returnType = extractTypeString(member.type, sourceFile);
+
+          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
+          methodSignatures.push(signature);
+        }
+      });
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+
+  methodSignatures.sort();
+
+  return methodSignatures.join('');
+}
+
+/**
+ * Extracts a deterministic signature string from an oracle registry object literal (e.g. PXE's `ORACLE_REGISTRY`).
+ *
+ * Reads the registry declaration where each oracle's wire ABI lives: the ordered parameter names with their
+ * `TypeMapping` expressions and the return type. The resulting hash is sensitive to parameter, type, and return
+ * changes, not just oracle additions and removals.
+ *
+ * Type expressions are captured as their source text (e.g. `OPTION(AZTEC_ADDRESS)`, `BOUNDED_VEC(NOTE)`), so the
+ * signature tracks the composition of types. However, if the internal serialization logic of a `TypeMapping` constant
+ * (e.g. `FIELD`) changes without the constant being renamed, the hash will not change.
+ *
+ * @example
+ * // Given a registry like:
+ * //   export const ORACLE_REGISTRY = {
+ * //     aztec_utl_foo: makeEntry({ params: [{ name: 'a', type: U32 }], returnType: BOOL }),
+ * //     aztec_prv_bar: makeEntry(),
+ * //   } satisfies Record<string, OracleRegistryEntry>;
+ * //
+ * // Returns (sorted, newline-joined):
+ * //   "aztec_prv_bar(): void\naztec_utl_foo(a: U32): BOOL"
+ *
+ * @param sourcePath - Absolute path to the TypeScript source file declaring the registry.
+ * @param registryName - Name of the registry constant to read (e.g. `ORACLE_REGISTRY`).
+ */
+export function getOracleRegistrySignature(sourcePath: string, registryName: string): string {
+  const sourceCode = readFileSync(sourcePath, 'utf-8');
+  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  const registry = findObjectLiteral(sourceFile, registryName);
+  if (!registry) {
+    throw new Error(`Could not find oracle registry '${registryName}' in ${sourcePath}.`);
+  }
+
+  const oracleSignatures = registry.properties.map(property => {
+    if (!ts.isPropertyAssignment(property)) {
+      throw new Error(
+        `Unexpected member in oracle registry '${registryName}': ${property.getText(sourceFile)}. Spread elements ` +
+          `are not supported.`,
+      );
+    }
+
+    const oracleName = getPropertyName(property.name, sourceFile);
+    const { params, returnType } = extractRegistryEntry(property.initializer, sourceFile);
+    const paramSignatures = params.map(param => `${param.name}: ${param.type}`);
+    return `${oracleName}(${paramSignatures.join(', ')}): ${returnType}`;
+  });
+
+  oracleSignatures.sort();
+
+  return oracleSignatures.join('\n');
+}
+
+/**
+ * Reads an integer-valued global constant from a Noir or TypeScript source file.
+ *
+ * Matches both the Noir form (`pub global NAME: Field = N;`) and the TypeScript form (`export const NAME = N;`). This
+ * lets us compare a version constant that is hand-duplicated across the TS and Noir layers (which can't import each
+ * other) without depending on either compiler. Only the assignment form `NAME = N` matches, so later usages of the
+ * constant are ignored regardless of their order in the file.
+ *
+ * @param sourcePath - Absolute path to the source file to read.
+ * @param name - Name of the global constant whose integer value should be extracted.
+ * @returns The integer value assigned to the constant.
+ * @throws If the constant's declaration is not found in the file.
+ */
+export function readNumericGlobal(sourcePath: string, name: string): number {
+  const sourceCode = readFileSync(sourcePath, 'utf-8');
+  const match = sourceCode.match(new RegExp(`\\b${name}\\s*(?::\\s*\\w+\\s*)?=\\s*(\\d+)`));
+  if (!match) {
+    throw new Error(`Could not find numeric global '${name}' in ${sourcePath}.`);
+  }
+  return Number(match[1]);
+}
+
+function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
+  const name = param.name;
+
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+
+  if (ts.isArrayBindingPattern(name)) {
+    if (name.elements.length > 0) {
+      const element = name.elements[0];
+      if (ts.isBindingElement(element)) {
+        const elementName = element.name;
+        if (ts.isIdentifier(elementName)) {
+          return elementName.text;
+        }
+        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
+          return elementName.getText(sourceFile);
+        }
+      }
+    }
+    return name.getText(sourceFile);
+  }
+
+  if (ts.isObjectBindingPattern(name)) {
+    return name.getText(sourceFile);
+  }
+
+  return (name as ts.Node).getText(sourceFile);
+}
+
+/** Returns the source text of a type annotation, or `'void'` if absent. */
+function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
+  if (!typeNode) {
+    return 'void';
+  }
+
+  return typeNode.getText(sourceFile).replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Finds a top-level object-literal-valued constant by name, unwrapping `satisfies`/`as`/parenthesized wrappers.
+ *
+ * @example
+ * // `const REGISTRY = { ... } satisfies Record<string, Entry>` => the `{ ... }` ObjectLiteralExpression
+ */
+function findObjectLiteral(sourceFile: ts.SourceFile, name: string): ts.ObjectLiteralExpression | undefined {
+  let result: ts.ObjectLiteralExpression | undefined;
+
+  function visit(node: ts.Node) {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name && node.initializer) {
+      result = unwrapObjectLiteral(node.initializer);
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return result;
+}
+
+/** Peels `satisfies`, `as`, and parenthesized wrappers off an expression to reach the underlying object literal. */
+function unwrapObjectLiteral(node: ts.Expression): ts.ObjectLiteralExpression | undefined {
+  let current = node;
+  while (ts.isSatisfiesExpression(current) || ts.isAsExpression(current) || ts.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isObjectLiteralExpression(current) ? current : undefined;
+}
+
+/**
+ * Extracts the ordered `params` (names + type expressions) and `returnType` from a `makeEntry({ ... })` call.
+ *
+ * @example
+ * // makeEntry({ params: [{ name: 'a', type: OPTION(FIELD) }], returnType: BOOL })
+ * // => { params: [{ name: 'a', type: 'OPTION(FIELD)' }], returnType: 'BOOL' }
+ * //
+ * // makeEntry()
+ * // => { params: [], returnType: 'void' }
+ */
+function extractRegistryEntry(
+  initializer: ts.Expression,
+  sourceFile: ts.SourceFile,
+): { params: { name: string; type: string }[]; returnType: string } {
+  if (!ts.isCallExpression(initializer)) {
+    throw new Error(`Expected a makeEntry(...) call but got: ${initializer.getText(sourceFile)}`);
+  }
+
+  const [arg] = initializer.arguments;
+  if (arg === undefined) {
+    return { params: [], returnType: 'void' };
+  }
+  if (!ts.isObjectLiteralExpression(arg)) {
+    throw new Error(`Expected a makeEntry object argument but got: ${arg.getText(sourceFile)}`);
+  }
+
+  let params: { name: string; type: string }[] = [];
+  let returnType = 'void';
+
+  arg.properties.forEach(property => {
+    if (!ts.isPropertyAssignment(property)) {
+      throw new Error(`Unexpected makeEntry property: ${property.getText(sourceFile)}`);
+    }
+    const key = getPropertyName(property.name, sourceFile);
+    if (key === 'params') {
+      params = extractRegistryParams(property.initializer, sourceFile);
+    } else if (key === 'returnType') {
+      returnType = normalizeExpressionText(property.initializer, sourceFile);
+    } else {
+      throw new Error(`Unexpected makeEntry property '${key}'.`);
+    }
+  });
+
+  return { params, returnType };
+}
+
+/**
+ * Extracts `{ name, type }` pairs from the `params` array literal inside a `makeEntry` call.
+ */
+function extractRegistryParams(
+  initializer: ts.Expression,
+  sourceFile: ts.SourceFile,
+): { name: string; type: string }[] {
+  if (!ts.isArrayLiteralExpression(initializer)) {
+    throw new Error(`Expected a params array but got: ${initializer.getText(sourceFile)}`);
+  }
+
+  return initializer.elements.map(element => {
+    if (!ts.isObjectLiteralExpression(element)) {
+      throw new Error(`Expected a param object but got: ${element.getText(sourceFile)}`);
+    }
+
+    let name: string | undefined;
+    let type: string | undefined;
+    element.properties.forEach(property => {
+      if (!ts.isPropertyAssignment(property)) {
+        throw new Error(`Unexpected param property: ${property.getText(sourceFile)}`);
+      }
+      const key = getPropertyName(property.name, sourceFile);
+      if (key === 'name') {
+        if (!ts.isStringLiteralLike(property.initializer)) {
+          throw new Error(`Expected a string literal param name but got: ${property.initializer.getText(sourceFile)}`);
+        }
+        name = property.initializer.text;
+      } else if (key === 'type') {
+        type = normalizeExpressionText(property.initializer, sourceFile);
+      } else {
+        throw new Error(`Unexpected param property '${key}'.`);
+      }
+    });
+
+    if (name === undefined || type === undefined) {
+      throw new Error(`Param missing 'name' or 'type': ${element.getText(sourceFile)}`);
+    }
+    return { name, type };
+  });
+}
+
+/** Returns the text of an identifier or string-literal property name, throwing on computed or numeric names. */
+function getPropertyName(name: ts.PropertyName, sourceFile: ts.SourceFile): string {
+  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) {
+    return name.text;
+  }
+  throw new Error(`Unsupported property name: ${name.getText(sourceFile)}`);
+}
+
+/**
+ * Returns the source text of an expression with all whitespace stripped for format-insensitive comparison.
+ *
+ * @example
+ * // `OPTION(\n  AZTEC_ADDRESS\n)` => `"OPTION(AZTEC_ADDRESS)"`
+ */
+function normalizeExpressionText(node: ts.Expression, sourceFile: ts.SourceFile): string {
+  // Type expressions are TypeMapping references and calls (identifiers, parentheses, commas, numbers) with no
+  // meaningful whitespace, so we strip it entirely to keep the signature stable across reformatting.
+  return node.getText(sourceFile).replace(/\s+/g, '');
+}

package/src/block_synchronizer/block_stream_source.ts

@@ -0,0 +1,42 @@
+import { type BlockData, type BlockQuery, type BlocksQuery, L2Block, type L2BlockSource } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+/**
+ * Lifts an {@link AztecNode} RPC client into the shape {@link L2BlockStream} expects.
+ * `getBlocks` requests transaction bodies so that real `L2Block` instances can be constructed. The stream no
+ * longer fetches checkpoint payloads (the `chain-checkpointed` event is a thin tip event), so `getCheckpoints`
+ * is not part of the lifted shape.
+ */
+export function blockStreamSourceFromAztecNode(
+  node: AztecNode,
+): Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips'> {
+  return {
+    getL2Tips: () => node.getChainTips(),
+
+    async getBlockData(query: BlockQuery): Promise<BlockData | undefined> {
+      const response = await node.getBlock(query);
+      if (!response) {
+        return undefined;
+      }
+      return {
+        header: response.header,
+        archive: response.archive,
+        blockHash: response.hash,
+        checkpointNumber: response.checkpointNumber,
+        indexWithinCheckpoint: response.indexWithinCheckpoint,
+      };
+    },
+
+    async getBlocks(query: BlocksQuery): Promise<L2Block[]> {
+      // Epoch lookups are not exposed on the public AztecNode RPC; only `from + limit` is.
+      if (!('from' in query)) {
+        throw new Error('getBlocks with epoch query not supported via AztecNode RPC');
+      }
+      if (query.onlyCheckpointed) {
+        throw new Error('getBlocks with onlyCheckpointed not supported via AztecNode RPC');
+      }
+      const responses = await node.getBlocks(query.from, query.limit, { includeTransactions: true });
+      return responses.map(r => new L2Block(r.archive, r.header, r.body!, r.checkpointNumber, r.indexWithinCheckpoint));
+    },
+  };
+}

package/src/block_synchronizer/block_synchronizer.ts

@@ -1,5 +1,6 @@
 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';
@@ -8,9 +9,11 @@ import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
 import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
-import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
-import type { NoteStore } from '../storage/note_store/note_store.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
@@ -20,72 +23,104 @@ import type { PrivateEventStore } from '../storage/private_event_store/private_e
 export class BlockSynchronizer implements L2BlockStreamEventHandler {
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
+  private readonly eventQueue = new SerialQueue();
   protected readonly blockStream: L2BlockStream;
 
   constructor(
-    private node: AztecNode,
-    private store: AztecAsyncKVStore,
-    private anchorBlockStore: AnchorBlockStore,
-    private noteStore: NoteStore,
-    private privateEventStore: PrivateEventStore,
-    private l2TipsStore: L2TipsKVStore,
-    private contractSyncService: ContractSyncService,
-    private config: Partial<BlockSynchronizerConfig> = {},
+    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 config: Partial<BlockSynchronizerConfig> = {},
     bindings?: LoggerBindings,
   ) {
     this.log = createLogger('pxe:block_synchronizer', bindings);
-    this.blockStream = this.createBlockStream(config);
+    this.blockStream = this.createBlockStream();
+    this.eventQueue.start();
   }
 
-  protected createBlockStream(config: Partial<BlockSynchronizerConfig>): L2BlockStream {
+  protected createBlockStream(): L2BlockStream {
     return new L2BlockStream(
-      this.node,
+      blockStreamSourceFromAztecNode(this.node),
       this.l2TipsStore,
       this,
       createLogger('pxe:block_stream', this.log.getBindings()),
       {
-        batchSize: config.l2BlockBatchSize,
-        // Skipping finalized blocks makes us sync much faster - we only need to download blocks other than the latest one
-        // in order to detect reorgs, and there can be no reorgs on finalized block, making this safe.
-        skipFinalized: true,
+        // 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. */
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    await this.l2TipsStore.handleBlockStreamEvent(event);
+  /** 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 'blocks-added': {
+      case 'chain-proposed': {
         if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
-          const lastBlock = event.blocks.at(-1)!;
-          await this.updateAnchorBlockHeader(lastBlock.header);
+          // 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') {
-          // Get the last block header from the checkpoint
-          const lastBlock = event.checkpoint.checkpoint.blocks.at(-1)!;
-          await this.updateAnchorBlockHeader(lastBlock.header);
+          // 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 blockHeader = await this.node.getBlockHeader(BlockNumber(event.block.number));
-          if (blockHeader) {
-            await this.updateAnchorBlockHeader(blockHeader);
+          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 blockHeader = await this.node.getBlockHeader(BlockNumber(event.block.number));
-          if (blockHeader) {
-            await this.updateAnchorBlockHeader(blockHeader);
+          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;
@@ -98,15 +133,16 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
             `Ignoring prune event to block ${event.block.number} greater than current anchor block ${currentAnchorBlockNumber}`,
             { pruneEvent: event, currentAnchorBlockHeader: currentAnchorBlockHeader.toInspect() },
           );
-          return;
+          break;
         }
 
-        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
+        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 newAnchorBlockHeader = await this.node.getBlockHeader(BlockHash.fromString(event.block.hash));
+        const newAnchorBlock = await this.node.getBlock(BlockHash.fromString(event.block.hash));
+        const newAnchorBlockHeader = newAnchorBlock?.header;
 
         if (!newAnchorBlockHeader) {
           throw new Error(
@@ -116,13 +152,23 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
 
         // Operations are wrapped in a single transaction to ensure atomicity.
         await this.store.transactionAsync(async () => {
-          await this.noteStore.rollback(event.block.number, currentAnchorBlockNumber);
-          await this.privateEventStore.rollback(event.block.number, currentAnchorBlockNumber);
+          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 */
@@ -152,6 +198,8 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
 
     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 {
@@ -161,6 +209,13 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
   }
 
+  /** 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;
 
@@ -171,7 +226,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
     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.getBlockHeader(BlockNumber.ZERO))!);
+      await this.anchorBlockStore.setHeader((await this.node.getBlockData(BlockNumber.ZERO))!.header);
     }
     await this.blockStream.sync();
   }

package/src/config/index.ts

@@ -1,6 +1,7 @@
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
+  enumConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
   parseBooleanEnv,
@@ -9,6 +10,7 @@ import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 
 export { getPackageInfo } from './package_info.js';
+export * from '../hooks/index.js';
 
 /**
  * Configuration settings for the prover factory
@@ -26,6 +28,12 @@ export interface BlockSynchronizerConfig {
   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 & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
@@ -58,14 +66,13 @@ export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
   syncChainTip: {
     env: 'PXE_SYNC_CHAIN_TIP',
     description: 'Which chain tip to sync to (proposed, checkpointed, proven, finalized)',
-    defaultValue: 'proposed',
-    parseEnv: (val: string) => {
-      const allowedValues = ['proposed', 'checkpointed', 'proven', 'finalized'];
-      if (allowedValues.includes(val)) {
-        return val;
-      }
-      throw new Error(`Invalid value for PXE_SYNC_CHAIN_TIP: ${val}. Allowed values are: ${allowedValues.join(', ')}`);
-    },
+    ...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),
   },
 };