@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/src/block_synchronizer/block_synchronizer.ts

@@ -1,16 +1,13 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+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 {
-  L2BlockHash,
-  L2BlockStream,
-  type L2BlockStreamEvent,
-  type L2BlockStreamEventHandler,
-} from '@aztec/stdlib/block';
+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 { PXEConfig } from '../config/index.js';
+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';
@@ -32,23 +29,27 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private noteStore: NoteStore,
     private privateEventStore: PrivateEventStore,
     private l2TipsStore: L2TipsKVStore,
-    config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
-    loggerOrSuffix?: string | Logger,
+    private contractSyncService: ContractSyncService,
+    private config: Partial<BlockSynchronizerConfig> = {},
+    bindings?: LoggerBindings,
   ) {
-    this.log =
-      !loggerOrSuffix || typeof loggerOrSuffix === 'string'
-        ? createLogger(loggerOrSuffix ? `pxe:block_synchronizer:${loggerOrSuffix}` : `pxe:block_synchronizer`)
-        : loggerOrSuffix;
+    this.log = createLogger('pxe:block_synchronizer', bindings);
     this.blockStream = this.createBlockStream(config);
   }
 
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>>) {
-    return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-      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,
-    });
+  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. */
@@ -57,23 +58,55 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
 
     switch (event.type) {
       case 'blocks-added': {
-        const lastBlock = event.blocks.at(-1)!;
-        this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
-          blockHash: lastBlock.hash(),
-          archive: lastBlock.archive.root.toString(),
-          header: lastBlock.header.toInspect(),
-        });
-        await this.anchorBlockStore.setHeader(lastBlock.header);
+        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`);
 
-        const oldAnchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
         // 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(L2BlockHash.fromString(event.block.hash));
+        const newAnchorBlockHeader = await this.node.getBlockHeader(BlockHash.fromString(event.block.hash));
 
         if (!newAnchorBlockHeader) {
           throw new Error(
@@ -83,15 +116,25 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
 
         // Operations are wrapped in a single transaction to ensure atomicity.
         await this.store.transactionAsync(async () => {
-          await this.noteStore.rollback(event.block.number, oldAnchorBlockNumber);
-          await this.privateEventStore.rollback(event.block.number, oldAnchorBlockNumber);
-          await this.anchorBlockStore.setHeader(newAnchorBlockHeader);
+          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) {
+    // 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);
+  }
+
   /**
    * 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.

package/src/config/index.ts

@@ -24,6 +24,8 @@ export interface KernelProverConfig {
 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 & BlockSynchronizerConfig;
@@ -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: '4.0.0', name: '@aztec/pxe' };
+  return { version: '5.0.0', name: '@aztec/pxe' };
 }