@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/tagging/sender_sync/utils/resolve_pending_txs.d.ts

@@ -0,0 +1,29 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type MinedTxReceipt, type TxHash } from '@aztec/stdlib/tx';
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+/** What a window's node reads established about each of its pending txs. */
+export type ResolvedPendingTxs = {
+    txHashesFinalizedFromLogs: TxHash[];
+    txHashesFinalizedFromReceipts: TxHash[];
+    txHashesDropped: TxHash[];
+    /** Both sources land here: the logs when a surviving tag fell inside the window, a receipt otherwise. */
+    receiptsWithExecutionReverted: MinedTxReceipt<{
+        includeTxEffect: true;
+    }>[];
+};
+/**
+ * Resolves a window's pending txs. All of the window's node reads happen here.
+ *
+ * The logs it is handed settle most txs on their own, as {@link classifyPendingTxsFromLogs} explains. Two groups are
+ * left over, and share one further round trip:
+ *
+ * - txs absent from the logs, whose receipt is what tells whether they are still in the mempool, dropped, or reverted;
+ * - txs the logs show as reverted, which only their tx effect resolves.
+ *
+ * A third round trip is paid only when those receipts reveal a reverted tx, since its effect cannot be requested
+ * before its status says it reverted.
+ */
+export declare function resolvePendingTxs(pendingTxs: PendingTx[], txsInLogs: Map<string, TxInLogs>, finalizedBlockNumber: BlockNumber, aztecNode: AztecNode): Promise<ResolvedPendingTxs>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZV9wZW5kaW5nX3R4cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvcmVzb2x2ZV9wZW5kaW5nX3R4cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsS0FBSyxNQUFNLEVBQTRCLE1BQU0sa0JBQWtCLENBQUM7QUFFOUYsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFFeEYsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFeEUsNEVBQTRFO0FBQzVFLE1BQU0sTUFBTSxrQkFBa0IsR0FBRztJQUMvQix5QkFBeUIsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNwQyw2QkFBNkIsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUN4QyxlQUFlLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDMUIseUdBQXlHO0lBQ3pHLDZCQUE2QixFQUFFLGNBQWMsQ0FBQztRQUFFLGVBQWUsRUFBRSxJQUFJLENBQUE7S0FBRSxDQUFDLEVBQUUsQ0FBQztDQUM1RSxDQUFDO0FBRUY7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCx3QkFBc0IsaUJBQWlCLENBQ3JDLFVBQVUsRUFBRSxTQUFTLEVBQUUsRUFDdkIsU0FBUyxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLEVBQ2hDLG9CQUFvQixFQUFFLFdBQVcsRUFDakMsU0FBUyxFQUFFLFNBQVMsR0FDbkIsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBbUI3QiJ9

package/dest/tagging/sender_sync/utils/resolve_pending_txs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve_pending_txs.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/resolve_pending_txs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAA4B,MAAM,kBAAkB,CAAC;AAE9F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wDAAwD,CAAC;AAExF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAExE,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,6BAA6B,EAAE,MAAM,EAAE,CAAC;IACxC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,yGAAyG;IACzG,6BAA6B,EAAE,cAAc,CAAC;QAAE,eAAe,EAAE,IAAI,CAAA;KAAE,CAAC,EAAE,CAAC;CAC5E,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAChC,oBAAoB,EAAE,WAAW,EACjC,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,kBAAkB,CAAC,CAmB7B"}

package/dest/tagging/sender_sync/utils/resolve_pending_txs.js

@@ -0,0 +1,41 @@
+import { TxStatus } from '@aztec/stdlib/tx';
+import { classifyPendingTxsFromLogs, classifyPendingTxsFromReceipts } from './classify_pending_txs.js';
+/**
+ * Resolves a window's pending txs. All of the window's node reads happen here.
+ *
+ * The logs it is handed settle most txs on their own, as {@link classifyPendingTxsFromLogs} explains. Two groups are
+ * left over, and share one further round trip:
+ *
+ * - txs absent from the logs, whose receipt is what tells whether they are still in the mempool, dropped, or reverted;
+ * - txs the logs show as reverted, which only their tx effect resolves.
+ *
+ * A third round trip is paid only when those receipts reveal a reverted tx, since its effect cannot be requested
+ * before its status says it reverted.
+ */ export async function resolvePendingTxs(pendingTxs, txsInLogs, finalizedBlockNumber, aztecNode) {
+    const statusFromLogs = classifyPendingTxsFromLogs(pendingTxs, txsInLogs, finalizedBlockNumber);
+    const [statusOfAbsent, receiptsOfRevertedInLogs] = await Promise.all([
+        classifyPendingTxsFromReceipts(statusFromLogs.txHashesAbsent, aztecNode),
+        getReceiptsWithEffect(statusFromLogs.txHashesWithExecutionReverted, aztecNode)
+    ]);
+    const receiptsOfRevertedAbsent = await getReceiptsWithEffect(statusOfAbsent.txHashesWithExecutionReverted, aztecNode);
+    return {
+        txHashesFinalizedFromLogs: statusFromLogs.txHashesFinalized,
+        txHashesFinalizedFromReceipts: statusOfAbsent.txHashesFinalized,
+        txHashesDropped: statusOfAbsent.txHashesDropped,
+        // Both groups were judged finalized before this fetch, the first off our own tip and the second off an earlier
+        // receipt, so both are confirmed against what the node says now. Finalizing off a reorgeable block would burn
+        // the indexes.
+        receiptsWithExecutionReverted: [
+            ...receiptsOfRevertedInLogs,
+            ...receiptsOfRevertedAbsent
+        ].filter(isFinalized)
+    };
+}
+function getReceiptsWithEffect(txHashes, aztecNode) {
+    return Promise.all(txHashes.map((txHash)=>aztecNode.getTxReceipt(txHash, {
+            includeTxEffect: true
+        })));
+}
+function isFinalized(receipt) {
+    return receipt.status === TxStatus.FINALIZED;
+}

package/dest/tagging/sender_sync/utils/test_utils.d.ts

@@ -0,0 +1,16 @@
+import type { MinedTxStatus, TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { MinedTxReceipt, TxExecutionResult } from '@aztec/stdlib/tx';
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+/** A tx the store holds as pending, tracked up to the given index. */
+export declare function pendingTx(txHash: TxHash, highestIndex: number): PendingTx;
+/** One tx as a window's logs show it: the block it was mined in and the tagging indexes its logs carried. */
+export declare function minedIn(blockNumber: number, taggingIndexes: number[]): TxInLogs;
+/** Builds the tx-hash-keyed map a window's logs would produce. */
+export declare function txsInLogs(...entries: [TxHash, TxInLogs][]): Map<string, TxInLogs>;
+/** The receipt of a mined tx, successful and without a tx effect unless stated otherwise. */
+export declare function minedReceipt(txHash: TxHash, status: MinedTxStatus, blockNumber: number, { executionResult, txEffect }?: {
+    executionResult?: TxExecutionResult;
+    txEffect?: TxEffect;
+}): MinedTxReceipt;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvdGVzdF91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxjQUFjLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVyRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUN4RixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUV4RSxzRUFBc0U7QUFDdEUsd0JBQWdCLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUV6RTtBQUVELDZHQUE2RztBQUM3Ryx3QkFBZ0IsT0FBTyxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFFLE1BQU0sRUFBRSxHQUFHLFFBQVEsQ0FFL0U7QUFFRCxrRUFBa0U7QUFDbEUsd0JBQWdCLFNBQVMsQ0FBQyxHQUFHLE9BQU8sRUFBRSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsRUFBRSxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBRWpGO0FBRUQsNkZBQTZGO0FBQzdGLHdCQUFnQixZQUFZLENBQzFCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsTUFBTSxFQUFFLGFBQWEsRUFDckIsV0FBVyxFQUFFLE1BQU0sRUFDbkIsRUFDRSxlQUEyQyxFQUMzQyxRQUFRLEVBQ1QsR0FBRTtJQUFFLGVBQWUsQ0FBQyxFQUFFLGlCQUFpQixDQUFDO0lBQUMsUUFBUSxDQUFDLEVBQUUsUUFBUSxDQUFBO0NBQU8sR0FDbkUsY0FBYyxDQWFoQiJ9

package/dest/tagging/sender_sync/utils/test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/test_utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wDAAwD,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAExE,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,CAEzE;AAED,6GAA6G;AAC7G,wBAAgB,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,QAAQ,CAE/E;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,GAAG,OAAO,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAEjF;AAED,6FAA6F;AAC7F,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,EACE,eAA2C,EAC3C,QAAQ,EACT,GAAE;IAAE,eAAe,CAAC,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAO,GACnE,cAAc,CAahB"}

package/dest/tagging/sender_sync/utils/test_utils.js

@@ -0,0 +1,24 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockHash } from '@aztec/stdlib/block';
+import { MinedTxReceipt, TxExecutionResult } from '@aztec/stdlib/tx';
+/** A tx the store holds as pending, tracked up to the given index. */ export function pendingTx(txHash, highestIndex) {
+    return {
+        txHash: txHash.toString(),
+        highestIndex
+    };
+}
+/** One tx as a window's logs show it: the block it was mined in and the tagging indexes its logs carried. */ export function minedIn(blockNumber, taggingIndexes) {
+    return {
+        blockNumber: BlockNumber(blockNumber),
+        taggingIndexes
+    };
+}
+/** Builds the tx-hash-keyed map a window's logs would produce. */ export function txsInLogs(...entries) {
+    return new Map(entries.map(([txHash, txInLogs])=>[
+            txHash.toString(),
+            txInLogs
+        ]));
+}
+/** The receipt of a mined tx, successful and without a tx effect unless stated otherwise. */ export function minedReceipt(txHash, status, blockNumber, { executionResult = TxExecutionResult.SUCCESS, txEffect } = {}) {
+    return new MinedTxReceipt(txHash, status, executionResult, 1n, BlockHash.random(), BlockNumber(blockNumber), SlotNumber(Number(blockNumber)), 0, EpochNumber(1), txEffect);
+}

package/dest/tagging/testing/tag_query_test_utils.d.ts

@@ -0,0 +1,6 @@
+import { type AppTaggingSecret, type PrivateLogsQuery, SiloedTag } from '@aztec/stdlib/logs';
+/** Computes the siloed tag */
+export declare function computeSiloedTagForIndex(secret: AppTaggingSecret, index: number): Promise<SiloedTag>;
+/** Extracts the bare-tag set from a query */
+export declare function extractTags(query: PrivateLogsQuery): SiloedTag[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnX3F1ZXJ5X3Rlc3RfdXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90YWdnaW5nL3Rlc3RpbmcvdGFnX3F1ZXJ5X3Rlc3RfdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxTQUFTLEVBQWlCLE1BQU0sb0JBQW9CLENBQUM7QUFFNUcsOEJBQThCO0FBQzlCLHdCQUFnQix3QkFBd0IsQ0FBQyxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBRXBHO0FBRUQsNkNBQTZDO0FBQzdDLHdCQUFnQixXQUFXLENBQUMsS0FBSyxFQUFFLGdCQUFnQixHQUFHLFNBQVMsRUFBRSxDQUVoRSJ9

package/dest/tagging/testing/tag_query_test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag_query_test_utils.d.ts","sourceRoot":"","sources":["../../../src/tagging/testing/tag_query_test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAiB,MAAM,oBAAoB,CAAC;AAE5G,8BAA8B;AAC9B,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAEpG;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS,EAAE,CAEhE"}

package/dest/tagging/testing/tag_query_test_utils.js

@@ -0,0 +1,10 @@
+import { SiloedTag } from '@aztec/stdlib/logs';
+/** Computes the siloed tag */ export function computeSiloedTagForIndex(secret, index) {
+    return SiloedTag.compute({
+        extendedSecret: secret,
+        index
+    });
+}
+/** Extracts the bare-tag set from a query */ export function extractTags(query) {
+    return query.tags.map((entry)=>entry instanceof SiloedTag ? entry : entry.tag);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.993d240",
+  "version": "0.0.1-commit.9a89641",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -71,20 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.993d240",
-    "@aztec/bb.js": "0.0.1-commit.993d240",
-    "@aztec/builder": "0.0.1-commit.993d240",
-    "@aztec/constants": "0.0.1-commit.993d240",
-    "@aztec/ethereum": "0.0.1-commit.993d240",
-    "@aztec/foundation": "0.0.1-commit.993d240",
-    "@aztec/key-store": "0.0.1-commit.993d240",
-    "@aztec/kv-store": "0.0.1-commit.993d240",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.993d240",
-    "@aztec/noir-types": "0.0.1-commit.993d240",
-    "@aztec/protocol-contracts": "0.0.1-commit.993d240",
-    "@aztec/simulator": "0.0.1-commit.993d240",
-    "@aztec/standard-contracts": "0.0.1-commit.993d240",
-    "@aztec/stdlib": "0.0.1-commit.993d240",
+    "@aztec/bb-prover": "0.0.1-commit.9a89641",
+    "@aztec/bb.js": "6.0.0-nightly.20260807",
+    "@aztec/builder": "0.0.1-commit.9a89641",
+    "@aztec/constants": "0.0.1-commit.9a89641",
+    "@aztec/ethereum": "0.0.1-commit.9a89641",
+    "@aztec/foundation": "0.0.1-commit.9a89641",
+    "@aztec/key-store": "0.0.1-commit.9a89641",
+    "@aztec/kv-store": "0.0.1-commit.9a89641",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.9a89641",
+    "@aztec/noir-types": "6.0.0-nightly.20260807",
+    "@aztec/protocol-contracts": "0.0.1-commit.9a89641",
+    "@aztec/simulator": "0.0.1-commit.9a89641",
+    "@aztec/standard-contracts": "0.0.1-commit.9a89641",
+    "@aztec/stdlib": "0.0.1-commit.9a89641",
     "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.993d240",
-    "@aztec/world-state": "0.0.1-commit.993d240",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.9a89641",
+    "@aztec/world-state": "0.0.1-commit.9a89641",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/bin/check_oracle_version.ts

@@ -1,44 +1,23 @@
-/* eslint-disable import-x/no-named-as-default-member */
 import { keccak256String } from '@aztec/foundation/crypto/keccak';
 
-import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import ts from 'typescript';
-import { fileURLToPath } from 'url';
-
+import { ORACLE_REGISTRY } from '../contract_function_simulator/index.js';
 import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
+import { getOracleRegistrySignature } 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 `ORACLE_REGISTRY` (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
-  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 oracleInterfaceSignature = getOracleInterfaceSignature(oracleSourcePath, ['Oracle'], excludedProps);
-
   // We use keccak256 here just because we already have it in the dependencies.
-  const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);
+  const oracleInterfaceHash = keccak256String(getOracleRegistrySignature(ORACLE_REGISTRY));
   if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
     throw new Error(
       `The Oracle interface has changed. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} in pxe/src/oracle_version.ts and bump the oracle version (ORACLE_VERSION_MAJOR for breaking changes, ORACLE_VERSION_MINOR for oracle additions).`,
@@ -46,126 +25,4 @@ function assertOracleInterfaceMatches(): void {
   }
 }
 
-/**
- * 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 {
-  // Read and parse the TypeScript source file
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  // Extract method signatures from the target classes/interfaces
-  const methodSignatures: string[] = [];
-
-  function visit(node: ts.Node) {
-    // Look for class or interface declarations matching the target names
-    const isTarget =
-      (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && targets.includes(node.name?.text ?? '');
-
-    if (isTarget) {
-      // Visit all members of the class/interface
-      node.members.forEach(member => {
-        if (
-          (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) &&
-          member.name &&
-          ts.isIdentifier(member.name)
-        ) {
-          const methodName = member.name.text;
-
-          // Skip excluded methods
-          if (excludedMembers.includes(methodName)) {
-            return;
-          }
-
-          // Extract parameter signatures
-          const paramSignatures: string[] = [];
-          member.parameters.forEach(param => {
-            const paramName = extractParameterName(param, sourceFile);
-            const paramType = extractTypeString(param.type, sourceFile);
-            paramSignatures.push(`${paramName}: ${paramType}`);
-          });
-
-          // Extract return type
-          const returnType = extractTypeString(member.type, sourceFile);
-
-          // Build full signature: methodName(param1: Type1, param2: Type2): ReturnType
-          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
-          methodSignatures.push(signature);
-        }
-      });
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-
-  // Sort signatures alphabetically for consistent hashing
-  methodSignatures.sort();
-
-  // Create a hashable representation by concatenating all signatures
-  return methodSignatures.join('');
-}
-
-/**
- * Extracts the parameter name from a parameter node, handling destructured parameters.
- */
-function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
-  const name = param.name;
-
-  if (ts.isIdentifier(name)) {
-    return name.text;
-  }
-
-  if (ts.isArrayBindingPattern(name)) {
-    // Handle destructured parameters like [blockNumber]: ACVMField[]
-    // Extract the first element 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;
-        }
-        // Nested destructuring - use text representation
-        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
-          return elementName.getText(sourceFile);
-        }
-      }
-    }
-    // Fallback: return the text representation
-    return name.getText(sourceFile);
-  }
-
-  if (ts.isObjectBindingPattern(name)) {
-    // Handle object destructuring
-    return name.getText(sourceFile);
-  }
-
-  // Fallback for any other case - this should never happen but TypeScript needs it
-  return (name as ts.Node).getText(sourceFile);
-}
-
-/**
- * Extracts the type string from a type node, normalizing whitespace.
- */
-function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
-  if (!typeNode) {
-    return 'void';
-  }
-
-  // Get the type text and normalize whitespace
-  let typeText = typeNode.getText(sourceFile);
-  // Normalize whitespace: remove extra spaces, newlines, and tabs
-  typeText = typeText.replace(/\s+/g, ' ').trim();
-  return typeText;
-}
-
 assertOracleInterfaceMatches();

package/src/bin/index.ts

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

package/src/bin/oracle_version_helpers.ts

@@ -0,0 +1,30 @@
+import type { OracleRegistryEntry } from '../contract_function_simulator/index.js';
+
+/**
+ * Extracts a deterministic signature string from an oracle registry (e.g. PXE's `ORACLE_REGISTRY`).
+ *
+ * Reads the registry where each oracle's wire ABI lives: the ordered parameter names with their `TypeMapping` labels
+ * and the return type. The resulting hash is sensitive to parameter, type, and return changes, not just oracle
+ * additions and removals.
+ *
+ * @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"
+ */
+export function getOracleRegistrySignature(registry: Record<string, OracleRegistryEntry>): string {
+  const oracleSignatures = Object.entries(registry).map(([name, entry]) => {
+    const paramSignatures = entry.params.map(p => `${p.name}: ${p.type.label}`);
+    const returnType = entry.returnType === undefined ? 'void' : entry.returnType.label;
+    return `${name}(${paramSignatures.join(', ')}): ${returnType}`;
+  });
+
+  oracleSignatures.sort();
+
+  return oracleSignatures.join('\n');
+}

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

@@ -4,13 +4,14 @@ 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 { 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 { ContractSyncService } from '../contract/contract_sync_service.js';
+import type { CachingAztecNode } from '../node/caching_aztec_node.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 +27,32 @@ 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: CachingAztecNode,
+    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(
       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 +63,29 @@ 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);
+          await this.updateAnchorBlockHeader(event.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 +119,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 +138,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 +163,11 @@ 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();
+
+    // Cached node reads stay correct indefinitely, so this wipe is only about bounding memory growth. An anchor
+    // update is the recurring trigger PXE already has.
+    this.node.wipeCache();
+
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);
   }