refactor(PXE): clean up block sync (#19026)

Block sync is currently handled through collaboration of `Synchronizer`,
`SyncDataProvider`, and even `PXEOracleInterface#getAnchorBlock`.

## Current problems
- The names aren't very intuitive (`Synchronizer` and `SyncDataProvider`
only handle chain state data at the end of the day).
- Any code running inside `ContractFunctionSimulator` can call
`getAnchorBlock` whenever it pleases. This works currently because calls
to `Synchronizer` are carefully orchestrated from PXE. But it seems
error prone, obscure, and it gives the false impression that function
simulation happens on live block data when it actually depends on a
static anchor.
- There are multiple ways throughout the app to get the anchor block:
`Synchronizer#getSynchedBlock` (unused),
`PXEOracleInterface#getAnchorBlock` (unnecessary, inappropriate),
`SyncDataProvider#getBlockNumber` (redundant), and
`SyncDataProvider#getBlockHeader` (the one that should be the source of
truth)
- Many checks are relying on block number when they should rely on block
hash.

## Refactor

(note: adjusted naming after discussing with @benesjan)

- Rename `Synchronizer` => `BlockSynchronizer`
- Rename `SyncDataProvider` => `AnchorBlockDataProvider`
- Remove `AnchorBlockDataProvider#getBlockNumber`.
`AnchorBlockDataProvider#getBlockHeader` remains the only way to consume
current block information for the rest of the app. To get the block
number, there's a simple `getBlockNumber` accessor in `BlockHeader`.
- Remove `ExecutionDataProvider#getAnchorBlock`. Instead, explicitly
pass anchor block headers as params to functions in "the realm" of
`ContractFunctionSimulator` (`run`, `runUtility`,
`varifyCurrentClassId`, etc).

## Out of scope of PR

> - Many checks are relying on block number when they should rely on
block hash.

This should be tackled on a per use case/feature basis in future PRs,
though relying on `getBlockHeader` solely seems aligned in the right
direction.

Closes F-225

Author: mverzilli

…xe/src/synchronizer/synchronizer.test.ts …_synchronizer/block_synchronizer.test.tsyarn-project/pxe/src/synchronizer/synchronizer.test.ts renamed to yarn-project/pxe/src/block_synchronizer/block_synchronizer.test.ts yarn-project/pxe/src/synchronizer/synchronizer.test.ts renamed to yarn-project/pxe/src/block_synchronizer/block_synchronizer.test.ts

@@ -9,21 +9,21 @@ import { randomPublishedL2Block } from '@aztec/stdlib/testing';
 import { jest } from '@jest/globals';
 import { type MockProxy, mock } from 'jest-mock-extended';
 
+import { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
 import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
 import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
-import { Synchronizer } from './synchronizer.js';
+import { BlockSynchronizer } from './block_synchronizer.js';
 
-describe('Synchronizer', () => {
-  let synchronizer: Synchronizer;
+describe('BlockSynchronizer', () => {
+  let synchronizer: BlockSynchronizer;
   let tipsStore: L2TipsKVStore;
-  let syncDataProvider: SyncDataProvider;
+  let anchorBlockDataProvider: AnchorBlockDataProvider;
   let noteDataProvider: NoteDataProvider;
   let taggingDataProvider: TaggingDataProvider;
   let aztecNode: MockProxy<AztecNode>;
   let blockStream: MockProxy<L2BlockStream>;
 
-  const TestSynchronizer = class extends Synchronizer {
+  const TestSynchronizer = class extends BlockSynchronizer {
     protected override createBlockStream(): L2BlockStream {
       return blockStream;
     }
@@ -34,17 +34,23 @@ describe('Synchronizer', () => {
     blockStream = mock<L2BlockStream>();
     aztecNode = mock<AztecNode>();
     tipsStore = new L2TipsKVStore(store, 'pxe');
-    syncDataProvider = new SyncDataProvider(store);
+    anchorBlockDataProvider = new AnchorBlockDataProvider(store);
     noteDataProvider = await NoteDataProvider.create(store);
     taggingDataProvider = new TaggingDataProvider(store);
-    synchronizer = new TestSynchronizer(aztecNode, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore);
+    synchronizer = new TestSynchronizer(
+      aztecNode,
+      anchorBlockDataProvider,
+      noteDataProvider,
+      taggingDataProvider,
+      tipsStore,
+    );
   });
 
   it('sets header from latest block', async () => {
     const block = await randomPublishedL2Block(1);
     await synchronizer.handleBlockStreamEvent({ type: 'blocks-added', blocks: [block] });
 
-    const obtainedHeader = await syncDataProvider.getBlockHeader();
+    const obtainedHeader = await anchorBlockDataProvider.getBlockHeader();
     expect(obtainedHeader).toEqual(block.block.getBlockHeader());
   });
 

…ect/pxe/src/synchronizer/synchronizer.ts …block_synchronizer/block_synchronizer.tsyarn-project/pxe/src/synchronizer/synchronizer.ts renamed to yarn-project/pxe/src/block_synchronizer/block_synchronizer.ts yarn-project/pxe/src/synchronizer/synchronizer.ts renamed to yarn-project/pxe/src/block_synchronizer/block_synchronizer.ts

@@ -5,23 +5,23 @@ import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler
 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';
 
 /**
- * The Synchronizer class orchestrates synchronization between the PXE and Aztec node, maintaining an up-to-date
+ * 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 {
+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: L2TipsKVStore,
@@ -30,7 +30,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   ) {
     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);
   }
@@ -56,13 +56,13 @@ export class Synchronizer implements L2BlockStreamEventHandler {
           archive: lastBlock.archive.root.toString(),
           header: lastBlock.header.toInspect(),
         });
-        await this.syncDataProvider.setHeader(lastBlock.getBlockHeader());
+        await this.anchorBlockDataProvider.setHeader(lastBlock.getBlockHeader());
         break;
       }
       case 'chain-pruned': {
         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();
+        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.
@@ -72,7 +72,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
         if (!newHeader) {
           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;
       }
@@ -82,6 +82,11 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   /**
    * 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 +109,14 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     let currentHeader;
 
     try {
-      currentHeader = await this.syncDataProvider.getBlockHeader();
+      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(BlockNumber.ZERO))!);
+      await this.anchorBlockDataProvider.setHeader((await this.node.getBlockHeader(BlockNumber.ZERO))!);
     }
     await this.blockStream.sync();
   }
-
-  public getSynchedBlockNumber() {
-    return this.syncDataProvider.getBlockNumber();
-  }
 }

yarn-project/pxe/src/block_synchronizer/index.ts

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

yarn-project/pxe/src/config/index.ts

@@ -19,14 +19,14 @@ 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;
 }
 
-export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & SynchronizerConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 
 export type CliPXEOptions = {
   /** Custom Aztec Node URL to connect to  */

yarn-project/pxe/src/contract_function_simulator/contract_function_simulator.ts

@@ -59,6 +59,7 @@ import { PrivateLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import {
+  BlockHeader,
   CallContext,
   HashedValues,
   PrivateExecutionResult,
@@ -98,6 +99,7 @@ export class ContractFunctionSimulator {
    * @param contractAddress - The address of the contract (should match request.origin)
    * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract
    * or a specific account.
+   * @param anchorBlockHeader - The block header to use as base state for this run.
    * @param senderForTags - The address that is used as a tagging sender when emitting private logs. Returned from
    * the `privateGetSenderForTags` oracle.
    * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
@@ -108,13 +110,13 @@ export class ContractFunctionSimulator {
     contractAddress: AztecAddress,
     selector: FunctionSelector,
     msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
+    anchorBlockHeader: BlockHeader,
     senderForTags?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     const simulatorSetupTimer = new Timer();
-    const anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
 
-    await verifyCurrentClassId(contractAddress, this.executionDataProvider);
+    await verifyCurrentClassId(contractAddress, this.executionDataProvider, anchorBlockHeader);
 
     const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
 
@@ -213,20 +215,34 @@ export class ContractFunctionSimulator {
    * Runs a utility function.
    * @param call - The function call to execute.
    * @param authwits - Authentication witnesses required for the function call.
+   * @param anchorBlockHeader - The block header to use as base state for this run.
    * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
    * accounts if not specified.
    * @returns A return value of the utility function in a form as returned by the simulator (Noir fields)
    */
-  public async runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<Fr[]> {
-    await verifyCurrentClassId(call.to, this.executionDataProvider);
+  public async runUtility(
+    call: FunctionCall,
+    authwits: AuthWitness[],
+    anchorBlockHeader: BlockHeader,
+    scopes?: AztecAddress[],
+  ): Promise<Fr[]> {
+    await verifyCurrentClassId(call.to, this.executionDataProvider, anchorBlockHeader);
 
     const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
 
     if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
     }
 
-    const oracle = new UtilityExecutionOracle(call.to, authwits, [], this.executionDataProvider, undefined, scopes);
+    const oracle = new UtilityExecutionOracle(
+      call.to,
+      authwits,
+      [],
+      anchorBlockHeader,
+      this.executionDataProvider,
+      undefined,
+      scopes,
+    );
 
     try {
       this.log.verbose(`Executing utility function ${entryPointArtifact.name}`, {

yarn-project/pxe/src/contract_function_simulator/execution_data_provider.ts

@@ -10,7 +10,7 @@ import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader, NodeStats } from '@aztec/stdlib/tx';
+import type { NodeStats } from '@aztec/stdlib/tx';
 
 import type { NoteData } from './oracle/interfaces.js';
 import type { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
@@ -138,14 +138,6 @@ export interface ExecutionDataProvider {
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
 
-  /**
-   * Retrieve the latest block header synchronized by the execution data provider. This block header is referred
-   * to as the anchor block header in Aztec terminology and it defines the state that is used during private function
-   * execution.
-   * @returns The anchor block header.
-   */
-  getAnchorBlockHeader(): Promise<BlockHeader>;
-
   /**
    * Fetches the index and sibling path of a leaf at a given block from a given tree.
    * @param blockNumber - The block number at which to get the membership witness.

yarn-project/pxe/src/contract_function_simulator/oracle/interfaces.ts

@@ -63,7 +63,7 @@ export interface IMiscOracle {
 export interface IUtilityExecutionOracle {
   isUtility: true;
 
-  utilityGetUtilityContext(): Promise<UtilityContext>;
+  utilityGetUtilityContext(): UtilityContext;
   utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
   utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance>;
   utilityGetMembershipWitness(blockNumber: BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;

yarn-project/pxe/src/contract_function_simulator/oracle/oracle.ts

@@ -112,9 +112,9 @@ export class Oracle {
     return [values.map(toACVMField)];
   }
 
-  async utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
-    const context = await this.handlerAsUtility().utilityGetUtilityContext();
-    return context.toNoirRepresentation();
+  utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
+    return Promise.resolve(context.toNoirRepresentation());
   }
 
   async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {

yarn-project/pxe/src/contract_function_simulator/oracle/oracle_version_is_checked.test.ts

@@ -25,7 +25,6 @@ describe('Oracle Version Check test suite', () => {
     // Mock basic oracle responses
     executionDataProvider.getPublicStorageAt.mockResolvedValue(Fr.ZERO);
     executionDataProvider.loadCapsule.mockImplementation((_, __) => Promise.resolve(null));
-    executionDataProvider.getAnchorBlockHeader.mockResolvedValue(BlockHeader.empty());
     executionDataProvider.getContractInstance.mockResolvedValue({
       currentContractClassId: new Fr(42),
       originalContractClassId: new Fr(42),
@@ -68,7 +67,7 @@ describe('Oracle Version Check test suite', () => {
       // Call the private function with arbitrary message sender and sender for tags
       const msgSender = await AztecAddress.random();
       const senderForTags = await AztecAddress.random();
-      await acirSimulator.run(txRequest, contractAddress, selector, msgSender, senderForTags);
+      await acirSimulator.run(txRequest, contractAddress, selector, msgSender, BlockHeader.random(), senderForTags);
 
       expect(executionDataProvider.assertCompatibleOracleVersion).toHaveBeenCalledTimes(1);
     }, 30_000);
@@ -97,7 +96,7 @@ describe('Oracle Version Check test suite', () => {
       };
 
       // Call the utility function
-      await acirSimulator.runUtility(execRequest, [], []);
+      await acirSimulator.runUtility(execRequest, [], BlockHeader.random(), []);
 
       expect(executionDataProvider.assertCompatibleOracleVersion).toHaveBeenCalledTimes(1);
     }, 30_000);