@aztec/pxe 0.63.0 → 0.64.0

package/src/synchronizer/synchronizer.ts

@@ -1,9 +1,14 @@
-import { type AztecNode, type L2Block } from '@aztec/circuit-types';
+import {
+  type AztecNode,
+  L2BlockStream,
+  type L2BlockStreamEvent,
+  type L2BlockStreamEventHandler,
+} from '@aztec/circuit-types';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { type SerialQueue } from '@aztec/foundation/queue';
-import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type L2TipsStore } from '@aztec/kv-store/stores';
 
+import { type PXEConfig } from '../config/index.js';
 import { type PxeDatabase } from '../database/index.js';
 
 /**
@@ -13,14 +18,51 @@ import { type PxeDatabase } from '../database/index.js';
  * details, and fetch transactions by hash. The Synchronizer ensures that it maintains the note processors
  * in sync with the blockchain while handling retries and errors gracefully.
  */
-export class Synchronizer {
-  private runningPromise?: RunningPromise;
+export class Synchronizer implements L2BlockStreamEventHandler {
   private running = false;
   private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
   private log: DebugLogger;
+  protected readonly blockStream: L2BlockStream;
 
-  constructor(private node: AztecNode, private db: PxeDatabase, private jobQueue: SerialQueue, logSuffix = '') {
+  constructor(
+    private node: AztecNode,
+    private db: PxeDatabase,
+    private l2TipsStore: L2TipsStore,
+    config: Partial<Pick<PXEConfig, 'l2BlockPollingIntervalMS' | 'l2StartingBlock'>> = {},
+    logSuffix?: string,
+  ) {
     this.log = createDebugLogger(logSuffix ? `aztec:pxe_synchronizer_${logSuffix}` : 'aztec:pxe_synchronizer');
+    this.blockStream = this.createBlockStream(config);
+  }
+
+  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockPollingIntervalMS' | 'l2StartingBlock'>>) {
+    return new L2BlockStream(this.node, this.l2TipsStore, this, {
+      pollIntervalMS: config.l2BlockPollingIntervalMS,
+      startingBlock: config.l2StartingBlock,
+    });
+  }
+
+  /** 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':
+        this.log.verbose(`Processing blocks ${event.blocks[0].number} to ${event.blocks.at(-1)!.number}`);
+        await this.db.setHeader(event.blocks.at(-1)!.header);
+        break;
+      case 'chain-pruned':
+        this.log.info(`Pruning data after block ${event.blockNumber} due to reorg`);
+        // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
+        await this.db.unnullifyNotesAfter(event.blockNumber);
+        await this.db.removeNotesAfter(event.blockNumber);
+        // 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.
+        await this.db.resetNoteSyncData();
+        // Update the header to the last block.
+        await this.db.setHeader(await this.node.getBlockHeader(event.blockNumber));
+        break;
+    }
   }
 
   /**
@@ -31,79 +73,21 @@ export class Synchronizer {
    * @param limit - The maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
    * @param retryInterval - The time interval (in ms) to wait before retrying if no data is available.
    */
-  public async start(limit = 1, retryInterval = 1000) {
+  public async start() {
     if (this.running) {
       return;
     }
     this.running = true;
 
-    await this.jobQueue.put(() => this.initialSync());
+    // REFACTOR: We should know the header of the genesis block without having to request it from the node.
+    await this.db.setHeader(await this.node.getBlockHeader(0));
+
+    await this.trigger();
     this.log.info('Initial sync complete');
-    this.runningPromise = new RunningPromise(() => this.sync(limit), retryInterval);
-    this.runningPromise.start();
+    this.blockStream.start();
     this.log.debug('Started loop');
   }
 
-  protected async initialSync() {
-    // fast forward to the latest block
-    const latestHeader = await this.node.getHeader();
-    this.initialSyncBlockNumber = Number(latestHeader.globalVariables.blockNumber.toBigInt());
-    await this.db.setHeader(latestHeader);
-  }
-
-  /**
-   * Fetches encrypted logs and blocks from the Aztec node and processes them for all note processors.
-   * If needed, catches up note processors that are lagging behind the main sync, e.g. because we just added a new account.
-   *
-   * Uses the job queue to ensure that
-   * - sync does not overlap with pxe simulations.
-   * - one sync is running at a time.
-   *
-   * @param limit - The maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
-   * @returns a promise that resolves when the sync is complete
-   */
-  protected sync(limit: number) {
-    return this.jobQueue.put(async () => {
-      let moreWork = true;
-      // keep external this.running flag to interrupt greedy sync
-      while (moreWork && this.running) {
-        moreWork = await this.work(limit);
-      }
-    });
-  }
-
-  /**
-   * Fetches encrypted logs and blocks from the Aztec node and processes them for all note processors.
-   *
-   * @param limit - The maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
-   * @returns true if there could be more work, false if we're caught up or there was an error.
-   */
-  protected async work(limit = 1): Promise<boolean> {
-    const from = this.getSynchedBlockNumber() + 1;
-    try {
-      const blocks = await this.node.getBlocks(from, limit);
-      if (blocks.length === 0) {
-        return false;
-      }
-
-      // Update latest tree roots from the most recent block
-      const latestBlock = blocks[blocks.length - 1];
-      await this.setHeaderFromBlock(latestBlock);
-      return true;
-    } catch (err) {
-      this.log.error(`Error in synchronizer work`, err);
-      return false;
-    }
-  }
-
-  private async setHeaderFromBlock(latestBlock: L2Block) {
-    if (latestBlock.number < this.initialSyncBlockNumber) {
-      return;
-    }
-
-    await this.db.setHeader(latestBlock.header);
-  }
-
   /**
    * Stops the synchronizer gracefully, interrupting any ongoing sleep and waiting for the current
    * iteration to complete before setting the running state to false. Once stopped, the synchronizer
@@ -113,10 +97,15 @@ export class Synchronizer {
    */
   public async stop() {
     this.running = false;
-    await this.runningPromise?.stop();
+    await this.blockStream.stop();
     this.log.info('Stopped');
   }
 
+  /** Triggers a single run. */
+  public async trigger() {
+    await this.blockStream.sync();
+  }
+
   private getSynchedBlockNumber() {
     return this.db.getBlockNumber() ?? this.initialSyncBlockNumber;
   }