Merge branch 'next' into merge-train/barretenberg

AztecBot · AztecBot · commit b090d22cf1f8 · 2026-01-23T14:39:48.000Z
diff --git a/yarn-project/foundation/src/config/env_var.ts b/yarn-project/foundation/src/config/env_var.ts
@@ -176,6 +176,7 @@ export type EnvVar =
   | 'PROVER_TEST_VERIFICATION_DELAY_MS'
   | 'PXE_L2_BLOCK_BATCH_SIZE'
   | 'PXE_PROVER_ENABLED'
+  | 'PXE_SYNC_CHAIN_TIP'
   | 'RPC_MAX_BATCH_SIZE'
   | 'RPC_MAX_BODY_SIZE'
   | 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT'
diff --git a/yarn-project/pxe/src/block_synchronizer/block_synchronizer.test.ts b/yarn-project/pxe/src/block_synchronizer/block_synchronizer.test.ts
@@ -1,21 +1,25 @@
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { timesParallel } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { GENESIS_CHECKPOINT_HEADER_HASH, L2Block, L2BlockHash, type L2BlockStream } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 import { jest } from '@jest/globals';
 import { type MockProxy, mock } from 'jest-mock-extended';
 
+import type { BlockSynchronizerConfig } from '../config/index.js';
 import { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
 import { NoteStore } from '../storage/note_store/note_store.js';
 import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
 import { BlockSynchronizer } from './block_synchronizer.js';
 
 describe('BlockSynchronizer', () => {
   let synchronizer: BlockSynchronizer;
+  let store: AztecAsyncKVStore;
   let tipsStore: L2TipsKVStore;
   let anchorBlockStore: AnchorBlockStore;
   let noteStore: NoteStore;
@@ -29,15 +33,19 @@ describe('BlockSynchronizer', () => {
     }
   };
 
+  const createSynchronizer = (config: Partial<BlockSynchronizerConfig> = {}) => {
+    return new TestSynchronizer(aztecNode, store, anchorBlockStore, noteStore, privateEventStore, tipsStore, config);
+  };
+
   beforeEach(async () => {
-    const store = await openTmpStore('test');
+    store = await openTmpStore('test');
     blockStream = mock<L2BlockStream>();
     aztecNode = mock<AztecNode>();
     tipsStore = new L2TipsKVStore(store, 'pxe');
     anchorBlockStore = new AnchorBlockStore(store);
     noteStore = new NoteStore(store);
     privateEventStore = new PrivateEventStore(store);
-    synchronizer = new TestSynchronizer(aztecNode, store, anchorBlockStore, noteStore, privateEventStore, tipsStore);
+    synchronizer = createSynchronizer();
   });
 
   it('sets header from latest block', async () => {
@@ -95,4 +103,140 @@ describe('BlockSynchronizer', () => {
 
     expect(rollback).toHaveBeenCalledWith(3, 4);
   });
+
+  describe('syncChainTip config', () => {
+    it('updates anchor on blocks-added when syncChainTip is proposed (default)', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'proposed' });
+      const block = await L2Block.random(BlockNumber(1));
+      await synchronizer.handleBlockStreamEvent({ type: 'blocks-added', blocks: [block] });
+
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(block.header)).toBe(true);
+    });
+
+    it('does not update anchor on blocks-added when syncChainTip is checkpointed', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'checkpointed' });
+
+      // First set a known anchor
+      const initialBlock = await L2Block.random(BlockNumber(0));
+      await anchorBlockStore.setHeader(initialBlock.header);
+
+      // blocks-added should NOT update the anchor
+      const newBlock = await L2Block.random(BlockNumber(1));
+      await synchronizer.handleBlockStreamEvent({ type: 'blocks-added', blocks: [newBlock] });
+
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(initialBlock.header)).toBe(true);
+    });
+
+    it('updates anchor on chain-checkpointed when syncChainTip is checkpointed', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'checkpointed' });
+
+      // Set initial anchor
+      const initialBlock = await L2Block.random(BlockNumber(0));
+      await anchorBlockStore.setHeader(initialBlock.header);
+
+      // Create a checkpoint with a block
+      const checkpointBlock = await L2Block.random(BlockNumber(1));
+      const checkpoint = await Checkpoint.random(CheckpointNumber(1), { numBlocks: 1 });
+      // Replace the random block with our known block
+      checkpoint.blocks[0] = checkpointBlock;
+
+      const publishedCheckpoint = new PublishedCheckpoint(checkpoint, L1PublishedData.random(), []);
+
+      await synchronizer.handleBlockStreamEvent({
+        type: 'chain-checkpointed',
+        checkpoint: publishedCheckpoint,
+        block: { number: BlockNumber(1), hash: '0x456' },
+      });
+
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(checkpointBlock.header)).toBe(true);
+    });
+
+    it('does not update anchor on chain-checkpointed when syncChainTip is proposed', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'proposed' });
+
+      // Set initial anchor via blocks-added
+      const initialBlock = await L2Block.random(BlockNumber(1));
+      await synchronizer.handleBlockStreamEvent({ type: 'blocks-added', blocks: [initialBlock] });
+
+      // Create a different checkpoint
+      const checkpoint = await Checkpoint.random(CheckpointNumber(1), { numBlocks: 1 });
+      const publishedCheckpoint = new PublishedCheckpoint(checkpoint, L1PublishedData.random(), []);
+
+      await synchronizer.handleBlockStreamEvent({
+        type: 'chain-checkpointed',
+        checkpoint: publishedCheckpoint,
+        block: { number: BlockNumber(1), hash: '0x456' },
+      });
+
+      // Anchor should still be the initial block, not the checkpoint block
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(initialBlock.header)).toBe(true);
+    });
+
+    it('updates anchor on chain-proven when syncChainTip is proven', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'proven' });
+
+      // Set initial anchor
+      const initialBlock = await L2Block.random(BlockNumber(0));
+      await anchorBlockStore.setHeader(initialBlock.header);
+
+      // Mock node to return block header
+      const provenBlock = await L2Block.random(BlockNumber(5));
+      aztecNode.getBlockHeader.mockResolvedValue(provenBlock.header);
+
+      await synchronizer.handleBlockStreamEvent({
+        type: 'chain-proven',
+        block: { number: BlockNumber(5), hash: '0x789' },
+      });
+
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(provenBlock.header)).toBe(true);
+    });
+
+    it('updates anchor on chain-finalized when syncChainTip is finalized', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'finalized' });
+
+      // Set initial anchor
+      const initialBlock = await L2Block.random(BlockNumber(0));
+      await anchorBlockStore.setHeader(initialBlock.header);
+
+      // Mock node to return block header
+      const finalizedBlock = await L2Block.random(BlockNumber(10));
+      aztecNode.getBlockHeader.mockResolvedValue(finalizedBlock.header);
+
+      await synchronizer.handleBlockStreamEvent({
+        type: 'chain-finalized',
+        block: { number: BlockNumber(10), hash: '0xabc' },
+      });
+
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(finalizedBlock.header)).toBe(true);
+    });
+
+    it('ignores prune event when anchor is already at or below prune point', async () => {
+      synchronizer = createSynchronizer({ syncChainTip: 'checkpointed' });
+
+      // Set anchor to block 2
+      const anchorBlock = await L2Block.random(BlockNumber(2));
+      await anchorBlockStore.setHeader(anchorBlock.header);
+
+      const rollback = jest.spyOn(noteStore, 'rollback').mockImplementation(() => Promise.resolve());
+
+      // Prune to block 3 (above anchor) - should be ignored
+      await synchronizer.handleBlockStreamEvent({
+        type: 'chain-pruned',
+        block: { number: BlockNumber(3), hash: '0x3' },
+        checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
+      });
+
+      expect(rollback).not.toHaveBeenCalled();
+
+      // Anchor should be unchanged
+      const obtainedHeader = await anchorBlockStore.getBlockHeader();
+      expect(obtainedHeader.equals(anchorBlock.header)).toBe(true);
+    });
+  });
 });
diff --git a/yarn-project/pxe/src/block_synchronizer/block_synchronizer.ts b/yarn-project/pxe/src/block_synchronizer/block_synchronizer.ts
@@ -9,8 +9,9 @@ import {
   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 { 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,7 +33,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private noteStore: NoteStore,
     private privateEventStore: PrivateEventStore,
     private l2TipsStore: L2TipsKVStore,
-    config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
+    private config: Partial<BlockSynchronizerConfig> = {},
     loggerOrSuffix?: string | Logger,
   ) {
     this.log =
@@ -42,7 +43,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     this.blockStream = this.createBlockStream(config);
   }
 
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>>) {
+  protected createBlockStream(config: Partial<BlockSynchronizerConfig>): L2BlockStream {
     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
@@ -57,19 +58,51 @@ 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.
@@ -83,15 +116,21 @@ 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) {
+    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.
diff --git a/yarn-project/pxe/src/config/index.ts b/yarn-project/pxe/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(', ')}`);
+    },
+  },
 };
 
 /**
