@aztec/world-state 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,4 +1,3 @@
-import { INITIAL_CHECKPOINT_NUMBER } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -6,15 +5,13 @@ import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
 import {
   type BlockHash,
-  GENESIS_CHECKPOINT_HEADER_HASH,
+  EventDrivenL2BlockStream,
   type L2Block,
-  type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
   type L2BlockStreamEventHandler,
   type L2BlockStreamLocalDataProvider,
-  type L2Tips,
+  type LocalChainTips,
 } from '@aztec/stdlib/block';
 import {
   WorldStateRunningState,
@@ -51,7 +48,7 @@ export class ServerWorldStateSynchronizer
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
 
   private syncPromise = promiseWithResolvers<void>();
-  protected blockStream: L2BlockStream | undefined;
+  protected blockStream: EventDrivenL2BlockStream | undefined;
 
   // WorldState doesn't track the proven block number, it only tracks the latest tips of the pending chain and the finalized chain
   // store the proven block number here, in the synchronizer, so that we don't end up spamming the logs with 'chain-proved' events
@@ -81,6 +78,46 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeDb.getSnapshot(blockNumber);
   }
 
+  public async getVerifiedSnapshot(blockNumber: BlockNumber, blockHash: BlockHash): Promise<MerkleTreeReadOperations> {
+    const snapshot = this.merkleTreeDb.getSnapshot(blockNumber);
+    // Block 0's snapshot is the pre-genesis archive view (size 0), so archive leaf 0 is not visible from it;
+    // verify against the initial header hash instead. For later blocks, read archive leaf `blockNumber` from the
+    // snapshot's own view so the exact handle we return is validated against the requested fork.
+    const actualHash =
+      blockNumber === BlockNumber.ZERO
+        ? (await this.merkleTreeCommitted.getInitialHeader().hash()).toString()
+        : (await snapshot.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber)))?.toString();
+
+    if (actualHash === undefined) {
+      // A missing archive leaf means either the block's history has been pruned away (permanent: the block predates
+      // the oldest historical block kept by world state) or a reorg flipped the fork between the sync and this read
+      // (transient). Only the latter is worth retrying, so it alone surfaces as WorldStateSynchronizerError.
+      const { oldestHistoricalBlock } = await this.merkleTreeDb.getStatusSummary();
+      if (blockNumber < oldestHistoricalBlock) {
+        throw new Error(
+          `Unable to find leaf for block ${blockNumber} in the archive tree: world state history has been pruned to block ${oldestHistoricalBlock}`,
+        );
+      }
+      throw new WorldStateSynchronizerError(`Unable to read block hash at block ${blockNumber} to verify snapshot`, {
+        cause: { reason: 'block_not_available', targetBlockNumber: blockNumber },
+      });
+    }
+    if (actualHash !== blockHash.toString()) {
+      throw new WorldStateSynchronizerError(
+        `Block hash mismatch at block ${blockNumber} (expected ${blockHash} but got ${actualHash})`,
+        {
+          cause: {
+            reason: 'block_hash_mismatch',
+            targetBlockNumber: blockNumber,
+            expectedHash: blockHash.toString(),
+            actualHash,
+          },
+        },
+      );
+    }
+    return snapshot;
+  }
+
   public fork(blockNumber?: BlockNumber, opts?: { closeDelayMs?: number }): Promise<MerkleTreeWriteOperations> {
     return this.merkleTreeDb.fork(blockNumber, opts);
   }
@@ -123,9 +160,9 @@ export class ServerWorldStateSynchronizer
     return this.syncPromise.promise;
   }
 
-  protected createBlockStream(): L2BlockStream {
+  protected createBlockStream(): EventDrivenL2BlockStream {
     const logger = createLogger('world-state:block_stream');
-    return new L2BlockStream(this.l2BlockSource, this, this, logger, {
+    return new EventDrivenL2BlockStream(this.l2BlockSource, this, this, logger, {
       pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
       batchSize: this.config.worldStateBlockRequestBatchSize,
       ignoreCheckpoints: true,
@@ -266,8 +303,12 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then(leaf => leaf?.toString());
   }
 
-  /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
-  public async getL2Tips(): Promise<L2Tips> {
+  /**
+   * Returns the proposed, proven, and finalized block tips of the chain. World state drives its block stream with
+   * `ignoreCheckpoints`, so it does not track checkpointed blocks or checkpoints and omits `checkpointed` from the tips
+   * it reports.
+   */
+  public async getL2Tips(): Promise<LocalChainTips> {
     const status = await this.merkleTreeDb.getStatusSummary();
     const unfinalizedBlockHashPromise = this.getL2BlockHash(status.unfinalizedBlockNumber);
     const finalizedBlockHashPromise = this.getL2BlockHash(status.finalizedBlockNumber);
@@ -281,30 +322,13 @@ export class ServerWorldStateSynchronizer
       finalizedBlockHashPromise,
       provenBlockHashPromise,
     ]);
-    const latestBlockId: L2BlockId = { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash! };
-
-    // World state doesn't track checkpointed blocks or checkpoints themselves.
-    // but we use a block stream so we need to provide 'local' L2Tips.
-    // We configure the block stream to ignore checkpoints and set checkpoint values to genesis here.
-    const genesisCheckpointHeaderHash = GENESIS_CHECKPOINT_HEADER_HASH.toString();
-    const initialBlockHash = (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     return {
-      proposed: latestBlockId,
-      checkpointed: {
-        block: { number: BlockNumber.ZERO, hash: initialBlockHash },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
-      },
-      proposedCheckpoint: {
-        block: { number: BlockNumber.ZERO, hash: initialBlockHash },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
-      },
+      proposed: { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash },
       finalized: {
-        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash ?? '' },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash },
       },
       proven: {
-        block: { number: provenBlockNumber, hash: provenBlockHash ?? '' },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+        block: { number: provenBlockNumber, hash: provenBlockHash },
       },
     };
   }
@@ -324,6 +348,15 @@ export class ServerWorldStateSynchronizer
       case 'chain-finalized':
         await this.handleChainFinalized(event.block.number);
         break;
+      // World state runs in block mode with ignoreCheckpoints: it tracks tips via blocks-added/pruned/proven/finalized
+      // and ignores the thin tip events (it never anchors on them).
+      case 'chain-proposed':
+      case 'chain-checkpointed':
+        break;
+      default: {
+        const _: never = event;
+        break;
+      }
     }
   }
 

package/src/test/utils.ts

@@ -60,7 +60,16 @@ export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], for
   await Promise.all([publicDataInsert, nullifierInsert, noteHashInsert, messageInsert]);
 
   const state = await fork.getStateReference();
-  block.header = BlockHeader.from({ ...block.header, state });
+
+  // Capture the archive root *before* appending this block so the header's lastArchive chains off the previous block.
+  // sync_block now verifies lastArchive against the committed archive root, so a block carrying an unchained value
+  // (e.g. the random lastArchive from L2Block.random) would be rejected as a divergence from the canonical chain.
+  const previousArchive = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+  block.header = BlockHeader.from({
+    ...block.header,
+    state,
+    lastArchive: new AppendOnlyTreeSnapshot(Fr.fromBuffer(previousArchive.root), Number(previousArchive.size)),
+  });
   await fork.updateArchive(block.header);
 
   const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);

package/src/testing.ts

@@ -8,14 +8,19 @@ import type { GenesisData } from '@aztec/stdlib/world-state';
 import { NativeWorldStateService } from './native/index.js';
 
 async function generateGenesisValues(genesis: GenesisData) {
-  if (!genesis.prefilledPublicData.length && genesis.genesisTimestamp === 0n) {
+  // The GENESIS_ARCHIVE_ROOT constant reflects the canonical empty genesis (no public data, no prefilled nullifiers,
+  // timestamp 0), so we can only short-circuit when this genesis adds none of those on top.
+  if (!genesis.prefilledPublicData.length && genesis.genesisTimestamp === 0n && !genesis.prefilledNullifiers?.length) {
     return {
       genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
     };
   }
 
-  // Create a temporary world state to compute the genesis values.
-  const ws = await NativeWorldStateService.tmp(/*cleanupTmpDir=*/ true, genesis);
+  // Compute the genesis values on a throwaway world state. The archive root derives deterministically from the
+  // prefilled public data, the prefilled nullifiers, and the genesis timestamp, so the fsync-off ephemeral store (no
+  // version manager, no crash-recoverability) produces an identical root while skipping the fsync overhead that `tmp`
+  // pays. close() removes the tmpdir.
+  const ws = await NativeWorldStateService.ephemeral(genesis);
   const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
   await ws.close();
 
@@ -31,6 +36,7 @@ export async function getGenesisValues(
   initialAccountFeeJuice = defaultInitialAccountFeeJuice,
   genesisPublicData: PublicDataTreeLeaf[] = [],
   genesisTimestamp: bigint = 0n,
+  prefilledNullifiers: Fr[] = [],
 ) {
   // Top up the accounts with fee juice.
   let prefilledPublicData = await Promise.all(
@@ -44,7 +50,11 @@ export async function getGenesisValues(
 
   prefilledPublicData.sort((a, b) => (b.slot.lt(a.slot) ? 1 : -1));
 
-  const genesis: GenesisData = { prefilledPublicData, genesisTimestamp };
+  // The indexed nullifier tree requires its prefilled leaves to be unique and strictly increasing, so sort ascending
+  // here (a copy, to avoid mutating the caller's array) rather than relying on the caller's ordering.
+  const sortedNullifiers = [...prefilledNullifiers].sort((a, b) => (a.toBigInt() < b.toBigInt() ? -1 : 1));
+
+  const genesis: GenesisData = { prefilledPublicData, prefilledNullifiers: sortedNullifiers, genesisTimestamp };
   const { genesisArchiveRoot } = await generateGenesisValues(genesis);
 
   return {

package/dest/native/world_state_operation.d.ts

@@ -1,7 +0,0 @@
-/**
- * Names of the world-state operations, used as labels for instrumentation and
- * logging. (Read/write ordering is enforced server-side by the wsdb scheduler,
- * so there is no longer a client-side operation queue.)
- */
-export type WorldStateOperationName = 'getTreeInfo' | 'getStateReference' | 'getInitialStateReference' | 'getLeafValue' | 'getLeafPreimage' | 'getSiblingPath' | 'getBlockNumbersForLeafIndices' | 'findLeafIndices' | 'findLowLeaf' | 'findSiblingPaths' | 'appendLeaves' | 'batchInsert' | 'sequentialInsert' | 'updateArchive' | 'syncBlock' | 'createFork' | 'deleteFork' | 'finalizeBlocks' | 'unwindBlocks' | 'removeHistoricalBlocks' | 'getStatus' | 'createCheckpoint' | 'commitCheckpoint' | 'revertCheckpoint' | 'commitAllCheckpoints' | 'revertAllCheckpoints' | 'copyStores';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfb3BlcmF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbmF0aXZlL3dvcmxkX3N0YXRlX29wZXJhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxNQUFNLHVCQUF1QixHQUMvQixhQUFhLEdBQ2IsbUJBQW1CLEdBQ25CLDBCQUEwQixHQUMxQixjQUFjLEdBQ2QsaUJBQWlCLEdBQ2pCLGdCQUFnQixHQUNoQiwrQkFBK0IsR0FDL0IsaUJBQWlCLEdBQ2pCLGFBQWEsR0FDYixrQkFBa0IsR0FDbEIsY0FBYyxHQUNkLGFBQWEsR0FDYixrQkFBa0IsR0FDbEIsZUFBZSxHQUNmLFdBQVcsR0FDWCxZQUFZLEdBQ1osWUFBWSxHQUNaLGdCQUFnQixHQUNoQixjQUFjLEdBQ2Qsd0JBQXdCLEdBQ3hCLFdBQVcsR0FDWCxrQkFBa0IsR0FDbEIsa0JBQWtCLEdBQ2xCLGtCQUFrQixHQUNsQixzQkFBc0IsR0FDdEIsc0JBQXNCLEdBQ3RCLFlBQVksQ0FBQyJ9

package/dest/native/world_state_operation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"world_state_operation.d.ts","sourceRoot":"","sources":["../../src/native/world_state_operation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAC/B,aAAa,GACb,mBAAmB,GACnB,0BAA0B,GAC1B,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,+BAA+B,GAC/B,iBAAiB,GACjB,aAAa,GACb,kBAAkB,GAClB,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,eAAe,GACf,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,cAAc,GACd,wBAAwB,GACxB,WAAW,GACX,kBAAkB,GAClB,kBAAkB,GAClB,kBAAkB,GAClB,sBAAsB,GACtB,sBAAsB,GACtB,YAAY,CAAC"}

package/dest/native/world_state_operation.js

@@ -1,5 +0,0 @@
-/**
- * Names of the world-state operations, used as labels for instrumentation and
- * logging. (Read/write ordering is enforced server-side by the wsdb scheduler,
- * so there is no longer a client-side operation queue.)
- */ export { };

package/src/native/world_state_operation.ts

@@ -1,33 +0,0 @@
-/**
- * Names of the world-state operations, used as labels for instrumentation and
- * logging. (Read/write ordering is enforced server-side by the wsdb scheduler,
- * so there is no longer a client-side operation queue.)
- */
-export type WorldStateOperationName =
-  | 'getTreeInfo'
-  | 'getStateReference'
-  | 'getInitialStateReference'
-  | 'getLeafValue'
-  | 'getLeafPreimage'
-  | 'getSiblingPath'
-  | 'getBlockNumbersForLeafIndices'
-  | 'findLeafIndices'
-  | 'findLowLeaf'
-  | 'findSiblingPaths'
-  | 'appendLeaves'
-  | 'batchInsert'
-  | 'sequentialInsert'
-  | 'updateArchive'
-  | 'syncBlock'
-  | 'createFork'
-  | 'deleteFork'
-  | 'finalizeBlocks'
-  | 'unwindBlocks'
-  | 'removeHistoricalBlocks'
-  | 'getStatus'
-  | 'createCheckpoint'
-  | 'commitCheckpoint'
-  | 'revertCheckpoint'
-  | 'commitAllCheckpoints'
-  | 'revertAllCheckpoints'
-  | 'copyStores';