@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/native/merkle_trees_facade.ts

@@ -1,5 +1,8 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { sleep } from '@aztec/foundation/sleep';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 import type {
   BatchInsertionResult,
@@ -18,6 +21,7 @@ import {
   PublicDataTreeLeafPreimage,
 } from '@aztec/stdlib/trees';
 import { type BlockHeader, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
+import { type WorldStateRevision, WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
 
 import assert from 'assert';
 
@@ -25,7 +29,6 @@ import {
   type SerializedIndexedLeaf,
   type SerializedLeafValue,
   WorldStateMessageType,
-  type WorldStateRevision,
   blockStateReference,
   treeStateReferenceToSnapshot,
 } from './message.js';
@@ -42,10 +45,32 @@ export class MerkleTreesFacade implements MerkleTreeReadOperations {
     return this.initialHeader;
   }
 
+  getRevision(): WorldStateRevisionWithHandle {
+    return WorldStateRevisionWithHandle.fromWorldStateRevision(this.revision, this.instance.getHandle());
+  }
+
   findLeafIndices(treeId: MerkleTreeId, values: MerkleTreeLeafType<MerkleTreeId>[]): Promise<(bigint | undefined)[]> {
     return this.findLeafIndicesAfter(treeId, values, 0n);
   }
 
+  async findSiblingPaths<N extends number>(
+    treeId: MerkleTreeId,
+    values: MerkleTreeLeafType<MerkleTreeId>[],
+  ): Promise<({ path: SiblingPath<N>; index: bigint } | undefined)[]> {
+    const response = await this.instance.call(WorldStateMessageType.FIND_SIBLING_PATHS, {
+      leaves: values.map(leaf => serializeLeaf(hydrateLeaf(treeId, leaf))),
+      revision: this.revision,
+      treeId,
+    });
+
+    return response.paths.map(path => {
+      if (!path) {
+        return undefined;
+      }
+      return { path: new SiblingPath<N>(path.path.length as N, path.path), index: BigInt(path.index) };
+    });
+  }
+
   async findLeafIndicesAfter(
     treeId: MerkleTreeId,
     leaves: MerkleTreeLeafType<MerkleTreeId>[],
@@ -169,19 +194,26 @@ export class MerkleTreesFacade implements MerkleTreeReadOperations {
   async getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
     treeId: ID,
     leafIndices: bigint[],
-  ): Promise<(bigint | undefined)[]> {
+  ): Promise<(BlockNumber | undefined)[]> {
     const response = await this.instance.call(WorldStateMessageType.GET_BLOCK_NUMBERS_FOR_LEAF_INDICES, {
       treeId,
       revision: this.revision,
       leafIndices,
     });
 
-    return response.blockNumbers.map(x => (x === undefined || x === null ? undefined : BigInt(x)));
+    return response.blockNumbers.map(x => (x === undefined || x === null ? undefined : BlockNumber(Number(x))));
   }
 }
 
 export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTreeWriteOperations {
-  constructor(instance: NativeWorldStateInstance, initialHeader: BlockHeader, revision: WorldStateRevision) {
+  private log = createLogger('world-state:merkle-trees-fork-facade');
+
+  constructor(
+    instance: NativeWorldStateInstance,
+    initialHeader: BlockHeader,
+    revision: WorldStateRevision,
+    private opts: { closeDelayMs?: number },
+  ) {
     assert.notEqual(revision.forkId, 0, 'Fork ID must be set');
     assert.equal(revision.includeUncommitted, true, 'Fork must include uncommitted data');
     super(instance, initialHeader, revision);
@@ -260,12 +292,37 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
 
   public async close(): Promise<void> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
-    await this.instance.call(WorldStateMessageType.DELETE_FORK, { forkId: this.revision.forkId });
+    try {
+      await this.instance.call(WorldStateMessageType.DELETE_FORK, { forkId: this.revision.forkId });
+    } catch (err: any) {
+      // Ignore errors due to native instance being closed during shutdown.
+      // This can happen when validators are still processing block proposals while the node is stopping.
+      if (err?.message === 'Native instance is closed') {
+        return;
+      }
+      throw err;
+    }
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    if (this.opts.closeDelayMs) {
+      void sleep(this.opts.closeDelayMs)
+        .then(() => this.close())
+        .catch(err => {
+          if (err && 'message' in err && err.message === 'Native instance is closed') {
+            return; // Ignore errors due to native instance being closed
+          }
+          this.log.warn('Error closing MerkleTreesForkFacade after delay', { err });
+        });
+    } else {
+      await this.close();
+    }
   }
 
-  public async createCheckpoint(): Promise<void> {
+  public async createCheckpoint(): Promise<number> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
-    await this.instance.call(WorldStateMessageType.CREATE_CHECKPOINT, { forkId: this.revision.forkId });
+    const resp = await this.instance.call(WorldStateMessageType.CREATE_CHECKPOINT, { forkId: this.revision.forkId });
+    return resp.depth;
   }
 
   public async commitCheckpoint(): Promise<void> {
@@ -277,6 +334,22 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
     await this.instance.call(WorldStateMessageType.REVERT_CHECKPOINT, { forkId: this.revision.forkId });
   }
+
+  public async commitAllCheckpointsTo(depth: number): Promise<void> {
+    assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+    await this.instance.call(WorldStateMessageType.COMMIT_ALL_CHECKPOINTS, {
+      forkId: this.revision.forkId,
+      depth,
+    });
+  }
+
+  public async revertAllCheckpointsTo(depth: number): Promise<void> {
+    assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+    await this.instance.call(WorldStateMessageType.REVERT_ALL_CHECKPOINTS, {
+      forkId: this.revision.forkId,
+      depth,
+    });
+  }
 }
 
 function hydrateLeaf<ID extends MerkleTreeId>(treeId: ID, leaf: Fr | Buffer) {
@@ -295,7 +368,7 @@ export function serializeLeaf(leaf: Fr | NullifierLeaf | PublicDataTreeLeaf): Se
   if (leaf instanceof Fr) {
     return leaf.toBuffer();
   } else if (leaf instanceof NullifierLeaf) {
-    return { value: leaf.nullifier.toBuffer() };
+    return { nullifier: leaf.nullifier.toBuffer() };
   } else {
     return { value: leaf.value.toBuffer(), slot: leaf.slot.toBuffer() };
   }
@@ -307,23 +380,22 @@ function deserializeLeafValue(leaf: SerializedLeafValue): Fr | NullifierLeaf | P
   } else if ('slot' in leaf) {
     return new PublicDataTreeLeaf(Fr.fromBuffer(leaf.slot), Fr.fromBuffer(leaf.value));
   } else {
-    return new NullifierLeaf(Fr.fromBuffer(leaf.value));
+    return new NullifierLeaf(Fr.fromBuffer(leaf.nullifier));
   }
 }
 
-function deserializeIndexedLeaf(leaf: SerializedIndexedLeaf): IndexedTreeLeafPreimage {
-  if ('slot' in leaf.value) {
+function deserializeIndexedLeaf(leafPreimage: SerializedIndexedLeaf): IndexedTreeLeafPreimage {
+  if ('slot' in leafPreimage.leaf) {
     return new PublicDataTreeLeafPreimage(
-      Fr.fromBuffer(leaf.value.slot),
-      Fr.fromBuffer(leaf.value.value),
-      Fr.fromBuffer(leaf.nextValue),
-      BigInt(leaf.nextIndex),
+      new PublicDataTreeLeaf(Fr.fromBuffer(leafPreimage.leaf.slot), Fr.fromBuffer(leafPreimage.leaf.value)),
+      Fr.fromBuffer(leafPreimage.nextKey),
+      BigInt(leafPreimage.nextIndex),
     );
-  } else if ('value' in leaf.value) {
+  } else if ('nullifier' in leafPreimage.leaf) {
     return new NullifierLeafPreimage(
-      Fr.fromBuffer(leaf.value.value),
-      Fr.fromBuffer(leaf.nextValue),
-      BigInt(leaf.nextIndex),
+      new NullifierLeaf(Fr.fromBuffer(leafPreimage.leaf.nullifier)),
+      Fr.fromBuffer(leafPreimage.nextKey),
+      BigInt(leafPreimage.nextIndex),
     );
   } else {
     throw new Error('Invalid leaf type');

package/src/native/message.ts

@@ -1,8 +1,11 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
+import type { BlockHash } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { StateReference } from '@aztec/stdlib/tx';
 import type { UInt32 } from '@aztec/stdlib/types';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
 
 export enum WorldStateMessageType {
   GET_TREE_INFO = 100,
@@ -16,6 +19,7 @@ export enum WorldStateMessageType {
 
   FIND_LEAF_INDICES,
   FIND_LOW_LEAF,
+  FIND_SIBLING_PATHS,
 
   APPEND_LEAVES,
   BATCH_INSERT,
@@ -31,7 +35,7 @@ export enum WorldStateMessageType {
   CREATE_FORK,
   DELETE_FORK,
 
-  FINALISE_BLOCKS,
+  FINALIZE_BLOCKS,
   UNWIND_BLOCKS,
   REMOVE_HISTORICAL_BLOCKS,
 
@@ -40,6 +44,10 @@ export enum WorldStateMessageType {
   CREATE_CHECKPOINT,
   COMMIT_CHECKPOINT,
   REVERT_CHECKPOINT,
+  COMMIT_ALL_CHECKPOINTS,
+  REVERT_ALL_CHECKPOINTS,
+
+  COPY_STORES,
 
   CLOSE = 999,
 }
@@ -50,11 +58,11 @@ interface WithTreeId {
 
 export interface WorldStateStatusSummary {
   /** Last block number that can still be unwound. */
-  unfinalisedBlockNumber: bigint;
-  /** Last block number that is finalised and cannot be unwound. */
-  finalisedBlockNumber: bigint;
+  unfinalizedBlockNumber: BlockNumber;
+  /** Last block number that is finalized and cannot be unwound. */
+  finalizedBlockNumber: BlockNumber;
   /** Oldest block still available for historical queries and forks. */
-  oldestHistoricalBlock: bigint;
+  oldestHistoricalBlock: BlockNumber;
   /** Whether the trees are in sync with each other */
   treesAreSynched: boolean;
 }
@@ -75,11 +83,11 @@ export interface TreeMeta {
   /** The tree's initial root value  */
   initialRoot: Fr;
   /** The current oldest historical block number of the tree */
-  oldestHistoricBlock: bigint;
-  /** The current unfinalised block number of the tree */
-  unfinalisedBlockHeight: bigint;
-  /** The current finalised block number of the tree */
-  finalisedBlockHeight: bigint;
+  oldestHistoricBlock: BlockNumber;
+  /** The current unfinalized block number of the tree */
+  unfinalizedBlockHeight: BlockNumber;
+  /** The current finalized block number of the tree */
+  finalizedBlockHeight: BlockNumber;
 }
 
 export interface DBStats {
@@ -94,6 +102,8 @@ export interface DBStats {
 export interface TreeDBStats {
   /** The configured max size of the DB mapping file (effectively the max possible size of the DB) */
   mapSize: bigint;
+  /** The physical file size of the database on disk */
+  physicalFileSize: bigint;
   /** Stats for the 'blocks' DB */
   blocksDBStats: DBStats;
   /** Stats for the 'nodes' DB */
@@ -149,6 +159,7 @@ export function buildEmptyDBStats() {
 export function buildEmptyTreeDBStats() {
   return {
     mapSize: 0n,
+    physicalFileSize: 0n,
     blocksDBStats: buildEmptyDBStats(),
     nodesDBStats: buildEmptyDBStats(),
     leafIndicesDBStats: buildEmptyDBStats(),
@@ -164,9 +175,9 @@ export function buildEmptyTreeMeta() {
     depth: 0,
     size: 0n,
     committedSize: 0n,
-    unfinalisedBlockHeight: 0n,
-    finalisedBlockHeight: 0n,
-    oldestHistoricBlock: 0n,
+    unfinalizedBlockHeight: BlockNumber.ZERO,
+    finalizedBlockHeight: BlockNumber.ZERO,
+    oldestHistoricBlock: BlockNumber.ZERO,
     root: Fr.ZERO,
     initialRoot: Fr.ZERO,
     initialSize: 0n,
@@ -195,9 +206,9 @@ export function buildEmptyWorldStateDBStats() {
 
 export function buildEmptyWorldStateSummary() {
   return {
-    unfinalisedBlockNumber: 0n,
-    finalisedBlockNumber: 0n,
-    oldestHistoricalBlock: 0n,
+    unfinalizedBlockNumber: BlockNumber.ZERO,
+    finalizedBlockNumber: BlockNumber.ZERO,
+    oldestHistoricalBlock: BlockNumber.ZERO,
     treesAreSynched: true,
   } as WorldStateStatusSummary;
 }
@@ -210,61 +221,62 @@ export function buildEmptyWorldStateStatusFull() {
   } as WorldStateStatusFull;
 }
 
-export function sanitiseSummary(summary: WorldStateStatusSummary) {
-  summary.finalisedBlockNumber = BigInt(summary.finalisedBlockNumber);
-  summary.unfinalisedBlockNumber = BigInt(summary.unfinalisedBlockNumber);
-  summary.oldestHistoricalBlock = BigInt(summary.oldestHistoricalBlock);
+export function sanitizeSummary(summary: WorldStateStatusSummary) {
+  summary.finalizedBlockNumber = BlockNumber.fromBigInt(BigInt(summary.finalizedBlockNumber));
+  summary.unfinalizedBlockNumber = BlockNumber.fromBigInt(BigInt(summary.unfinalizedBlockNumber));
+  summary.oldestHistoricalBlock = BlockNumber.fromBigInt(BigInt(summary.oldestHistoricalBlock));
   return summary;
 }
 
-export function sanitiseDBStats(stats: DBStats) {
+export function sanitizeDBStats(stats: DBStats) {
   stats.numDataItems = BigInt(stats.numDataItems);
   stats.totalUsedSize = BigInt(stats.totalUsedSize);
   return stats;
 }
 
-export function sanitiseMeta(meta: TreeMeta) {
+export function sanitizeMeta(meta: TreeMeta) {
   meta.committedSize = BigInt(meta.committedSize);
-  meta.finalisedBlockHeight = BigInt(meta.finalisedBlockHeight);
+  meta.finalizedBlockHeight = BlockNumber.fromBigInt(BigInt(meta.finalizedBlockHeight));
   meta.initialSize = BigInt(meta.initialSize);
-  meta.oldestHistoricBlock = BigInt(meta.oldestHistoricBlock);
+  meta.oldestHistoricBlock = BlockNumber.fromBigInt(BigInt(meta.oldestHistoricBlock));
   meta.size = BigInt(meta.size);
-  meta.unfinalisedBlockHeight = BigInt(meta.unfinalisedBlockHeight);
+  meta.unfinalizedBlockHeight = BlockNumber.fromBigInt(BigInt(meta.unfinalizedBlockHeight));
   return meta;
 }
 
-export function sanitiseTreeDBStats(stats: TreeDBStats) {
-  stats.blocksDBStats = sanitiseDBStats(stats.blocksDBStats);
-  stats.leafIndicesDBStats = sanitiseDBStats(stats.leafIndicesDBStats);
-  stats.leafPreimagesDBStats = sanitiseDBStats(stats.leafPreimagesDBStats);
-  stats.blockIndicesDBStats = sanitiseDBStats(stats.blockIndicesDBStats);
-  stats.nodesDBStats = sanitiseDBStats(stats.nodesDBStats);
+export function sanitizeTreeDBStats(stats: TreeDBStats) {
+  stats.blocksDBStats = sanitizeDBStats(stats.blocksDBStats);
+  stats.leafIndicesDBStats = sanitizeDBStats(stats.leafIndicesDBStats);
+  stats.leafPreimagesDBStats = sanitizeDBStats(stats.leafPreimagesDBStats);
+  stats.blockIndicesDBStats = sanitizeDBStats(stats.blockIndicesDBStats);
+  stats.nodesDBStats = sanitizeDBStats(stats.nodesDBStats);
   stats.mapSize = BigInt(stats.mapSize);
+  stats.physicalFileSize = BigInt(stats.physicalFileSize);
   return stats;
 }
 
-export function sanitiseWorldStateDBStats(stats: WorldStateDBStats) {
-  stats.archiveTreeStats = sanitiseTreeDBStats(stats.archiveTreeStats);
-  stats.messageTreeStats = sanitiseTreeDBStats(stats.messageTreeStats);
-  stats.noteHashTreeStats = sanitiseTreeDBStats(stats.noteHashTreeStats);
-  stats.nullifierTreeStats = sanitiseTreeDBStats(stats.nullifierTreeStats);
-  stats.publicDataTreeStats = sanitiseTreeDBStats(stats.publicDataTreeStats);
+export function sanitizeWorldStateDBStats(stats: WorldStateDBStats) {
+  stats.archiveTreeStats = sanitizeTreeDBStats(stats.archiveTreeStats);
+  stats.messageTreeStats = sanitizeTreeDBStats(stats.messageTreeStats);
+  stats.noteHashTreeStats = sanitizeTreeDBStats(stats.noteHashTreeStats);
+  stats.nullifierTreeStats = sanitizeTreeDBStats(stats.nullifierTreeStats);
+  stats.publicDataTreeStats = sanitizeTreeDBStats(stats.publicDataTreeStats);
   return stats;
 }
 
-export function sanitiseWorldStateTreeMeta(meta: WorldStateMeta) {
-  meta.archiveTreeMeta = sanitiseMeta(meta.archiveTreeMeta);
-  meta.messageTreeMeta = sanitiseMeta(meta.messageTreeMeta);
-  meta.noteHashTreeMeta = sanitiseMeta(meta.noteHashTreeMeta);
-  meta.nullifierTreeMeta = sanitiseMeta(meta.nullifierTreeMeta);
-  meta.publicDataTreeMeta = sanitiseMeta(meta.publicDataTreeMeta);
+export function sanitizeWorldStateTreeMeta(meta: WorldStateMeta) {
+  meta.archiveTreeMeta = sanitizeMeta(meta.archiveTreeMeta);
+  meta.messageTreeMeta = sanitizeMeta(meta.messageTreeMeta);
+  meta.noteHashTreeMeta = sanitizeMeta(meta.noteHashTreeMeta);
+  meta.nullifierTreeMeta = sanitizeMeta(meta.nullifierTreeMeta);
+  meta.publicDataTreeMeta = sanitizeMeta(meta.publicDataTreeMeta);
   return meta;
 }
 
-export function sanitiseFullStatus(status: WorldStateStatusFull) {
-  status.dbStats = sanitiseWorldStateDBStats(status.dbStats);
-  status.summary = sanitiseSummary(status.summary);
-  status.meta = sanitiseWorldStateTreeMeta(status.meta);
+export function sanitizeFullStatus(status: WorldStateStatusFull) {
+  status.dbStats = sanitizeWorldStateDBStats(status.dbStats);
+  status.summary = sanitizeSummary(status.summary);
+  status.meta = sanitizeWorldStateTreeMeta(status.meta);
   return status;
 }
 
@@ -272,6 +284,16 @@ interface WithForkId {
   forkId: number;
 }
 
+interface CreateCheckpointResponse {
+  depth: number;
+}
+
+/** Request to commit/revert all checkpoints down to a target depth. The resulting depth after the operation equals the given depth. */
+interface CheckpointDepthRequest extends WithForkId {
+  /** The target depth after the operation. All checkpoints above this depth are committed/reverted. */
+  depth: number;
+}
+
 interface WithWorldStateRevision {
   revision: WorldStateRevision;
 }
@@ -286,13 +308,13 @@ interface WithLeafIndex {
 
 export type SerializedLeafValue =
   | Buffer // Fr
-  | { value: Buffer } // NullifierLeaf
+  | { nullifier: Buffer } // NullifierLeaf
   | { value: Buffer; slot: Buffer }; // PublicDataTreeLeaf
 
 export type SerializedIndexedLeaf = {
-  value: Exclude<SerializedLeafValue, Buffer>;
+  leaf: Exclude<SerializedLeafValue, Buffer>;
   nextIndex: bigint | number;
-  nextValue: Buffer; // Fr
+  nextKey: Buffer; // Fr
 };
 
 interface WithLeafValues {
@@ -300,7 +322,7 @@ interface WithLeafValues {
 }
 
 interface BlockShiftRequest extends WithCanonicalForkId {
-  toBlockNumber: bigint;
+  toBlockNumber: BlockNumber;
 }
 
 interface WithLeaves {
@@ -344,6 +366,16 @@ interface FindLeafIndicesResponse {
   indices: bigint[];
 }
 
+interface FindSiblingPathsRequest extends WithTreeId, WithLeafValues, WithWorldStateRevision {}
+
+interface SiblingPathAndIndex {
+  index: bigint;
+  path: Buffer[];
+}
+interface FindSiblingPathsResponse {
+  paths: (SiblingPathAndIndex | undefined)[];
+}
+
 interface FindLowLeafRequest extends WithTreeId, WithWorldStateRevision {
   key: Fr;
 }
@@ -389,9 +421,9 @@ interface UpdateArchiveRequest extends WithForkId {
 }
 
 interface SyncBlockRequest extends WithCanonicalForkId {
-  blockNumber: number;
+  blockNumber: BlockNumber;
   blockStateRef: BlockStateReference;
-  blockHeaderHash: Fr;
+  blockHeaderHash: BlockHash;
   paddedNoteHashes: readonly SerializedLeafValue[];
   paddedL1ToL2Messages: readonly SerializedLeafValue[];
   paddedNullifiers: readonly SerializedLeafValue[];
@@ -400,7 +432,7 @@ interface SyncBlockRequest extends WithCanonicalForkId {
 
 interface CreateForkRequest extends WithCanonicalForkId {
   latest: boolean;
-  blockNumber: number;
+  blockNumber: BlockNumber;
 }
 
 interface CreateForkResponse {
@@ -409,6 +441,11 @@ interface CreateForkResponse {
 
 interface DeleteForkRequest extends WithForkId {}
 
+interface CopyStoresRequest extends WithCanonicalForkId {
+  dstPath: string;
+  compact: boolean;
+}
+
 export type WorldStateRequestCategories = WithForkId | WithWorldStateRevision | WithCanonicalForkId;
 
 export function isWithForkId(body: WorldStateRequestCategories): body is WithForkId {
@@ -435,6 +472,7 @@ export type WorldStateRequest = {
 
   [WorldStateMessageType.FIND_LEAF_INDICES]: FindLeafIndicesRequest;
   [WorldStateMessageType.FIND_LOW_LEAF]: FindLowLeafRequest;
+  [WorldStateMessageType.FIND_SIBLING_PATHS]: FindSiblingPathsRequest;
 
   [WorldStateMessageType.APPEND_LEAVES]: AppendLeavesRequest;
   [WorldStateMessageType.BATCH_INSERT]: BatchInsertRequest;
@@ -452,13 +490,17 @@ export type WorldStateRequest = {
 
   [WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS]: BlockShiftRequest;
   [WorldStateMessageType.UNWIND_BLOCKS]: BlockShiftRequest;
-  [WorldStateMessageType.FINALISE_BLOCKS]: BlockShiftRequest;
+  [WorldStateMessageType.FINALIZE_BLOCKS]: BlockShiftRequest;
 
   [WorldStateMessageType.GET_STATUS]: WithCanonicalForkId;
 
   [WorldStateMessageType.CREATE_CHECKPOINT]: WithForkId;
   [WorldStateMessageType.COMMIT_CHECKPOINT]: WithForkId;
   [WorldStateMessageType.REVERT_CHECKPOINT]: WithForkId;
+  [WorldStateMessageType.COMMIT_ALL_CHECKPOINTS]: CheckpointDepthRequest;
+  [WorldStateMessageType.REVERT_ALL_CHECKPOINTS]: CheckpointDepthRequest;
+
+  [WorldStateMessageType.COPY_STORES]: CopyStoresRequest;
 
   [WorldStateMessageType.CLOSE]: WithCanonicalForkId;
 };
@@ -475,6 +517,7 @@ export type WorldStateResponse = {
 
   [WorldStateMessageType.FIND_LEAF_INDICES]: FindLeafIndicesResponse;
   [WorldStateMessageType.FIND_LOW_LEAF]: FindLowLeafResponse;
+  [WorldStateMessageType.FIND_SIBLING_PATHS]: FindSiblingPathsResponse;
 
   [WorldStateMessageType.APPEND_LEAVES]: void;
   [WorldStateMessageType.BATCH_INSERT]: BatchInsertResponse;
@@ -492,33 +535,20 @@ export type WorldStateResponse = {
 
   [WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS]: WorldStateStatusFull;
   [WorldStateMessageType.UNWIND_BLOCKS]: WorldStateStatusFull;
-  [WorldStateMessageType.FINALISE_BLOCKS]: WorldStateStatusSummary;
+  [WorldStateMessageType.FINALIZE_BLOCKS]: WorldStateStatusSummary;
 
   [WorldStateMessageType.GET_STATUS]: WorldStateStatusSummary;
 
-  [WorldStateMessageType.CREATE_CHECKPOINT]: void;
+  [WorldStateMessageType.CREATE_CHECKPOINT]: CreateCheckpointResponse;
   [WorldStateMessageType.COMMIT_CHECKPOINT]: void;
   [WorldStateMessageType.REVERT_CHECKPOINT]: void;
+  [WorldStateMessageType.COMMIT_ALL_CHECKPOINTS]: void;
+  [WorldStateMessageType.REVERT_ALL_CHECKPOINTS]: void;
 
-  [WorldStateMessageType.CLOSE]: void;
-};
+  [WorldStateMessageType.COPY_STORES]: void;
 
-export type WorldStateRevision = {
-  forkId: number;
-  blockNumber: number;
-  includeUncommitted: boolean;
+  [WorldStateMessageType.CLOSE]: void;
 };
-export function worldStateRevision(
-  includeUncommitted: boolean,
-  forkId: number | undefined,
-  blockNumber: number | undefined,
-): WorldStateRevision {
-  return {
-    forkId: forkId ?? 0,
-    blockNumber: blockNumber ?? 0,
-    includeUncommitted,
-  };
-}
 
 type TreeStateReference = readonly [Buffer, number | bigint];
 type BlockStateReference = Map<Exclude<MerkleTreeId, MerkleTreeId.ARCHIVE>, TreeStateReference>;