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

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -1,7 +1,7 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
 import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { INITIAL_CONSTRAINED_PROBE_LEN, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
 import { getAllPrivateLogsByTags } from '../get_all_logs_by_tags.js';
 import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /**
@@ -55,9 +55,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
  * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
  *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
  *   one is already on-chain.
- * - The scan stops at the first gap in the index sequence. If all indexes in the batch have logs, the window
- *   advances. If a gap is found, the sequence has ended and no further logs exist.
- * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
  *
  * # Batching across secrets
  *
@@ -87,8 +92,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
             allLogs.push(...logsFoundWithSecret.map(({ log })=>log));
             // Persist new indexes. If the finalized index moved forward, the window advances
             // and we need another round for this secret.
-            const processForKind = pendingSecret.secret.kind === AppTaggingSecretKind.CONSTRAINED ? processConstrainedResults : processUnconstrainedResults;
-            return await processForKind(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
+            return pendingSecret.kind === AppTaggingSecretKind.CONSTRAINED ? await processConstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) : await processUnconstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
         }));
         pending = nextRound.filter(isDefined);
     }
@@ -97,13 +101,29 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /** Reads stored indexes for each secret and computes the initial index range to query. */ function getIndexRangesForSecrets(secrets, taggingStore, jobId) {
     return Promise.all(secrets.map(async (secret)=>{
         const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-        const highestIndexBeforeStart = secret.kind === AppTaggingSecretKind.CONSTRAINED ? currentHighestFinalizedIndex : await taggingStore.getHighestAgedIndex(secret, jobId);
-        const start = highestIndexBeforeStart === undefined ? 0 : highestIndexBeforeStart + 1;
-        const end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        const boundEnd = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        if (secret.kind === AppTaggingSecretKind.CONSTRAINED) {
+            // Constrained streams are gapless and resume at the finalized index, so probe a small initial window and stop
+            // at the first missing tag instead of always fetching the full window. The probe grows each round up to the
+            // window cap.
+            const start = currentHighestFinalizedIndex === undefined ? 0 : currentHighestFinalizedIndex + 1;
+            return {
+                kind: AppTaggingSecretKind.CONSTRAINED,
+                secret,
+                start,
+                end: Math.min(boundEnd, start + INITIAL_CONSTRAINED_PROBE_LEN),
+                boundEnd,
+                probeLen: INITIAL_CONSTRAINED_PROBE_LEN
+            };
+        }
+        // Unconstrained secrets can have gaps, so they scan the whole window starting past the highest aged index.
+        const highestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+        const start = highestAgedIndex === undefined ? 0 : highestAgedIndex + 1;
         return {
+            kind: AppTaggingSecretKind.UNCONSTRAINED,
             secret,
             start,
-            end
+            end: boundEnd
         };
     }));
 }
@@ -148,30 +168,43 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     return logsPerSecret;
 }
 /**
- * Processes fetched logs for a constrained secret. Constrained delivery guarantees contiguous index sequences,
- * so we scan from the start of the queried range and stop at the first missing index. Only `highestFinalizedIndex`
+ * Processes fetched logs for a constrained secret: persists the finalized index and advances the probe. See the
+ * "# Constrained secrets" section above for why the scan stops at the first missing index. Only `highestFinalizedIndex`
  * is tracked (no aged index).
  */ async function processConstrainedResults(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
-    // Find where the contiguous run of indexes ends. Constrained delivery guarantees there are no logs after the
-    // first gap, so all logs in the batch are within this prefix.
+    // Find where the contiguous run of indexes ends; all logs in the batch fall within this prefix.
     const indexesWithLogs = new Set(logsWithIndexes.map((l)=>l.taggingIndex));
     let firstMissingIndex = pending.start;
     while(firstMissingIndex < pending.end && indexesWithLogs.has(firstMissingIndex)){
         firstMissingIndex++;
     }
-    // Finalize any logs before the gap. The nullifier for a constrained-delivery log is emitted in the same
-    // transaction, guaranteeing the log cannot disappear once included, so we persist the highest finalized
-    // index even when a gap stops the scan. This lets the next sync round skip already-finalized indexes.
+    // Persist the highest finalized index found. The nullifier for a constrained-delivery log is emitted in the same
+    // transaction, guaranteeing the log cannot disappear once included, so we persist even when a gap stops the scan.
+    // This lets the next sync round skip already-finalized indexes.
     const { highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
     if (highestFinalizedIndex !== undefined) {
         await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
-        if (firstMissingIndex >= pending.end) {
-            return {
-                secret: pending.secret,
-                start: pending.end,
-                end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
-            };
-        }
+    }
+    // Advancing the probe is decoupled from persisting the finalized index: keep scanning as long as the probe was
+    // entirely hits (no gap) and there is room before the protocol bound, even if none of those hits is finalized yet.
+    // Gating this on finalization would drop logs in unfinalized blocks, which sit at the top of the contiguous run.
+    // The bound re-anchors to any finalized index found this round.
+    const probeFullyConsumed = firstMissingIndex >= pending.end;
+    const boundEnd = highestFinalizedIndex !== undefined ? Math.max(pending.boundEnd, highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1) : pending.boundEnd;
+    // Double the probe each round, capped at the window (see INITIAL_CONSTRAINED_PROBE_LEN in ../constants.ts).
+    // The queried range is already bounded by boundEnd (a probe can never reach
+    // more than WINDOW_LEN past the finalized frontier); this cap just keeps the stored length from growing unbounded
+    // once the probe saturates the window.
+    const nextProbeLen = Math.min(pending.probeLen * 2, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN);
+    if (probeFullyConsumed && pending.end < boundEnd) {
+        return {
+            kind: AppTaggingSecretKind.CONSTRAINED,
+            secret: pending.secret,
+            start: pending.end,
+            end: Math.min(boundEnd, pending.end + nextProbeLen),
+            boundEnd,
+            probeLen: nextProbeLen
+        };
     }
     return undefined;
 }
@@ -195,9 +228,11 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
     // For the next iteration we want to look only at indexes for which we have not yet fetched logs while
     // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+    const end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
     return {
+        kind: AppTaggingSecretKind.UNCONSTRAINED,
         secret: pending.secret,
         start: pending.end,
-        end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
+        end
     };
 }

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -48,7 +48,7 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
             break;
         }
         // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
-        // `storePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
+        // `mergePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
         // and is not re-fetched here.
         const knownSet = new Set(knownPendingTxHashes.map((h)=>h.toString()));
         const newPendingTxHashes = allPendingTxHashes.filter((h)=>!knownSet.has(h.toString()));

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

@@ -16,4 +16,4 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * preserving way.
  */
 export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQW9CZCJ9

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

@@ -1 +1 @@
-{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAgBd"}
+{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAoBd"}

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

@@ -23,7 +23,11 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
         })));
     const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
     const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
-    // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+    // Now we iterate over the map, construct the tagging index ranges and store them in the db. A tx already tracked
+    // in the store is merged rather than range-checked: if this PXE sent the tx and it partially reverted, the chain
+    // only shows the surviving sub-range of the prove-time entry (the finalized receipt step of the sync owns
+    // resolving that difference), and a tx from another PXE may straddle a sync window boundary, in which case the
+    // entry is widened so the next index choice covers the full onchain range.
     for (const [txHashStr, indexes] of txIndexesMap.entries()){
         const txHash = TxHash.fromString(txHashStr);
         const ranges = [
@@ -33,7 +37,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
                 highestIndex: Math.max(...indexes)
             }
         ];
-        await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+        await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
     }
 }
 // Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return

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

package/src/bin/check_oracle_version.ts

@@ -3,6 +3,7 @@ import { keccak256String } from '@aztec/foundation/crypto/keccak';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
+import { ORACLE_REGISTRY } from '../contract_function_simulator/index.js';
 import { ORACLE_INTERFACE_HASH, ORACLE_VERSION_MAJOR } from '../oracle_version.js';
 import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_helpers.js';
 
@@ -10,7 +11,7 @@ import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_
  * 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_REGISTRY` declaration (where each oracle's parameter names, parameter types, and return type
+ * 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
@@ -18,16 +19,8 @@ import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_
  *   - If the change is an oracle addition (non-breaking), bump ORACLE_VERSION_MINOR.
  */
 function assertOracleInterfaceMatches(): void {
-  // 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));
-  const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
-  const registrySourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle_registry.ts');
-
-  const oracleInterfaceSignature = getOracleRegistrySignature(registrySourcePath, 'ORACLE_REGISTRY');
-
   // 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).`,

package/src/bin/index.ts

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

package/src/bin/oracle_version_helpers.ts

@@ -1,75 +1,13 @@
-/* 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('');
-}
+import type { OracleRegistryEntry } from '../contract_function_simulator/index.js';
 
 /**
- * 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.
+ * Extracts a deterministic signature string from an oracle registry (e.g. PXE's `ORACLE_REGISTRY`).
  *
- * 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.
+ * 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:
@@ -79,32 +17,13 @@ export function getOracleInterfaceSignature(sourcePath: string, targets: string[
  * //   } 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`).
+ * //   "aztec_prv_bar(): void\naztec_utl_foo(a: u32): bool"
  */
-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}`;
+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();
@@ -133,179 +52,3 @@ export function readNumericGlobal(sourcePath: string, name: string): number {
   }
   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/contract/helpers.ts

@@ -1,10 +1,10 @@
-import { isProtocolContract } from '@aztec/protocol-contracts';
 import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { ContractClassService } from './contract_class_service.js';
+import { isSkipSyncContract } from './skip_sync_contracts.js';
 
 export async function syncScope(
   contractAddress: AztecAddress,
@@ -15,8 +15,8 @@ export async function syncScope(
   utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
   scope: AztecAddress,
 ) {
-  // Protocol contracts don't have private state to sync
-  if (isProtocolContract(contractAddress)) {
+  // Some canonical contracts hold no private state, so there is nothing to sync (see `skipSyncContracts`).
+  if (isSkipSyncContract(contractAddress)) {
     return;
   }