@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/bin/check_oracle_version.ts

@@ -0,0 +1,160 @@
+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_INTERFACE_HASH } from '../oracle_version.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).
+ */
+function assertOracleInterfaceMatches(): void {
+  const oracleInterfaceSignature = getOracleInterfaceSignature();
+
+  // We use keccak256 here just because we already have it in the dependencies.
+  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.`,
+    );
+  }
+}
+
+/**
+ * Constructs a signature of the Oracle interface while ignoring methods that are not foreign call handlers.
+ */
+function getOracleInterfaceSignature(): string {
+  const excludedProps = [
+    'handler',
+    'constructor',
+    'toACIRCallback',
+    'handlerAsMisc',
+    'handlerAsUtility',
+    'handlerAsPrivate',
+  ] as const;
+
+  // 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');
+
+  // Read and parse the TypeScript source file
+  const sourceCode = readFileSync(oracleSourcePath, 'utf-8');
+  const sourceFile = ts.createSourceFile('oracle.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  // Extract method signatures from the Oracle class
+  const methodSignatures: string[] = [];
+
+  function visit(node: ts.Node) {
+    // Look for class declaration named "Oracle"
+    if (ts.isClassDeclaration(node) && node.name?.text === 'Oracle') {
+      // Visit all members of the class
+      node.members.forEach(member => {
+        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+          const methodName = member.name.text;
+
+          // Skip excluded methods
+          if (excludedProps.includes(methodName as (typeof excludedProps)[number])) {
+            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/{synchronizer/synchronizer.ts → block_synchronizer/block_synchronizer.ts}

@@ -1,45 +1,46 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { L2TipsStore } from '@aztec/kv-store/stores';
+import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 import type { PXEConfig } from '../config/index.js';
+import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
 import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
-import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
+import type { RecipientTaggingDataProvider } from '../storage/tagging_data_provider/recipient_tagging_data_provider.js';
 
 /**
- * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
- * latest block header and handle reorgs.
- * It provides methods to trigger a sync and get the block number we are syncec to
- * details, and fetch transactions by hash.
+ * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
+ * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
+ * for querying sync status.
  */
-export class Synchronizer implements L2BlockStreamEventHandler {
-  private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
+export class BlockSynchronizer implements L2BlockStreamEventHandler {
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
   protected readonly blockStream: L2BlockStream;
 
   constructor(
     private node: AztecNode,
-    private syncDataProvider: SyncDataProvider,
+    private anchorBlockDataProvider: AnchorBlockDataProvider,
     private noteDataProvider: NoteDataProvider,
-    private taggingDataProvider: TaggingDataProvider,
-    private l2TipsStore: L2TipsStore,
-    config: Partial<Pick<PXEConfig, 'l2StartingBlock'>> = {},
+    private recipientTaggingDataProvider: RecipientTaggingDataProvider,
+    private l2TipsStore: L2TipsKVStore,
+    config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
     loggerOrSuffix?: string | Logger,
   ) {
     this.log =
       !loggerOrSuffix || typeof loggerOrSuffix === 'string'
-        ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`)
+        ? createLogger(loggerOrSuffix ? `pxe:block_synchronizer:${loggerOrSuffix}` : `pxe:block_synchronizer`)
         : loggerOrSuffix;
     this.blockStream = this.createBlockStream(config);
   }
 
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2StartingBlock'>>) {
+  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>>) {
     return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-      startingBlock: config.l2StartingBlock,
+      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,
     });
   }
 
@@ -49,30 +50,32 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     switch (event.type) {
       case 'blocks-added': {
-        const lastBlock = event.blocks.at(-1)!;
+        const lastBlock = event.blocks.at(-1)!.block;
         this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
           blockHash: lastBlock.hash(),
           archive: lastBlock.archive.root.toString(),
           header: lastBlock.header.toInspect(),
         });
-        await this.syncDataProvider.setHeader(lastBlock.header);
+        await this.anchorBlockDataProvider.setHeader(lastBlock.getBlockHeader());
         break;
       }
       case 'chain-pruned': {
-        this.log.warn(`Pruning data after block ${event.blockNumber} due to reorg`);
+        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
         // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
-        const lastSynchedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        await this.noteDataProvider.unnullifyNotesAfter(event.blockNumber, lastSynchedBlockNumber);
-        await this.noteDataProvider.removeNotesAfter(event.blockNumber);
+        const lastSynchedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+        await this.noteDataProvider.rollbackNotesAndNullifiers(event.block.number, lastSynchedBlockNumber);
         // Remove all note tagging indexes to force a full resync. This is suboptimal, but unless we track the
         // block number in which each index is used it's all we can do.
-        await this.taggingDataProvider.resetNoteSyncData();
+        // Note: This is now unnecessary for the sender tagging data provider because the new algorithm handles reorgs.
+        // TODO(#17775): Once this issue is implemented we will have the index-block number mapping, so we can
+        // implement this more intelligently.
+        await this.recipientTaggingDataProvider.resetNoteSyncData();
         // Update the header to the last block.
-        const newHeader = await this.node.getBlockHeader(event.blockNumber);
+        const newHeader = await this.node.getBlockHeader(event.block.number);
         if (!newHeader) {
-          this.log.error(`Block header not found for block number ${event.blockNumber} during chain prune`);
+          this.log.error(`Block header not found for block number ${event.block.number} during chain prune`);
         } else {
-          await this.syncDataProvider.setHeader(newHeader);
+          await this.anchorBlockDataProvider.setHeader(newHeader);
         }
         break;
       }
@@ -80,8 +83,13 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   }
 
   /**
-   * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+   * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
    * recent data (e.g. notes), and handling any reorgs that might have occurred.
+   *
+   * Note this BlockSynchronizer is designed to let its users control when a synchronization is run,
+   * so this component doesn't proactively stay up to date with the blockchain.
+   *
+   * We do this so PXE can ensure data consistency.
    */
   public async sync() {
     if (this.isSyncing !== undefined) {
@@ -104,18 +112,14 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     let currentHeader;
 
     try {
-      currentHeader = await this.syncDataProvider.getBlockHeader();
-    } catch (e) {
+      currentHeader = await this.anchorBlockDataProvider.getBlockHeader();
+    } catch {
       this.log.debug('Header is not set, requesting from the node');
     }
     if (!currentHeader) {
       // REFACTOR: We should know the header of the genesis block without having to request it from the node.
-      await this.syncDataProvider.setHeader((await this.node.getBlockHeader(0))!);
+      await this.anchorBlockDataProvider.setHeader((await this.node.getBlockHeader(BlockNumber.ZERO))!);
     }
     await this.blockStream.sync();
   }
-
-  public async getSynchedBlockNumber() {
-    return (await this.syncDataProvider.getBlockNumber()) ?? this.initialSyncBlockNumber;
-  }
 }

package/src/block_synchronizer/index.ts

@@ -0,0 +1 @@
+export * from './block_synchronizer.js';

package/src/config/index.ts

@@ -1,4 +1,3 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -8,19 +7,9 @@ import {
 } from '@aztec/foundation/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
-import type { Network } from '@aztec/stdlib/network';
 
 export { getPackageInfo } from './package_info.js';
 
-/**
- * Temporary configuration until WASM can be used instead of native
- */
-export interface BBProverConfig {
-  bbWorkingDirectory?: string;
-  bbBinaryPath?: string;
-  bbSkipCleanup?: boolean;
-}
-
 /**
  * Configuration settings for the prover factory
  */
@@ -28,77 +17,59 @@ export interface KernelProverConfig {
   /** Whether we are running with real proofs */
   proverEnabled?: boolean;
 }
+
 /**
- * Configuration settings for the PXE.
+ * Configuration settings for the block synchronizer.
  */
-export interface PXEConfig {
-  /** L2 block to start scanning from for new accounts */
-  l2StartingBlock: number;
+export interface BlockSynchronizerConfig {
+  /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
+  l2BlockBatchSize: number;
 }
 
-export type PXEServiceConfig = PXEConfig & KernelProverConfig & BBProverConfig & DataStoreConfig & ChainConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 
 export type CliPXEOptions = {
-  /** External Aztec network to connect to. e.g. devnet */
-  network?: Network;
-  /** API Key required by the external network's node */
-  apiKey?: string;
   /** Custom Aztec Node URL to connect to  */
   nodeUrl?: string;
 };
 
-export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
+export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
   ...dataConfigMappings,
   ...chainConfigMappings,
-  l2StartingBlock: {
-    env: 'PXE_L2_STARTING_BLOCK',
-    ...numberConfigHelper(INITIAL_L2_BLOCK_NUM),
-    description: 'L2 block to start scanning from for new accounts',
-  },
-  bbBinaryPath: {
-    env: 'BB_BINARY_PATH',
-    description: 'Path to the BB binary',
-  },
-  bbWorkingDirectory: {
-    env: 'BB_WORKING_DIRECTORY',
-    description: 'Working directory for the BB binary',
-  },
-  bbSkipCleanup: {
-    env: 'BB_SKIP_CLEANUP',
-    description: 'True to skip cleanup of temporary files for debugging purposes',
-    ...booleanConfigHelper(),
+  l2BlockBatchSize: {
+    env: 'PXE_L2_BLOCK_BATCH_SIZE',
+    ...numberConfigHelper(50),
+    description: 'Maximum amount of blocks to pull from the stream in one request when synchronizing',
   },
+  // TODO: We're losing this feature in moving to bb.js api.
+  // Reimplement it as a setting that dumps the msgpack data on the bb.js backend if needed.
+  // bbSkipCleanup: {
+  //   env: 'BB_SKIP_CLEANUP',
+  //   description: 'True to skip cleanup of temporary files for debugging purposes',
+  //   ...booleanConfigHelper(),
+  // },
   proverEnabled: {
     env: 'PXE_PROVER_ENABLED',
     description: 'Enable real proofs',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(true),
   },
 };
 
 /**
- * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
+ * Creates an instance of PXEConfig out of environment variables using sensible defaults for integration testing if not set.
  */
-export function getPXEServiceConfig(): PXEServiceConfig {
-  return getConfigFromMappings<PXEServiceConfig>(pxeConfigMappings);
+export function getPXEConfig(): PXEConfig {
+  return getConfigFromMappings<PXEConfig>(pxeConfigMappings);
 }
 
 export const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions> = {
-  network: {
-    env: 'NETWORK',
-    parseEnv: (val: string) => val as Network,
-    description: 'External Aztec network to connect to. e.g. devnet',
-  },
-  apiKey: {
-    env: 'API_KEY',
-    description: "API Key required by the external network's node",
-  },
   nodeUrl: {
     env: 'AZTEC_NODE_URL',
     description: 'Custom Aztec Node URL to connect to',
   },
 };
 
-export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEServiceConfig> = {
+export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEConfig> = {
   ...pxeConfigMappings,
   ...pxeCliConfigMappings,
   ...dataConfigMappings,
@@ -107,18 +78,19 @@ export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEService
     parseEnv: (val: string) => parseBooleanEnv(val) || !!process.env.NETWORK,
     description: 'Enable real proofs',
     isBoolean: true,
+    defaultValue: true,
   },
 };
 
 /**
  * Creates an instance of CliPxeOptions out of environment variables
  */
-export function getCliPXEOptions(): CliPXEOptions & PXEServiceConfig {
-  const pxeConfig = getPXEServiceConfig();
+export function getCliPXEOptions(): CliPXEOptions & PXEConfig {
+  const pxeConfig = getPXEConfig();
   const cliOptions = getConfigFromMappings<CliPXEOptions>(pxeCliConfigMappings);
   return {
     ...pxeConfig,
     ...cliOptions,
-    proverEnabled: pxeConfig.proverEnabled || !!cliOptions.network,
+    proverEnabled: pxeConfig.proverEnabled,
   };
 }

package/src/config/package_info.ts

@@ -1,3 +1,3 @@
 export function getPackageInfo() {
-  return { version: '0.1.0', name: '@aztec/pxe' };
+  return { version: '3.0.0', name: '@aztec/pxe' };
 }