@aztec/world-state 0.0.0-test.0

package/src/test/utils.ts

@@ -0,0 +1,153 @@
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+} from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+
+import type { NativeWorldStateService } from '../native/native_world_state.js';
+
+export async function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations) {
+  const l2Block = await L2Block.random(blockNum, size);
+  const l1ToL2Messages = Array(16).fill(0).map(Fr.random);
+
+  // Sync the append only trees
+  {
+    const noteHashesPadded = l2Block.body.txEffects.flatMap(txEffect =>
+      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    );
+    await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+
+    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+  }
+
+  // Sync the indexed trees
+  {
+    // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
+    for (const txEffect of l2Block.body.txEffects) {
+      await fork.batchInsert(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        txEffect.publicDataWrites.map(write => write.toBuffer()),
+        0,
+      );
+
+      const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
+
+      await fork.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        nullifiersPadded.map(nullifier => nullifier.toBuffer()),
+        NULLIFIER_SUBTREE_HEIGHT,
+      );
+    }
+  }
+
+  const state = await fork.getStateReference();
+  l2Block.header.state = state;
+  await fork.updateArchive(l2Block.header);
+
+  const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+
+  return {
+    block: l2Block,
+    messages: l1ToL2Messages,
+  };
+}
+
+export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOperations) {
+  const l2Block = L2Block.empty();
+  const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
+
+  l2Block.header.globalVariables.blockNumber = new Fr(blockNum);
+
+  // Sync the append only trees
+  {
+    const noteHashesPadded = l2Block.body.txEffects.flatMap(txEffect =>
+      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    );
+    await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+
+    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+  }
+
+  // Sync the indexed trees
+  {
+    // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
+    for (const txEffect of l2Block.body.txEffects) {
+      await fork.batchInsert(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        txEffect.publicDataWrites.map(write => write.toBuffer()),
+        0,
+      );
+
+      const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
+
+      await fork.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        nullifiersPadded.map(nullifier => nullifier.toBuffer()),
+        NULLIFIER_SUBTREE_HEIGHT,
+      );
+    }
+  }
+
+  const state = await fork.getStateReference();
+  l2Block.header.state = state;
+  await fork.updateArchive(l2Block.header);
+
+  const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+
+  return {
+    block: l2Block,
+    messages: l1ToL2Messages,
+  };
+}
+
+export async function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService) {
+  const tempFork = await worldState.fork(from - 1);
+
+  const blocks = [];
+  const messagesArray = [];
+  for (let blockNumber = from; blockNumber < from + count; blockNumber++) {
+    const { block, messages } = await mockBlock(blockNumber, numTxs, tempFork);
+    blocks.push(block);
+    messagesArray.push(messages);
+  }
+
+  await tempFork.close();
+
+  return { blocks, messages: messagesArray };
+}
+
+export async function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations) {
+  const nativeStateRef = await forkA.getStateReference();
+  const nativeArchive = await forkA.getTreeInfo(MerkleTreeId.ARCHIVE);
+  const legacyStateRef = await forkB.getStateReference();
+  const legacyArchive = await forkB.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  expect(nativeStateRef).toEqual(legacyStateRef);
+  expect(nativeArchive).toEqual(legacyArchive);
+}
+
+export async function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations) {
+  for (const treeId of [
+    MerkleTreeId.ARCHIVE,
+    MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+    MerkleTreeId.NOTE_HASH_TREE,
+    MerkleTreeId.NULLIFIER_TREE,
+    MerkleTreeId.PUBLIC_DATA_TREE,
+  ]) {
+    expect(await left.getTreeInfo(treeId)).toEqual(await right.getTreeInfo(treeId));
+
+    expect(await left.getSiblingPath(treeId, 0n)).toEqual(await right.getSiblingPath(treeId, 0n));
+  }
+}

package/src/testing.ts

@@ -0,0 +1,60 @@
+import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+
+import { NativeWorldStateService } from './native/index.js';
+
+async function generateGenesisValues(prefilledPublicData: PublicDataTreeLeaf[]) {
+  if (!prefilledPublicData.length) {
+    return {
+      genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
+      genesisBlockHash: new Fr(GENESIS_BLOCK_HASH),
+    };
+  }
+
+  // Create a temporary world state to compute the genesis values.
+  const ws = await NativeWorldStateService.tmp(
+    undefined /* rollupAddress */,
+    true /* cleanupTmpDir */,
+    prefilledPublicData,
+  );
+  const initialHeader = ws.getInitialHeader();
+  const genesisBlockHash = await initialHeader.hash();
+  const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
+  await ws.close();
+
+  return {
+    genesisArchiveRoot,
+    genesisBlockHash,
+  };
+}
+
+export const defaultInitialAccountFeeJuice = new Fr(10n ** 22n);
+
+export async function getGenesisValues(
+  initialAccounts: AztecAddress[],
+  initialAccountFeeJuice = defaultInitialAccountFeeJuice,
+  genesisPublicData: PublicDataTreeLeaf[] = [],
+) {
+  // Top up the accounts with fee juice.
+  let prefilledPublicData = await Promise.all(
+    initialAccounts.map(
+      async address => new PublicDataTreeLeaf(await computeFeePayerBalanceLeafSlot(address), initialAccountFeeJuice),
+    ),
+  );
+
+  // Add user-defined public data
+  prefilledPublicData = prefilledPublicData.concat(genesisPublicData);
+
+  prefilledPublicData.sort((a, b) => (b.slot.lt(a.slot) ? 1 : -1));
+
+  const { genesisBlockHash, genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
+
+  return {
+    genesisArchiveRoot,
+    genesisBlockHash,
+    prefilledPublicData,
+  };
+}

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

@@ -0,0 +1,3 @@
+export * from './merkle_tree_db.js';
+
+export type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';

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

@@ -0,0 +1,79 @@
+import { MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import type { IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ForkMerkleTreeOperations, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import type { MerkleTreeId } from '@aztec/stdlib/trees';
+
+import type { WorldStateStatusFull, WorldStateStatusSummary } from '../native/message.js';
+
+/**
+ *
+ * @remarks Short explanation:
+ *    The nullifier tree must be initially padded as the pre-populated 0 index prevents efficient subtree insertion.
+ *    Padding with some values solves this issue.
+ *
+ * @remarks Thorough explanation:
+ *    There needs to be an initial (0,0,0) leaf in the tree, so that when we insert the first 'proper' leaf, we can
+ *    prove that any value greater than 0 doesn't exist in the tree yet. We prefill/pad the tree with "the number of
+ *    leaves that are added by one block" so that the first 'proper' block can insert a full subtree.
+ *
+ *    Without this padding, there would be a leaf (0,0,0) at leaf index 0, making it really difficult to insert e.g.
+ *    1024 leaves for the first block, because there's only neat space for 1023 leaves after 0. By padding with 1023
+ *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
+ */
+export const INITIAL_NULLIFIER_TREE_SIZE = 2 * MAX_NULLIFIERS_PER_TX;
+
+export const INITIAL_PUBLIC_DATA_TREE_SIZE = 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX;
+
+export type TreeSnapshots = {
+  [MerkleTreeId.NULLIFIER_TREE]: IndexedTreeSnapshot;
+  [MerkleTreeId.NOTE_HASH_TREE]: TreeSnapshot<Fr>;
+  [MerkleTreeId.PUBLIC_DATA_TREE]: IndexedTreeSnapshot;
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: TreeSnapshot<Fr>;
+  [MerkleTreeId.ARCHIVE]: TreeSnapshot<Fr>;
+};
+
+export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
+  /**
+   * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
+   * @param block - The L2 block to handle.
+   * @param l1ToL2Messages - The L1 to L2 messages for the block.
+   */
+  handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull>;
+
+  /**
+   * Gets a handle that allows reading the latest committed state
+   */
+  getCommitted(): MerkleTreeReadOperations;
+
+  /**
+   * Removes all historical snapshots up to but not including the given block number
+   * @param toBlockNumber The block number of the new oldest historical block
+   * @returns The new WorldStateStatus
+   */
+  removeHistoricalBlocks(toBlockNumber: bigint): Promise<WorldStateStatusFull>;
+
+  /**
+   * Removes all pending blocks down to but not including the given block number
+   * @param toBlockNumber The block number of the new tip of the pending chain,
+   * @returns The new WorldStateStatus
+   */
+  unwindBlocks(toBlockNumber: bigint): Promise<WorldStateStatusFull>;
+
+  /**
+   * Advances the finalised block number to be the number provided
+   * @param toBlockNumber The block number that is now the tip of the finalised chain
+   * @returns The new WorldStateStatus
+   */
+  setFinalised(toBlockNumber: bigint): Promise<WorldStateStatusSummary>;
+
+  /**
+   * Gets the current status summary of the database.
+   * @returns The current WorldStateStatus.
+   */
+  getStatusSummary(): Promise<WorldStateStatusSummary>;
+
+  /** Stops the database */
+  close(): Promise<void>;
+}