@aztec/pxe 0.0.1-commit.24de95ac → 0.0.1-commit.2606882

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

@@ -0,0 +1,60 @@
+import { TxStatus } from '@aztec/stdlib/tx';
+export const EMPTY_STATUS_CHANGE = {
+    txHashesToFinalize: [],
+    txHashesToDrop: [],
+    txHashesWithExecutionReverted: []
+};
+/** Concatenates two status changes field-by-field. */ export function mergeStatusChanges(a, b) {
+    return {
+        txHashesToFinalize: [
+            ...a.txHashesToFinalize,
+            ...b.txHashesToFinalize
+        ],
+        txHashesToDrop: [
+            ...a.txHashesToDrop,
+            ...b.txHashesToDrop
+        ],
+        txHashesWithExecutionReverted: [
+            ...a.txHashesWithExecutionReverted,
+            ...b.txHashesWithExecutionReverted
+        ]
+    };
+}
+/**
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
+ * dropped, or execution-reverted (but mined).
+ */ export async function getStatusChangeOfPending(pending, aztecNode) {
+    // Get receipts for all pending tx hashes.
+    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
+    const txHashesToFinalize = [];
+    const txHashesToDrop = [];
+    const txHashesWithExecutionReverted = [];
+    for(let i = 0; i < receipts.length; i++){
+        const receipt = receipts[i];
+        const txHash = pending[i];
+        if (receipt.status === TxStatus.FINALIZED) {
+            // Tx has been included in a block and the corresponding block is finalized
+            if (receipt.hasExecutionSucceeded()) {
+                // No part of execution reverted - we just finalize all the indexes.
+                txHashesToFinalize.push(txHash);
+            } else if (receipt.hasExecutionReverted()) {
+                // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+                // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+                txHashesWithExecutionReverted.push(txHash);
+            } else {
+                // Defensive check - this branch should never be triggered
+                throw new Error('Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.');
+            }
+        } else if (receipt.isDropped()) {
+            // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
+            txHashesToDrop.push(txHash);
+        } else {
+        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
+        }
+    }
+    return {
+        txHashesToFinalize,
+        txHashesToDrop,
+        txHashesWithExecutionReverted
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type AppTaggingSecret } from '@aztec/stdlib/logs';
+import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
+/**
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
+ * place is when a tx is being sent from this PXE.
+ * @param extendedSecret - The app tagging secret whose indexes are being synced.
+ * @param start - The starting index (inclusive) of the window to process.
+ * @param end - The ending index (exclusive) of the window to process.
+ * @param aztecNode - The Aztec node instance to query for logs.
+ * @param taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * 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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,72 @@
+import { SiloedTag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+/**
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
+ * place is when a tx is being sent from this PXE.
+ * @param extendedSecret - The app tagging secret whose indexes are being synced.
+ * @param start - The starting index (inclusive) of the window to process.
+ * @param end - The ending index (exclusive) of the window to process.
+ * @param aztecNode - The Aztec node instance to query for logs.
+ * @param taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
+ */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId) {
+    // We compute the tags for the current window of indexes
+    const siloedTagsForWindow = await Promise.all(Array.from({
+        length: end - start
+    }, (_, i)=>SiloedTag.compute({
+            extendedSecret,
+            index: start + i
+        })));
+    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.
+    for (const [txHashStr, indexes] of txIndexesMap.entries()){
+        const txHash = TxHash.fromString(txHashStr);
+        const ranges = [
+            {
+                extendedSecret,
+                lowestIndex: Math.min(...indexes),
+                highestIndex: Math.max(...indexes)
+            }
+        ];
+        await taggingStore.storePendingIndexes(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
+// an array for each tag.
+async function getTxsContainingTags(tags, aztecNode, anchorBlockHash) {
+    // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
+    // pagination here. Sender sync only needs `txHash` from each log, so we leave `includeEffects` off.
+    const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
+    return allLogs.map((logs)=>logs.map((log)=>log.txHash));
+}
+// Returns a map of txHash to all indexes for that txHash.
+function getTxIndexesMap(txHashesForTags, start, count) {
+    if (txHashesForTags.length !== count) {
+        throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
+    }
+    const indexesMap = new Map();
+    // Iterate over indexes
+    for(let i = 0; i < txHashesForTags.length; i++){
+        const taggingIndex = start + i;
+        const txHashesForTag = txHashesForTags[i];
+        // iterate over tx hashes that used that index (tag)
+        for (const txHash of txHashesForTag){
+            const key = txHash.toString();
+            const existing = indexesMap.get(key);
+            // Add the index to the tx's indexes
+            if (existing) {
+                existing.push(taggingIndex);
+            } else {
+                indexesMap.set(key, [
+                    taggingIndex
+                ]);
+            }
+        }
+    }
+    return indexesMap;
+}

package/package.json

@@ -1,18 +1,28 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.24de95ac",
+  "version": "0.0.1-commit.2606882",
   "type": "module",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/entrypoints/server/index.ts",
+      "./src/entrypoints/client/lazy/index.ts",
+      "./src/config/index.ts"
+    ],
+    "name": "PXE",
+    "tsconfig": "./tsconfig.json"
+  },
   "exports": {
     "./server": "./dest/entrypoints/server/index.js",
     "./client/lazy": "./dest/entrypoints/client/lazy/index.js",
     "./client/bundle": "./dest/entrypoints/client/bundle/index.js",
     "./simulator": "./dest/contract_function_simulator/index.js",
-    "./config": "./dest/config/index.js"
+    "./config": "./dest/config/index.js",
+    "./bin": "./dest/bin/index.js"
   },
   "bin": "./dest/bin/index.js",
   "scripts": {
-    "build": "yarn clean && yarn generate && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && yarn generate && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo ./src/config/package_info.ts",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
     "generate": "node ./scripts/generate_package_info.js",
@@ -61,35 +71,38 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.24de95ac",
-    "@aztec/bb.js": "0.0.1-commit.24de95ac",
-    "@aztec/builder": "0.0.1-commit.24de95ac",
-    "@aztec/constants": "0.0.1-commit.24de95ac",
-    "@aztec/ethereum": "0.0.1-commit.24de95ac",
-    "@aztec/foundation": "0.0.1-commit.24de95ac",
-    "@aztec/key-store": "0.0.1-commit.24de95ac",
-    "@aztec/kv-store": "0.0.1-commit.24de95ac",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.24de95ac",
-    "@aztec/noir-types": "0.0.1-commit.24de95ac",
-    "@aztec/protocol-contracts": "0.0.1-commit.24de95ac",
-    "@aztec/simulator": "0.0.1-commit.24de95ac",
-    "@aztec/stdlib": "0.0.1-commit.24de95ac",
+    "@aztec/bb-prover": "0.0.1-commit.2606882",
+    "@aztec/bb.js": "0.0.1-commit.2606882",
+    "@aztec/builder": "0.0.1-commit.2606882",
+    "@aztec/constants": "0.0.1-commit.2606882",
+    "@aztec/ethereum": "0.0.1-commit.2606882",
+    "@aztec/foundation": "0.0.1-commit.2606882",
+    "@aztec/key-store": "0.0.1-commit.2606882",
+    "@aztec/kv-store": "0.0.1-commit.2606882",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.2606882",
+    "@aztec/noir-types": "0.0.1-commit.2606882",
+    "@aztec/protocol-contracts": "0.0.1-commit.2606882",
+    "@aztec/simulator": "0.0.1-commit.2606882",
+    "@aztec/standard-contracts": "0.0.1-commit.2606882",
+    "@aztec/stdlib": "0.0.1-commit.2606882",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
     "sha3": "^2.1.4",
     "tslib": "^2.4.0",
-    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/merkle-tree": "0.0.1-commit.24de95ac",
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.24de95ac",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.2606882",
+    "@aztec/world-state": "0.0.1-commit.2606882",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",
     "@types/lodash.times": "^4.3.9",
     "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
+    "jest-file-snapshot": "^0.7.0",
     "jest-mock-extended": "^4.0.0",
     "lodash.times": "^4.3.2",
     "ts-node": "^10.9.1",

package/src/bin/check_oracle_version.ts

@@ -1,19 +1,19 @@
-import { keccak256String } from '@aztec/foundation/crypto';
+import { keccak256String } from '@aztec/foundation/crypto/keccak';
 
-import { Oracle } from '../contract_function_simulator/oracle/oracle.js';
-import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
+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';
 
 /**
  * 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 constant needs to be incremented and the ORACLE_INTERFACE_HASH constant needs to be
- * updated.
- *
- * TODO(#16581): The following only takes into consideration changes to the oracles defined in Oracle.ts and omits TXE
- * oracles. Ensure this checks TXE oracles as well. This hasn't been implemented yet since we don't have a clean TXE
- * oracle interface like we do in PXE (i.e., there is no single Oracle class that contains only the oracles).
+ * 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.
+ *   - If the change is an oracle addition (non-breaking), bump ORACLE_VERSION_MINOR.
  */
 function assertOracleInterfaceMatches(): void {
   const excludedProps = [
@@ -23,28 +23,66 @@ function assertOracleInterfaceMatches(): void {
     'handlerAsMisc',
     'handlerAsUtility',
     'handlerAsPrivate',
-  ] as const;
-
-  // Create a hashable representation of the oracle interface by concatenating its method names. Return values are
-  // excluded from the hash calculation since they are typically arrays of fields and I didn't manage to reliably
-  // stringify them.
-  // TODO(#16581): we're only checking the functions implemented by the Oracle object, which is really an ACVM
-  // translator, akin to TXE's RPC translator. This is correct in that it is ultimately the foreign interface that
-  // matters, but incorrect in that it does not take into consideration TXE's extended interface. An improvement would
-  // be to check RPCTranslator from TXE, though that still seems a bit fragile.
-  const oracleInterfaceMethodNames = Object.getOwnPropertyNames(Oracle.prototype)
-    .filter(name => !excludedProps.includes(name as (typeof excludedProps)[number]))
-    .sort()
-    .join('');
+  ];
+
+  // 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(oracleInterfaceMethodNames);
+  const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);
   if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
-    // This check exists only to notify you when you need to update the ORACLE_VERSION constant.
     throw new Error(
-      `The Oracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
+      `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).`,
     );
   }
 }
 
+/**
+ * Verifies that `ORACLE_VERSION_MAJOR` is identical across all of its hand-maintained copies.
+ *
+ * The major version is duplicated across the PXE TypeScript constant and two Noir constants (Aztec.nr and the protocol
+ * contracts' `aztec_sublib`) because those layers can't import each other. This static check fails fast at build time,
+ * naming each file and its value.
+ *
+ * Only the major version is checked: the minor version legitimately diverges under the "environment minor >= contract
+ * minor" tolerance, so asserting minor equality would false-positive.
+ */
+function assertContractOracleVersionMajorInSync(): void {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then up two more to the git root.
+  const packageRoot = dirname(dirname(currentDir));
+  const gitRoot = join(packageRoot, '..', '..');
+
+  const copies = [
+    { label: 'pxe/src/oracle_version.ts', value: ORACLE_VERSION_MAJOR },
+    {
+      label: 'aztec-nr/aztec/src/oracle/version.nr',
+      value: readNumericGlobal(
+        join(gitRoot, 'noir-projects/aztec-nr/aztec/src/oracle/version.nr'),
+        'ORACLE_VERSION_MAJOR',
+      ),
+    },
+    {
+      label: 'aztec_sublib/src/oracle/version.nr',
+      value: readNumericGlobal(
+        join(gitRoot, 'noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr'),
+        'ORACLE_VERSION_MAJOR',
+      ),
+    },
+  ];
+
+  if (new Set(copies.map(copy => copy.value)).size > 1) {
+    const details = copies.map(copy => `${copy.label}=${copy.value}`).join(', ');
+    throw new Error(`ORACLE_VERSION_MAJOR is out of sync: ${details}. Bump all copies together.`);
+  }
+}
+
 assertOracleInterfaceMatches();
+assertContractOracleVersionMajorInSync();

package/src/bin/index.ts

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

package/src/bin/oracle_version_helpers.ts

@@ -0,0 +1,121 @@
+/* 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('');
+}
+
+/**
+ * Reads an integer-valued global constant from a Noir or TypeScript source file.
+ *
+ * Matches both the Noir form (`pub global NAME: Field = N;`) and the TypeScript form (`export const NAME = N;`). This
+ * lets us compare a version constant that is hand-duplicated across the TS and Noir layers (which can't import each
+ * other) without depending on either compiler. Only the assignment form `NAME = N` matches, so later usages of the
+ * constant are ignored regardless of their order in the file.
+ *
+ * @param sourcePath - Absolute path to the source file to read.
+ * @param name - Name of the global constant whose integer value should be extracted.
+ * @returns The integer value assigned to the constant.
+ * @throws If the constant's declaration is not found in the file.
+ */
+export function readNumericGlobal(sourcePath: string, name: string): number {
+  const sourceCode = readFileSync(sourcePath, 'utf-8');
+  const match = sourceCode.match(new RegExp(`\\b${name}\\s*(?::\\s*\\w+\\s*)?=\\s*(\\d+)`));
+  if (!match) {
+    throw new Error(`Could not find numeric global '${name}' in ${sourcePath}.`);
+  }
+  return Number(match[1]);
+}
+
+function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
+  const name = param.name;
+
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+
+  if (ts.isArrayBindingPattern(name)) {
+    if (name.elements.length > 0) {
+      const element = name.elements[0];
+      if (ts.isBindingElement(element)) {
+        const elementName = element.name;
+        if (ts.isIdentifier(elementName)) {
+          return elementName.text;
+        }
+        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
+          return elementName.getText(sourceFile);
+        }
+      }
+    }
+    return name.getText(sourceFile);
+  }
+
+  if (ts.isObjectBindingPattern(name)) {
+    return name.getText(sourceFile);
+  }
+
+  return (name as ts.Node).getText(sourceFile);
+}
+
+function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
+  if (!typeNode) {
+    return 'void';
+  }
+
+  return typeNode.getText(sourceFile).replace(/\s+/g, ' ').trim();
+}

package/src/block_synchronizer/block_stream_source.ts

@@ -0,0 +1,81 @@
+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 { 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.
+ */
+export function blockStreamSourceFromAztecNode(
+  node: AztecNode,
+): Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips' | 'getCheckpoints'> {
+  return {
+    getL2Tips: async () => {
+      const tips = await node.getChainTips();
+      return { ...tips, proposedCheckpoint: tips.checkpointed };
+    },
+
+    async getBlockData(query: BlockQuery): Promise<BlockData | undefined> {
+      const response = await node.getBlock(query);
+      if (!response) {
+        return undefined;
+      }
+      return {
+        header: response.header,
+        archive: response.archive,
+        blockHash: response.hash,
+        checkpointNumber: response.checkpointNumber,
+        indexWithinCheckpoint: response.indexWithinCheckpoint,
+      };
+    },
+
+    async getBlocks(query: BlocksQuery): Promise<L2Block[]> {
+      // Epoch lookups are not exposed on the public AztecNode RPC; only `from + limit` is.
+      if (!('from' in query)) {
+        throw new Error('getBlocks with epoch query not supported via AztecNode RPC');
+      }
+      if (query.onlyCheckpointed) {
+        throw new Error('getBlocks with onlyCheckpointed not supported via AztecNode RPC');
+      }
+      const responses = await node.getBlocks(query.from, query.limit, { includeTransactions: true });
+      return responses.map(r => new L2Block(r.archive, r.header, r.body!, r.checkpointNumber, r.indexWithinCheckpoint));
+    },
+
+    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 ?? []);
+      });
+    },
+  };
+}