@aztec/world-state 0.16.4 → 0.16.6

package/src/merkle-tree/merkle_tree_snapshot_operations_facade.ts

@@ -1,143 +0,0 @@
-import { Fr } from '@aztec/circuits.js';
-import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
-import { BatchInsertionResult, IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
-import { MerkleTreeId, SiblingPath } from '@aztec/types';
-
-import { CurrentTreeRoots, HandleL2BlockResult, MerkleTreeDb, MerkleTreeOperations, TreeInfo } from '../index.js';
-
-/**
- * Merkle tree operations on readonly tree snapshots.
- */
-export class MerkleTreeSnapshotOperationsFacade implements MerkleTreeOperations {
-  #treesDb: MerkleTreeDb;
-  #blockNumber: number;
-  #treeSnapshots: ReadonlyArray<TreeSnapshot | IndexedTreeSnapshot> = [];
-
-  constructor(trees: MerkleTreeDb, blockNumber: number) {
-    this.#treesDb = trees;
-    this.#blockNumber = blockNumber;
-  }
-
-  async #getTreeSnapshot(merkleTreeId: number): Promise<TreeSnapshot | IndexedTreeSnapshot> {
-    if (this.#treeSnapshots[merkleTreeId]) {
-      return this.#treeSnapshots[merkleTreeId];
-    }
-
-    this.#treeSnapshots = await this.#treesDb.getSnapshot(this.#blockNumber);
-    return this.#treeSnapshots[merkleTreeId]!;
-  }
-
-  async findLeafIndex(treeId: MerkleTreeId, value: Buffer): Promise<bigint | undefined> {
-    const tree = await this.#getTreeSnapshot(treeId);
-    return tree.findLeafIndex(value);
-  }
-
-  getLatestGlobalVariablesHash(): Promise<Fr> {
-    return Promise.reject(new Error('not implemented'));
-  }
-
-  async getLeafPreimage(
-    treeId: MerkleTreeId.NULLIFIER_TREE,
-    index: bigint,
-  ): Promise<IndexedTreeLeafPreimage | undefined> {
-    const snapshot = (await this.#getTreeSnapshot(treeId)) as IndexedTreeSnapshot;
-    return snapshot.getLatestLeafPreimageCopy(BigInt(index));
-  }
-
-  async getLeafValue(treeId: MerkleTreeId, index: bigint): Promise<Buffer | undefined> {
-    const snapshot = await this.#getTreeSnapshot(treeId);
-    return snapshot.getLeafValue(BigInt(index));
-  }
-
-  getPreviousValueIndex(
-    _treeId: MerkleTreeId.NULLIFIER_TREE,
-    _value: bigint,
-  ): Promise<
-    | {
-        /**
-         * The index of the found leaf.
-         */
-        index: bigint;
-        /**
-         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
-         */
-        alreadyPresent: boolean;
-      }
-    | undefined
-  > {
-    return Promise.reject(new Error('not implemented'));
-  }
-
-  async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
-    const snapshot = await this.#getTreeSnapshot(treeId);
-    return snapshot.getSiblingPath(index);
-  }
-
-  async getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
-    const snapshot = await this.#getTreeSnapshot(treeId);
-    return {
-      depth: snapshot.getDepth(),
-      root: snapshot.getRoot(),
-      size: snapshot.getNumLeaves(),
-      treeId,
-    };
-  }
-
-  async getTreeRoots(): Promise<CurrentTreeRoots> {
-    const snapshots = await Promise.all([
-      this.#getTreeSnapshot(MerkleTreeId.CONTRACT_TREE),
-      this.#getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE),
-      this.#getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE),
-      this.#getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE),
-      this.#getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
-      this.#getTreeSnapshot(MerkleTreeId.BLOCKS_TREE),
-    ]);
-
-    return {
-      blocksTreeRoot: snapshots[MerkleTreeId.BLOCKS_TREE].getRoot(),
-      contractDataTreeRoot: snapshots[MerkleTreeId.CONTRACT_TREE].getRoot(),
-      l1Tol2MessagesTreeRoot: snapshots[MerkleTreeId.L1_TO_L2_MESSAGES_TREE].getRoot(),
-      noteHashTreeRoot: snapshots[MerkleTreeId.NOTE_HASH_TREE].getRoot(),
-      nullifierTreeRoot: snapshots[MerkleTreeId.NULLIFIER_TREE].getRoot(),
-      publicDataTreeRoot: snapshots[MerkleTreeId.PUBLIC_DATA_TREE].getRoot(),
-    };
-  }
-
-  appendLeaves(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number>(): Promise<
-    BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>
-  > {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  updateBlocksTree(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  commit(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  handleL2Block(): Promise<HandleL2BlockResult> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  rollback(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  updateHistoricBlocksTree(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  updateLatestGlobalVariablesHash(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-
-  updateLeaf(): Promise<void> {
-    return Promise.reject(new Error('Tree snapshot operations are read-only'));
-  }
-}

package/src/synchronizer/config.ts

@@ -1,27 +0,0 @@
-/**
- * World State synchronizer configuration values.
- */
-export interface WorldStateConfig {
-  /**
-   * The frequency in which to check.
-   */
-  worldStateBlockCheckIntervalMS: number;
-
-  /**
-   * Size of queue of L2 blocks to store.
-   */
-  l2QueueSize: number;
-}
-
-/**
- * Returns the configuration values for the world state synchronizer.
- * @returns The configuration values for the world state synchronizer.
- */
-export function getConfigEnvVars(): WorldStateConfig {
-  const { WS_BLOCK_CHECK_INTERVAL_MS, WS_L2_BLOCK_QUEUE_SIZE } = process.env;
-  const envVars: WorldStateConfig = {
-    worldStateBlockCheckIntervalMS: WS_BLOCK_CHECK_INTERVAL_MS ? +WS_BLOCK_CHECK_INTERVAL_MS : 100,
-    l2QueueSize: WS_L2_BLOCK_QUEUE_SIZE ? +WS_L2_BLOCK_QUEUE_SIZE : 1000,
-  };
-  return envVars;
-}

package/src/synchronizer/index.ts

@@ -1,2 +0,0 @@
-export * from './server_world_state_synchronizer.js';
-export * from './world_state_synchronizer.js';

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,248 +0,0 @@
-import { SerialQueue } from '@aztec/foundation/fifo';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { elapsed } from '@aztec/foundation/timer';
-import { L2Block, L2BlockDownloader, L2BlockSource } from '@aztec/types';
-import { L2BlockHandledStats } from '@aztec/types/stats';
-
-import { LevelUp } from 'levelup';
-
-import { HandleL2BlockResult, MerkleTreeOperations, MerkleTrees } from '../index.js';
-import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
-import { MerkleTreeSnapshotOperationsFacade } from '../merkle-tree/merkle_tree_snapshot_operations_facade.js';
-import { WorldStateConfig } from './config.js';
-import { WorldStateRunningState, WorldStateStatus, WorldStateSynchronizer } from './world_state_synchronizer.js';
-
-const DB_KEY_BLOCK_NUMBER = 'latestBlockNumber';
-
-/**
- * Synchronizes the world state with the L2 blocks from a L2BlockSource.
- * The synchronizer will download the L2 blocks from the L2BlockSource and insert the new commitments into the merkle
- * tree.
- */
-export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
-  private currentL2BlockNum = 0;
-  private latestBlockNumberAtStart = 0;
-
-  private l2BlockDownloader: L2BlockDownloader;
-  private syncPromise: Promise<void> = Promise.resolve();
-  private syncResolve?: () => void = undefined;
-  private jobQueue = new SerialQueue();
-  private stopping = false;
-  private runningPromise: Promise<void> = Promise.resolve();
-  private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
-
-  private constructor(
-    private db: LevelUp,
-    private merkleTreeDb: MerkleTrees,
-    private l2BlockSource: L2BlockSource,
-    config: WorldStateConfig,
-    private log = createDebugLogger('aztec:world_state'),
-  ) {
-    this.l2BlockDownloader = new L2BlockDownloader(
-      l2BlockSource,
-      config.l2QueueSize,
-      config.worldStateBlockCheckIntervalMS,
-    );
-  }
-
-  public getLatest(): MerkleTreeOperations {
-    return new MerkleTreeOperationsFacade(this.merkleTreeDb, true);
-  }
-
-  public getCommitted(): MerkleTreeOperations {
-    return new MerkleTreeOperationsFacade(this.merkleTreeDb, false);
-  }
-
-  public getSnapshot(blockNumber: number): MerkleTreeOperations {
-    return new MerkleTreeSnapshotOperationsFacade(this.merkleTreeDb, blockNumber);
-  }
-
-  public static async new(
-    db: LevelUp,
-    merkleTreeDb: MerkleTrees,
-    l2BlockSource: L2BlockSource,
-    config: WorldStateConfig,
-    log = createDebugLogger('aztec:world_state'),
-  ) {
-    const server = new ServerWorldStateSynchronizer(db, merkleTreeDb, l2BlockSource, config, log);
-    await server.#init();
-    return server;
-  }
-
-  async #init() {
-    await this.restoreCurrentL2BlockNumber();
-  }
-
-  public async start() {
-    if (this.currentState === WorldStateRunningState.STOPPED) {
-      throw new Error('Synchronizer already stopped');
-    }
-    if (this.currentState !== WorldStateRunningState.IDLE) {
-      return this.syncPromise;
-    }
-
-    // get the current latest block number
-    this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
-
-    const blockToDownloadFrom = this.currentL2BlockNum + 1;
-
-    // if there are blocks to be retrieved, go to a synching state
-    if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
-      this.setCurrentState(WorldStateRunningState.SYNCHING);
-      this.syncPromise = new Promise(resolve => {
-        this.syncResolve = resolve;
-      });
-      this.log(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
-    } else {
-      // if no blocks to be retrieved, go straight to running
-      this.setCurrentState(WorldStateRunningState.RUNNING);
-      this.syncPromise = Promise.resolve();
-      this.log(`Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`);
-    }
-
-    // start looking for further blocks
-    const blockProcess = async () => {
-      while (!this.stopping) {
-        await this.jobQueue.put(() => this.collectAndProcessBlocks());
-      }
-    };
-    this.jobQueue.start();
-    this.runningPromise = blockProcess();
-    this.l2BlockDownloader.start(blockToDownloadFrom);
-    this.log(`Started block downloader from block ${blockToDownloadFrom}`);
-    return this.syncPromise;
-  }
-
-  public async stop() {
-    this.log('Stopping world state...');
-    this.stopping = true;
-    await this.l2BlockDownloader.stop();
-    await this.jobQueue.cancel();
-    await this.merkleTreeDb.stop();
-    await this.runningPromise;
-    await this.commitCurrentL2BlockNumber();
-    this.setCurrentState(WorldStateRunningState.STOPPED);
-  }
-
-  public status(): Promise<WorldStateStatus> {
-    const status = {
-      syncedToL2Block: this.currentL2BlockNum,
-      state: this.currentState,
-    } as WorldStateStatus;
-    return Promise.resolve(status);
-  }
-
-  /**
-   * Forces an immediate sync
-   * @param minBlockNumber - The minimum block number that we must sync to
-   * @returns A promise that resolves with the block number the world state was synced to
-   */
-  public async syncImmediate(minBlockNumber?: number): Promise<number> {
-    if (this.currentState !== WorldStateRunningState.RUNNING) {
-      throw new Error(`World State is not running, unable to perform sync`);
-    }
-    // If we have been given a block number to sync to and we have reached that number
-    // then return.
-    if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
-      return this.currentL2BlockNum;
-    }
-    const blockToSyncTo = minBlockNumber === undefined ? 'latest' : `${minBlockNumber}`;
-    this.log(`World State at block ${this.currentL2BlockNum}, told to sync to block ${blockToSyncTo}...`);
-    // ensure any outstanding block updates are completed first.
-    await this.jobQueue.syncPoint();
-    while (true) {
-      // Check the block number again
-      if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
-        return this.currentL2BlockNum;
-      }
-      // Poll for more blocks
-      const numBlocks = await this.l2BlockDownloader.pollImmediate();
-      this.log(`Block download immediate poll yielded ${numBlocks} blocks`);
-      if (numBlocks) {
-        // More blocks were received, process them and go round again
-        await this.jobQueue.put(() => this.collectAndProcessBlocks());
-        continue;
-      }
-      // No blocks are available, if we have been given a block number then we can't achieve it
-      if (minBlockNumber !== undefined) {
-        throw new Error(
-          `Unable to sync to block number ${minBlockNumber}, currently synced to block ${this.currentL2BlockNum}`,
-        );
-      }
-      return this.currentL2BlockNum;
-    }
-  }
-
-  /**
-   * Checks for the availability of new blocks and processes them.
-   */
-  private async collectAndProcessBlocks() {
-    // This request for blocks will timeout after 1 second if no blocks are received
-    const blocks = await this.l2BlockDownloader.getBlocks(1);
-    await this.handleL2Blocks(blocks);
-    await this.commitCurrentL2BlockNumber();
-  }
-
-  /**
-   * Handles a list of L2 blocks (i.e. Inserts the new commitments into the merkle tree).
-   * @param l2Blocks - The L2 blocks to handle.
-   * @returns Whether the block handled was produced by this same node.
-   */
-  private async handleL2Blocks(l2Blocks: L2Block[]) {
-    for (const l2Block of l2Blocks) {
-      const [duration, result] = await elapsed(() => this.handleL2Block(l2Block));
-      this.log(`Handled new L2 block`, {
-        eventName: 'l2-block-handled',
-        duration,
-        isBlockOurs: result.isBlockOurs,
-        ...l2Block.getStats(),
-      } satisfies L2BlockHandledStats);
-    }
-  }
-
-  /**
-   * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
-   * @param l2Block - The L2 block to handle.
-   */
-  private async handleL2Block(l2Block: L2Block): Promise<HandleL2BlockResult> {
-    const result = await this.merkleTreeDb.handleL2Block(l2Block);
-    this.currentL2BlockNum = l2Block.number;
-    if (
-      this.currentState === WorldStateRunningState.SYNCHING &&
-      this.currentL2BlockNum >= this.latestBlockNumberAtStart
-    ) {
-      this.setCurrentState(WorldStateRunningState.RUNNING);
-      if (this.syncResolve !== undefined) {
-        this.syncResolve();
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Method to set the value of the current state.
-   * @param newState - New state value.
-   */
-  private setCurrentState(newState: WorldStateRunningState) {
-    this.currentState = newState;
-    this.log(`Moved to state ${WorldStateRunningState[this.currentState]}`);
-  }
-
-  private async commitCurrentL2BlockNumber() {
-    const hex = this.currentL2BlockNum.toString(16);
-    const encoded = Buffer.from(hex.length % 2 === 1 ? '0' + hex : hex, 'hex');
-
-    await this.db.put(DB_KEY_BLOCK_NUMBER, encoded);
-  }
-
-  private async restoreCurrentL2BlockNumber() {
-    try {
-      const encoded: Buffer = await this.db.get(DB_KEY_BLOCK_NUMBER);
-      this.currentL2BlockNum = parseInt(encoded.toString('hex'), 16);
-      this.log.debug(`Restored current L2 block number ${this.currentL2BlockNum} from db`);
-    } catch (err) {
-      this.log.debug('No current L2 block number found in db, starting from 0');
-      this.currentL2BlockNum = 0;
-    }
-  }
-}

package/src/synchronizer/world_state_synchronizer.ts

@@ -1,73 +0,0 @@
-import { MerkleTreeOperations } from '../index.js';
-
-/**
- * Defines the possible states of the world state synchronizer.
- */
-export enum WorldStateRunningState {
-  IDLE,
-  SYNCHING,
-  RUNNING,
-  STOPPED,
-}
-
-/**
- * Defines the status of the world state synchronizer.
- */
-export interface WorldStateStatus {
-  /**
-   * The current state of the world state synchronizer.
-   */
-  state: WorldStateRunningState;
-  /**
-   * The block number that the world state synchronizer is synced to.
-   */
-  syncedToL2Block: number;
-}
-
-/**
- * Defines the interface for a world state synchronizer.
- */
-export interface WorldStateSynchronizer {
-  /**
-   * Starts the synchronizer.
-   * @returns A promise that resolves once the initial sync is completed.
-   */
-  start(): void;
-
-  /**
-   * Returns the current status of the synchronizer.
-   * @returns The current status of the synchronizer.
-   */
-  status(): Promise<WorldStateStatus>;
-
-  /**
-   * Stops the synchronizer.
-   */
-  stop(): Promise<void>;
-
-  /**
-   * Forces an immediate sync to an optionally provided minimum block number
-   * @param minBlockNumber - The minimum block number that we must sync to
-   * @returns A promise that resolves with the block number the world state was synced to
-   */
-  syncImmediate(minBlockNumber?: number): Promise<number>;
-
-  /**
-   * Returns an instance of MerkleTreeOperations that will include uncommitted data.
-   * @returns An instance of MerkleTreeOperations that will include uncommitted data.
-   */
-  getLatest(): MerkleTreeOperations;
-
-  /**
-   * Returns an instance of MerkleTreeOperations that will not include uncommitted data.
-   * @returns An instance of MerkleTreeOperations that will not include uncommitted data.
-   */
-  getCommitted(): MerkleTreeOperations;
-
-  /**
-   * Returns a readonly instance of MerkleTreeOperations where the state is as it was at the given block number
-   * @param block - The block number to look at
-   * @returns An instance of MerkleTreeOperations
-   */
-  getSnapshot(block: number): MerkleTreeOperations;
-}

package/src/world-state-db/index.ts

@@ -1,2 +0,0 @@
-export * from './merkle_trees.js';
-export * from './merkle_tree_db.js';