@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.e3c1de76

package/src/bin/check_oracle_version.ts

@@ -1,6 +1,11 @@
-import { keccak256String } from '@aztec/foundation/crypto';
+/* 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 } from '../contract_function_simulator/oracle/oracle.js';
 import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
 
 /**
@@ -16,6 +21,22 @@ import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
  * 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',
@@ -25,26 +46,116 @@ function assertOracleInterfaceMatches(): void {
     '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');
 
-  // We use keccak256 here just because we already have it in the dependencies.
-  const oracleInterfaceHash = keccak256String(oracleInterfaceMethodNames);
-  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.`,
-    );
+  // 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/block_synchronizer/block_synchronizer.ts

@@ -0,0 +1,172 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+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 { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+import type { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+
+/**
+ * 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 BlockSynchronizer implements L2BlockStreamEventHandler {
+  private log: Logger;
+  private isSyncing: Promise<void> | undefined;
+  protected readonly blockStream: L2BlockStream;
+
+  constructor(
+    private node: AztecNode,
+    private store: AztecAsyncKVStore,
+    private anchorBlockStore: AnchorBlockStore,
+    private noteStore: NoteStore,
+    private privateEventStore: PrivateEventStore,
+    private l2TipsStore: L2TipsKVStore,
+    private config: Partial<BlockSynchronizerConfig> = {},
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('pxe:block_synchronizer', bindings);
+    this.blockStream = this.createBlockStream(config);
+  }
+
+  protected createBlockStream(config: Partial<BlockSynchronizerConfig>): L2BlockStream {
+    return new L2BlockStream(
+      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,
+      },
+    );
+  }
+
+  /** Handle events emitted by the block stream. */
+  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    await this.l2TipsStore.handleBlockStreamEvent(event);
+
+    switch (event.type) {
+      case 'blocks-added': {
+        if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
+          const lastBlock = event.blocks.at(-1)!;
+          await this.updateAnchorBlockHeader(lastBlock.header);
+        }
+        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);
+        }
+        break;
+      }
+      case 'chain-proven': {
+        if (this.config.syncChainTip === 'proven') {
+          const blockHeader = await this.node.getBlockHeader(BlockNumber(event.block.number));
+          if (blockHeader) {
+            await this.updateAnchorBlockHeader(blockHeader);
+          }
+        }
+        break;
+      }
+      case 'chain-finalized': {
+        if (this.config.syncChainTip === 'finalized') {
+          const blockHeader = await this.node.getBlockHeader(BlockNumber(event.block.number));
+          if (blockHeader) {
+            await this.updateAnchorBlockHeader(blockHeader);
+          }
+        }
+        break;
+      }
+      case 'chain-pruned': {
+        const currentAnchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+        const currentAnchorBlockNumber = currentAnchorBlockHeader.getBlockNumber();
+        if (currentAnchorBlockNumber <= event.block.number) {
+          this.log.verbose(
+            `Ignoring prune event to block ${event.block.number} greater than current anchor block ${currentAnchorBlockNumber}`,
+            { pruneEvent: event, currentAnchorBlockHeader: currentAnchorBlockHeader.toInspect() },
+          );
+          return;
+        }
+
+        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
+
+        // 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
+        // forward.
+        const newAnchorBlockHeader = await this.node.getBlockHeader(BlockHash.fromString(event.block.hash));
+
+        if (!newAnchorBlockHeader) {
+          throw new Error(
+            `Block header for block number ${event.block.number} and hash ${event.block.hash} not found during chain prune. This likely indicates a bug in the node, as we receive block stream events and fetch block headers from the same node.`,
+          );
+        }
+
+        // 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.updateAnchorBlockHeader(newAnchorBlockHeader);
+        });
+        break;
+      }
+    }
+  }
+
+  /** Updates the anchor block header to the target block */
+  private async updateAnchorBlockHeader(blockHeader: BlockHeader) {
+    this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
+    await this.anchorBlockStore.setHeader(blockHeader);
+  }
+
+  /**
+   * 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) {
+      this.log.debug(`Waiting for the ongoing sync to finish`);
+      await this.isSyncing;
+      return;
+    }
+
+    this.log.debug(`Syncing PXE with the node`);
+    const isSyncing = this.doSync();
+    this.isSyncing = isSyncing;
+    try {
+      await isSyncing;
+    } finally {
+      this.isSyncing = undefined;
+    }
+  }
+
+  private async doSync() {
+    let currentHeader;
+
+    try {
+      currentHeader = await this.anchorBlockStore.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.anchorBlockStore.setHeader((await this.node.getBlockHeader(BlockNumber.ZERO))!);
+    }
+    await this.blockStream.sync();
+  }
+}

package/src/block_synchronizer/index.ts

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

package/src/config/index.ts

@@ -19,14 +19,16 @@ export interface KernelProverConfig {
 }
 
 /**
- * Configuration settings for the synchronizer.
+ * Configuration settings for the block synchronizer.
  */
-export interface SynchronizerConfig {
+export interface BlockSynchronizerConfig {
   /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
   l2BlockBatchSize: number;
+  /** Which chain tip to sync to (proposed, checkpointed, proven, finalized) */
+  syncChainTip?: 'proposed' | 'checkpointed' | 'proven' | 'finalized';
 }
 
-export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & SynchronizerConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 
 export type CliPXEOptions = {
   /** Custom Aztec Node URL to connect to  */
@@ -53,6 +55,18 @@ export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
     description: 'Enable real proofs',
     ...booleanConfigHelper(true),
   },
+  syncChainTip: {
+    env: 'PXE_SYNC_CHAIN_TIP',
+    description: 'Which chain tip to sync to (proposed, checkpointed, proven, finalized)',
+    defaultValue: 'proposed',
+    parseEnv: (val: string) => {
+      const allowedValues = ['proposed', 'checkpointed', 'proven', 'finalized'];
+      if (allowedValues.includes(val)) {
+        return val;
+      }
+      throw new Error(`Invalid value for PXE_SYNC_CHAIN_TIP: ${val}. Allowed values are: ${allowedValues.join(', ')}`);
+    },
+  },
 };
 
 /**

package/src/config/package_info.ts

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

package/src/contract_function_simulator/benchmarked_node.ts

@@ -0,0 +1,103 @@
+import { Timer } from '@aztec/foundation/timer';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats, RoundTripStats } from '@aztec/stdlib/tx';
+
+/*
+ * Proxy generator for an AztecNode that tracks the time taken for each RPC call and the number of round trips (actual
+ * blocking waits for node responses).
+ *
+ * A round trip is counted when we transition from 0 to 1 in-flight calls, and ends when all concurrent calls complete.
+ * This means parallel calls in Promise.all count as a single round trip.
+ *
+ * Note that batching of RPC calls in `safe_json_rpc_client.ts` could affect the round trip counts but in places we
+ * currently use this information we do not even use HTTP as we have direct access to the Aztec Node instance in TS
+ * (i.e. not running against external node) so this is not a problem for now.
+ *
+ * If you want to use this against external node and the info gets skewed by batching you can set the `maxBatchSize`
+ * value in `safe_json_rpc_client.ts` to 1 (the main motivation for batching was to get around parallel http requests
+ * limits in web browsers which is not a problem when debugging in node.js).
+ */
+export type BenchmarkedNode = AztecNode & { getStats(): NodeStats };
+
+export class BenchmarkedNodeFactory {
+  static create(node: AztecNode): BenchmarkedNode {
+    // Per-method call stats
+    const perMethod: Partial<Record<keyof AztecNode, { times: number[] }>> = {};
+
+    // Round trip tracking
+    let inFlightCount = 0;
+    let currentRoundTripTimer: Timer | null = null;
+    let currentRoundTripMethods: string[] = [];
+    const roundTrips: RoundTripStats = {
+      roundTrips: 0,
+      totalBlockingTime: 0,
+      roundTripDurations: [],
+      roundTripMethods: [],
+    };
+
+    return new Proxy(node, {
+      get(target, prop: keyof BenchmarkedNode) {
+        if (prop === 'getStats') {
+          return (): NodeStats => {
+            return { perMethod, roundTrips };
+          };
+        } else {
+          return function (...args: any[]) {
+            // Track per-method stats
+            if (!perMethod[prop]) {
+              perMethod[prop] = { times: [] };
+            }
+
+            // Start of a new round trip batch?
+            if (inFlightCount === 0) {
+              roundTrips.roundTrips++;
+              currentRoundTripTimer = new Timer();
+              currentRoundTripMethods = [];
+            }
+            inFlightCount++;
+            currentRoundTripMethods.push(prop);
+
+            const callTimer = new Timer();
+            const result = (target[prop] as any).apply(target, args);
+
+            // Handle completion - called when the call finishes (after Promise resolves)
+            const handleCompletion = () => {
+              const callTime = callTimer.ms();
+              perMethod[prop]!.times.push(callTime);
+
+              inFlightCount--;
+
+              // End of round trip batch - all concurrent calls completed
+              if (inFlightCount === 0 && currentRoundTripTimer) {
+                const roundTripTime = currentRoundTripTimer.ms();
+                roundTrips.totalBlockingTime += roundTripTime;
+                roundTrips.roundTripDurations.push(roundTripTime);
+                roundTrips.roundTripMethods.push(currentRoundTripMethods);
+                currentRoundTripTimer = null;
+                currentRoundTripMethods = [];
+              }
+            };
+
+            // If the result is a Promise, chain the completion handler
+            if (result && typeof result.then === 'function') {
+              return result.then(
+                (value: any) => {
+                  handleCompletion();
+                  return value;
+                },
+                (error: any) => {
+                  handleCompletion();
+                  throw error;
+                },
+              );
+            } else {
+              // Synchronous method - handle completion immediately
+              handleCompletion();
+              return result;
+            }
+          };
+        }
+      },
+    }) as BenchmarkedNode;
+  }
+}