@aztec/pxe 0.0.1-commit.86469d5 → 0.0.1-commit.8655d4a

package/src/block_synchronizer/block_synchronizer.ts

@@ -1,5 +1,6 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
 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';
@@ -7,9 +8,11 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
+import type { ContractSyncService } from '../contract_sync/contract_sync_service.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';
+import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
 
 /**
  * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
@@ -19,6 +22,7 @@ import type { PrivateEventStore } from '../storage/private_event_store/private_e
 export class BlockSynchronizer implements L2BlockStreamEventHandler {
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
+  private readonly eventQueue = new SerialQueue();
   protected readonly blockStream: L2BlockStream;
 
   constructor(
@@ -28,16 +32,18 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private noteStore: NoteStore,
     private privateEventStore: PrivateEventStore,
     private l2TipsStore: L2TipsKVStore,
+    private contractSyncService: ContractSyncService,
     private config: Partial<BlockSynchronizerConfig> = {},
     bindings?: LoggerBindings,
   ) {
     this.log = createLogger('pxe:block_synchronizer', bindings);
     this.blockStream = this.createBlockStream(config);
+    this.eventQueue.start();
   }
 
   protected createBlockStream(config: Partial<BlockSynchronizerConfig>): L2BlockStream {
     return new L2BlockStream(
-      this.node,
+      blockStreamSourceFromAztecNode(this.node),
       this.l2TipsStore,
       this,
       createLogger('pxe:block_stream', this.log.getBindings()),
@@ -50,8 +56,12 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     );
   }
 
-  /** Handle events emitted by the block stream. */
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+  /** Handle events emitted by the block stream. Serialized to prevent concurrent mutations to anchor state. */
+  public handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    return this.eventQueue.put(() => this.doHandleBlockStreamEvent(event));
+  }
+
+  private async doHandleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
     await this.l2TipsStore.handleBlockStreamEvent(event);
 
     switch (event.type) {
@@ -72,18 +82,22 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
       }
       case 'chain-proven': {
         if (this.config.syncChainTip === 'proven') {
-          const blockHeader = await this.node.getBlockHeader(BlockNumber(event.block.number));
-          if (blockHeader) {
-            await this.updateAnchorBlockHeader(blockHeader);
+          const block = await this.node.getBlock(BlockNumber(event.block.number));
+          if (block) {
+            await this.updateAnchorBlockHeader(block.header);
+          } else {
+            this.log.warn(`Block header not found for proven block ${event.block.number}, skipping anchor update`);
           }
         }
         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);
+          const block = await this.node.getBlock(BlockNumber(event.block.number));
+          if (block) {
+            await this.updateAnchorBlockHeader(block.header);
+          } else {
+            this.log.warn(`Block header not found for finalized block ${event.block.number}, skipping anchor update`);
           }
         }
         break;
@@ -104,7 +118,8 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
         // 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));
+        const newAnchorBlock = await this.node.getBlock(BlockHash.fromString(event.block.hash));
+        const newAnchorBlockHeader = newAnchorBlock?.header;
 
         if (!newAnchorBlockHeader) {
           throw new Error(
@@ -125,6 +140,10 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
 
   /** Updates the anchor block header to the target block */
   private async updateAnchorBlockHeader(blockHeader: BlockHeader) {
+    // Whenever the anchor block header is updated, we need to synchronize the private state of contracts again.
+    // Therefore, we clear the contract synchronization cache here such that the sync is re-triggered upon new
+    // execution.
+    this.contractSyncService.wipe();
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);
   }
@@ -146,6 +165,8 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
 
     this.log.debug(`Syncing PXE with the node`);
+    // Capture the promise locally so we always await the exact promise we created, even if this.isSyncing is modified
+    // between assignment and await (e.g. due to future refactors introducing a yield point).
     const isSyncing = this.doSync();
     this.isSyncing = isSyncing;
     try {
@@ -155,6 +176,13 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
   }
 
+  /** Stops the block synchronizer, waiting for any in-progress sync and queued events to complete. */
+  public async stop() {
+    await this.isSyncing;
+    await this.blockStream.stop();
+    await this.eventQueue.end();
+  }
+
   private async doSync() {
     let currentHeader;
 
@@ -165,7 +193,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     }
     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.anchorBlockStore.setHeader((await this.node.getBlockData(BlockNumber.ZERO))!.header);
     }
     await this.blockStream.sync();
   }

package/src/config/index.ts

@@ -1,12 +1,13 @@
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
+  enumConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
   parseBooleanEnv,
 } from '@aztec/foundation/config';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 
 export { getPackageInfo } from './package_info.js';
 
@@ -26,6 +27,12 @@ export interface BlockSynchronizerConfig {
   l2BlockBatchSize: number;
   /** Which chain tip to sync to (proposed, checkpointed, proven, finalized) */
   syncChainTip?: 'proposed' | 'checkpointed' | 'proven' | 'finalized';
+  /**
+   * Whether PXE should automatically sync with the node before each operation (simulate, prove, profile,
+   * execute utility, get private events, update contract). When disabled, callers (e.g. wallets) are
+   * responsible for calling `pxe.sync()` explicitly
+   */
+  autoSync: boolean;
 }
 
 export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
@@ -58,14 +65,13 @@ export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
   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(', ')}`);
-    },
+    ...enumConfigHelper(['proposed', 'checkpointed', 'proven', 'finalized'], 'proposed'),
+  },
+  autoSync: {
+    env: 'PXE_AUTO_SYNC',
+    description:
+      'Whether PXE syncs with the node automatically before each operation. Disable to let the caller (e.g. a wallet) drive syncs explicitly via pxe.sync().',
+    ...booleanConfigHelper(true),
   },
 };
 

package/src/config/package_info.ts

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