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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.2f68f620",
+  "version": "0.0.1-commit.3100065",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -71,20 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.2f68f620",
-    "@aztec/bb.js": "0.0.1-commit.2f68f620",
-    "@aztec/builder": "0.0.1-commit.2f68f620",
-    "@aztec/constants": "0.0.1-commit.2f68f620",
-    "@aztec/ethereum": "0.0.1-commit.2f68f620",
-    "@aztec/foundation": "0.0.1-commit.2f68f620",
-    "@aztec/key-store": "0.0.1-commit.2f68f620",
-    "@aztec/kv-store": "0.0.1-commit.2f68f620",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.2f68f620",
-    "@aztec/noir-types": "0.0.1-commit.2f68f620",
-    "@aztec/protocol-contracts": "0.0.1-commit.2f68f620",
-    "@aztec/simulator": "0.0.1-commit.2f68f620",
-    "@aztec/standard-contracts": "0.0.1-commit.2f68f620",
-    "@aztec/stdlib": "0.0.1-commit.2f68f620",
+    "@aztec/bb-prover": "0.0.1-commit.3100065",
+    "@aztec/bb.js": "0.0.1-commit.3100065",
+    "@aztec/builder": "0.0.1-commit.3100065",
+    "@aztec/constants": "0.0.1-commit.3100065",
+    "@aztec/ethereum": "0.0.1-commit.3100065",
+    "@aztec/foundation": "0.0.1-commit.3100065",
+    "@aztec/key-store": "0.0.1-commit.3100065",
+    "@aztec/kv-store": "0.0.1-commit.3100065",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3100065",
+    "@aztec/noir-types": "0.0.1-commit.3100065",
+    "@aztec/protocol-contracts": "0.0.1-commit.3100065",
+    "@aztec/simulator": "0.0.1-commit.3100065",
+    "@aztec/standard-contracts": "0.0.1-commit.3100065",
+    "@aztec/stdlib": "0.0.1-commit.3100065",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -93,8 +93,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.2f68f620",
-    "@aztec/world-state": "0.0.1-commit.2f68f620",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.3100065",
+    "@aztec/world-state": "0.0.1-commit.3100065",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/bin/check_oracle_version.ts

@@ -4,36 +4,27 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
 import { ORACLE_INTERFACE_HASH, ORACLE_VERSION_MAJOR } from '../oracle_version.js';
-import { getOracleInterfaceSignature, readNumericGlobal } from './oracle_version_helpers.js';
+import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_helpers.js';
 
 /**
  * Verifies that the Oracle interface matches the expected interface hash.
  *
  * The Oracle interface needs to be versioned to ensure compatibility between Aztec.nr and PXE. This function computes
- * a hash of the Oracle interface and compares it against a known hash. If they don't match, it means the interface has
- * changed and the oracle version needs to be bumped:
- *   - If the change is backward-breaking (e.g. removing/renaming an oracle), bump ORACLE_VERSION_MAJOR.
+ * a hash of the `ORACLE_REGISTRY` declaration (where each oracle's parameter names, parameter types, and return type
+ * live) and compares it against a known hash. If they don't match, it means the interface has changed and the oracle
+ * version needs to be bumped:
+ *   - If the change is backward-breaking (e.g. removing/renaming an oracle, or changing its params/return), bump
+ *     ORACLE_VERSION_MAJOR.
  *   - If the change is an oracle addition (non-breaking), bump ORACLE_VERSION_MINOR.
  */
 function assertOracleInterfaceMatches(): void {
-  const excludedProps = [
-    'handler',
-    'constructor',
-    'toACIRCallback',
-    'handlerAsMisc',
-    'handlerAsUtility',
-    'handlerAsPrivate',
-  ];
-
-  // Get the path to Oracle.ts source file
-  // The script runs from dest/bin/ after compilation, so we need to go up to the package root
-  // then into src/ to find the source file
+  // The script runs from dest/bin/ after compilation, so we go up to the package root then into src/ to find
+  // the source file.
   const currentDir = dirname(fileURLToPath(import.meta.url));
-  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then into src/
   const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
-  const oracleSourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle.ts');
+  const registrySourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle_registry.ts');
 
-  const oracleInterfaceSignature = getOracleInterfaceSignature(oracleSourcePath, ['Oracle'], excludedProps);
+  const oracleInterfaceSignature = getOracleRegistrySignature(registrySourcePath, 'ORACLE_REGISTRY');
 
   // We use keccak256 here just because we already have it in the dependencies.
   const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);

package/src/bin/index.ts

@@ -1 +1,5 @@
-export { getOracleInterfaceSignature, readNumericGlobal } from './oracle_version_helpers.js';
+export {
+  getOracleInterfaceSignature,
+  getOracleRegistrySignature,
+  readNumericGlobal,
+} from './oracle_version_helpers.js';

package/src/bin/oracle_version_helpers.ts

@@ -60,6 +60,58 @@ export function getOracleInterfaceSignature(sourcePath: string, targets: string[
   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.
  *
@@ -112,6 +164,7 @@ function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.Sou
   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';
@@ -119,3 +172,140 @@ function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.Sou
 
   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

@@ -1,29 +1,17 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import {
-  type BlockData,
-  type BlockQuery,
-  type BlocksQuery,
-  type CheckpointsQuery,
-  L2Block,
-  type L2BlockSource,
-} from '@aztec/stdlib/block';
-import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+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;
- * `getCheckpoints` requests blocks + L1 info + attestations so that `PublishedCheckpoint`
- * instances are fully populated.
+ * `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' | 'getCheckpoints'> {
+): Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips'> {
   return {
-    getL2Tips: async () => {
-      const tips = await node.getChainTips();
-      return { ...tips, proposedCheckpoint: tips.checkpointed };
-    },
+    getL2Tips: () => node.getChainTips(),
 
     async getBlockData(query: BlockQuery): Promise<BlockData | undefined> {
       const response = await node.getBlock(query);
@@ -50,32 +38,5 @@ export function blockStreamSourceFromAztecNode(
       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));
     },
-
-    async getCheckpoints(query: CheckpointsQuery): Promise<PublishedCheckpoint[]> {
-      if (!('from' in query)) {
-        throw new Error('getCheckpoints with epoch query not supported via AztecNode RPC');
-      }
-      const { from, limit } = query;
-      const responses = await node.getCheckpoints(from, limit, {
-        includeBlocks: true,
-        includeTransactions: true,
-        includeL1PublishInfo: true,
-        includeAttestations: true,
-      });
-      return responses.map(r => {
-        const checkpoint = new Checkpoint(
-          r.archive,
-          r.header,
-          r.blocks!.map(b => new L2Block(b.archive, b.header, b.body!, b.checkpointNumber, b.indexWithinCheckpoint)),
-          r.number,
-          r.feeAssetPriceModifier,
-        );
-        const l1 =
-          r.l1?.published === true
-            ? new L1PublishedData(r.l1.blockNumber, r.l1.timestamp, r.l1.blockHash)
-            : new L1PublishedData(0n, 0n, Fr.ZERO.toString());
-        return new PublishedCheckpoint(checkpoint, l1, r.attestations ?? []);
-      });
-    },
   };
 }

package/src/block_synchronizer/block_synchronizer.ts

@@ -8,9 +8,11 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 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 { 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';
 
@@ -26,32 +28,33 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
   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 contractClassService: ContractClassService,
+    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(
       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,
       },
     );
   }
@@ -62,21 +65,43 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
   }
 
   private async doHandleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    await this.l2TipsStore.handleBlockStreamEvent(event);
-
     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;
       }
@@ -110,10 +135,10 @@ 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
@@ -129,13 +154,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 */
@@ -144,6 +179,12 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     // 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);
   }

package/src/config/index.ts

@@ -10,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

package/src/config/package_info.ts

@@ -1,3 +1,3 @@
 export function getPackageInfo() {
-  return { version: '6.0.0', name: '@aztec/pxe' };
+  return { version: '5.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();
+  }
+}