@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.21caa21

package/src/native/message.ts

@@ -3,6 +3,7 @@ import type { Tuple } from '@aztec/foundation/serialize';
 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 +17,7 @@ export enum WorldStateMessageType {
 
   FIND_LEAF_INDICES,
   FIND_LOW_LEAF,
+  FIND_SIBLING_PATHS,
 
   APPEND_LEAVES,
   BATCH_INSERT,
@@ -31,7 +33,7 @@ export enum WorldStateMessageType {
   CREATE_FORK,
   DELETE_FORK,
 
-  FINALISE_BLOCKS,
+  FINALIZE_BLOCKS,
   UNWIND_BLOCKS,
   REMOVE_HISTORICAL_BLOCKS,
 
@@ -40,6 +42,10 @@ export enum WorldStateMessageType {
   CREATE_CHECKPOINT,
   COMMIT_CHECKPOINT,
   REVERT_CHECKPOINT,
+  COMMIT_ALL_CHECKPOINTS,
+  REVERT_ALL_CHECKPOINTS,
+
+  COPY_STORES,
 
   CLOSE = 999,
 }
@@ -50,9 +56,9 @@ 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: bigint;
+  /** Last block number that is finalized and cannot be unwound. */
+  finalizedBlockNumber: bigint;
   /** Oldest block still available for historical queries and forks. */
   oldestHistoricalBlock: bigint;
   /** Whether the trees are in sync with each other */
@@ -76,10 +82,10 @@ export interface TreeMeta {
   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;
+  /** The current unfinalized block number of the tree */
+  unfinalizedBlockHeight: bigint;
+  /** The current finalized block number of the tree */
+  finalizedBlockHeight: bigint;
 }
 
 export interface DBStats {
@@ -94,6 +100,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 +157,7 @@ export function buildEmptyDBStats() {
 export function buildEmptyTreeDBStats() {
   return {
     mapSize: 0n,
+    physicalFileSize: 0n,
     blocksDBStats: buildEmptyDBStats(),
     nodesDBStats: buildEmptyDBStats(),
     leafIndicesDBStats: buildEmptyDBStats(),
@@ -164,8 +173,8 @@ export function buildEmptyTreeMeta() {
     depth: 0,
     size: 0n,
     committedSize: 0n,
-    unfinalisedBlockHeight: 0n,
-    finalisedBlockHeight: 0n,
+    unfinalizedBlockHeight: 0n,
+    finalizedBlockHeight: 0n,
     oldestHistoricBlock: 0n,
     root: Fr.ZERO,
     initialRoot: Fr.ZERO,
@@ -195,8 +204,8 @@ export function buildEmptyWorldStateDBStats() {
 
 export function buildEmptyWorldStateSummary() {
   return {
-    unfinalisedBlockNumber: 0n,
-    finalisedBlockNumber: 0n,
+    unfinalizedBlockNumber: 0n,
+    finalizedBlockNumber: 0n,
     oldestHistoricalBlock: 0n,
     treesAreSynched: true,
   } as WorldStateStatusSummary;
@@ -210,61 +219,62 @@ export function buildEmptyWorldStateStatusFull() {
   } as WorldStateStatusFull;
 }
 
-export function sanitiseSummary(summary: WorldStateStatusSummary) {
-  summary.finalisedBlockNumber = BigInt(summary.finalisedBlockNumber);
-  summary.unfinalisedBlockNumber = BigInt(summary.unfinalisedBlockNumber);
+export function sanitizeSummary(summary: WorldStateStatusSummary) {
+  summary.finalizedBlockNumber = BigInt(summary.finalizedBlockNumber);
+  summary.unfinalizedBlockNumber = BigInt(summary.unfinalizedBlockNumber);
   summary.oldestHistoricalBlock = 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 = BigInt(meta.finalizedBlockHeight);
   meta.initialSize = BigInt(meta.initialSize);
   meta.oldestHistoricBlock = BigInt(meta.oldestHistoricBlock);
   meta.size = BigInt(meta.size);
-  meta.unfinalisedBlockHeight = BigInt(meta.unfinalisedBlockHeight);
+  meta.unfinalizedBlockHeight = 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;
 }
 
@@ -286,13 +296,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 {
@@ -344,6 +354,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;
 }
@@ -409,6 +429,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 +460,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 +478,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]: WithForkId;
+  [WorldStateMessageType.REVERT_ALL_CHECKPOINTS]: WithForkId;
+
+  [WorldStateMessageType.COPY_STORES]: CopyStoresRequest;
 
   [WorldStateMessageType.CLOSE]: WithCanonicalForkId;
 };
@@ -475,6 +505,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 +523,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.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>;

package/src/native/native_world_state.ts

@@ -1,17 +1,20 @@
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { fromEntries, padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import { tryRmDir } from '@aztec/foundation/fs';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { L2Block, L2BlockNew } from '@aztec/stdlib/block';
 import { DatabaseVersionManager } from '@aztec/stdlib/database-version';
 import type {
   IndexedTreeId,
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
 } from '@aztec/stdlib/interfaces/server';
+import type { SnapshotDataKeys } from '@aztec/stdlib/snapshots';
 import { MerkleTreeId, NullifierLeaf, type NullifierLeafPreimage, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { BlockHeader, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
+import { WorldStateRevision } from '@aztec/stdlib/world-state';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert/strict';
@@ -20,6 +23,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import type { WorldStateTreeMapSizes } from '../synchronizer/factory.js';
 import type { MerkleTreeAdminDatabase as MerkleTreeDatabase } from '../world-state-db/merkle_tree_db.js';
 import { MerkleTreesFacade, MerkleTreesForkFacade, serializeLeaf } from './merkle_trees_facade.js';
 import {
@@ -27,16 +31,17 @@ import {
   type WorldStateStatusFull,
   type WorldStateStatusSummary,
   blockStateReference,
-  sanitiseFullStatus,
-  sanitiseSummary,
+  sanitizeFullStatus,
+  sanitizeSummary,
   treeStateReferenceToSnapshot,
-  worldStateRevision,
 } from './message.js';
 import { NativeWorldState } from './native_world_state_instance.js';
 
 // The current version of the world state database schema
 // Increment this when making incompatible changes to the database schema
-export const WORLD_STATE_DB_VERSION = 1; // The initial version
+export const WORLD_STATE_DB_VERSION = 2; // The initial version
+
+export const WORLD_STATE_DIR = 'world_state';
 
 export class NativeWorldStateService implements MerkleTreeDatabase {
   protected initialHeader: BlockHeader | undefined;
@@ -44,38 +49,38 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   private cachedStatusSummary: WorldStateStatusSummary | undefined;
 
   protected constructor(
-    protected readonly instance: NativeWorldState,
+    protected instance: NativeWorldState,
     protected readonly worldStateInstrumentation: WorldStateInstrumentation,
-    protected readonly log = createLogger('world-state:database'),
+    protected readonly log: Logger = createLogger('world-state:database'),
     private readonly cleanup = () => Promise.resolve(),
   ) {}
 
   static async new(
     rollupAddress: EthAddress,
     dataDir: string,
-    dbMapSizeKb: number,
+    wsTreeMapSizes: WorldStateTreeMapSizes,
     prefilledPublicData: PublicDataTreeLeaf[] = [],
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
     log = createLogger('world-state:database'),
     cleanup = () => Promise.resolve(),
   ): Promise<NativeWorldStateService> {
-    const worldStateDirectory = join(dataDir, 'world_state');
+    const worldStateDirectory = join(dataDir, WORLD_STATE_DIR);
     // Create a version manager to handle versioning
-    const versionManager = new DatabaseVersionManager(
-      WORLD_STATE_DB_VERSION,
+    const versionManager = new DatabaseVersionManager({
+      schemaVersion: WORLD_STATE_DB_VERSION,
       rollupAddress,
-      worldStateDirectory,
-      (dir: string) => {
-        return Promise.resolve(new NativeWorldState(dir, dbMapSizeKb, prefilledPublicData, instrumentation));
+      dataDirectory: worldStateDirectory,
+      onOpen: (dir: string) => {
+        return Promise.resolve(new NativeWorldState(dir, wsTreeMapSizes, prefilledPublicData, instrumentation));
       },
-    );
+    });
 
     const [instance] = await versionManager.open();
     const worldState = new this(instance, instrumentation, log, cleanup);
     try {
       await worldState.init();
     } catch (e) {
-      log.error(`Error initialising world state: ${e}`);
+      log.error(`Error initializing world state: ${e}`);
       throw e;
     }
 
@@ -91,7 +96,14 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     const log = createLogger('world-state:database');
     const dataDir = await mkdtemp(join(tmpdir(), 'aztec-world-state-'));
     const dbMapSizeKb = 10 * 1024 * 1024;
-    log.debug(`Created temporary world state database at: ${dataDir} with size: ${dbMapSizeKb}`);
+    const worldStateTreeMapSizes: WorldStateTreeMapSizes = {
+      archiveTreeMapSizeKb: dbMapSizeKb,
+      nullifierTreeMapSizeKb: dbMapSizeKb,
+      noteHashTreeMapSizeKb: dbMapSizeKb,
+      messageTreeMapSizeKb: dbMapSizeKb,
+      publicDataTreeMapSizeKb: dbMapSizeKb,
+    };
+    log.debug(`Created temporary world state database at: ${dataDir} with tree map size: ${dbMapSizeKb}`);
 
     // pass a cleanup callback because process.on('beforeExit', cleanup) does not work under Jest
     const cleanup = async () => {
@@ -103,7 +115,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       }
     };
 
-    return this.new(rollupAddress, dataDir, dbMapSizeKb, prefilledPublicData, instrumentation, log, cleanup);
+    return this.new(rollupAddress, dataDir, worldStateTreeMapSizes, prefilledPublicData, instrumentation, log, cleanup);
   }
 
   protected async init() {
@@ -127,12 +139,23 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     assert.strictEqual(initialHeaderIndex, 0n, 'Invalid initial archive state');
   }
 
+  public async clear() {
+    await this.instance.close();
+    this.cachedStatusSummary = undefined;
+    await tryRmDir(this.instance.getDataDir(), this.log);
+    this.instance = this.instance.clone();
+  }
+
   public getCommitted(): MerkleTreeReadOperations {
-    return new MerkleTreesFacade(this.instance, this.initialHeader!, worldStateRevision(false, 0, 0));
+    return new MerkleTreesFacade(this.instance, this.initialHeader!, WorldStateRevision.empty());
   }
 
   public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
-    return new MerkleTreesFacade(this.instance, this.initialHeader!, worldStateRevision(false, 0, blockNumber));
+    return new MerkleTreesFacade(
+      this.instance,
+      this.initialHeader!,
+      new WorldStateRevision(/*forkId=*/ 0, /* blockNumber=*/ blockNumber, /* includeUncommitted=*/ false),
+    );
   }
 
   public async fork(blockNumber?: number): Promise<MerkleTreeWriteOperations> {
@@ -141,19 +164,31 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       blockNumber: blockNumber ?? 0,
       canonical: true,
     });
-    return new MerkleTreesForkFacade(this.instance, this.initialHeader!, worldStateRevision(true, resp.forkId, 0));
+    return new MerkleTreesForkFacade(
+      this.instance,
+      this.initialHeader!,
+      new WorldStateRevision(/*forkId=*/ resp.forkId, /* blockNumber=*/ 0, /* includeUncommitted=*/ true),
+    );
   }
 
   public getInitialHeader(): BlockHeader {
     return this.initialHeader!;
   }
 
-  public async handleL2BlockAndMessages(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
+  public async handleL2BlockAndMessages(
+    l2Block: L2Block | L2BlockNew,
+    l1ToL2Messages: Fr[],
+    // TODO(#17027)
+    // Temporary hack to only insert l1 to l2 messages for the first block in a checkpoint.
+    isFirstBlock = true,
+  ): Promise<WorldStateStatusFull> {
     // We have to pad both the values within tx effects because that's how the trees are built by circuits.
     const paddedNoteHashes = l2Block.body.txEffects.flatMap(txEffect =>
       padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
     );
-    const paddedL1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    const paddedL1ToL2Messages = isFirstBlock
+      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
+      : [];
 
     const paddedNullifiers = l2Block.body.txEffects
       .flatMap(txEffect => padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX))
@@ -173,7 +208,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
         WorldStateMessageType.SYNC_BLOCK,
         {
           blockNumber: l2Block.number,
-          blockHeaderHash: await l2Block.header.hash(),
+          blockHeaderHash: await l2Block.hash(),
           paddedL1ToL2Messages: paddedL1ToL2Messages.map(serializeLeaf),
           paddedNoteHashes: paddedNoteHashes.map(serializeLeaf),
           paddedNullifiers: paddedNullifiers.map(serializeLeaf),
@@ -181,7 +216,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
           blockStateRef: blockStateReference(l2Block.header.state),
           canonical: true,
         },
-        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.sanitizeAndCacheSummaryFromFull.bind(this),
         this.deleteCachedSummary.bind(this),
       );
     } catch (err) {
@@ -200,16 +235,16 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     return BlockHeader.empty({ state });
   }
 
-  private sanitiseAndCacheSummaryFromFull(response: WorldStateStatusFull) {
-    const sanitised = sanitiseFullStatus(response);
-    this.cachedStatusSummary = { ...sanitised.summary };
-    return sanitised;
+  private sanitizeAndCacheSummaryFromFull(response: WorldStateStatusFull) {
+    const sanitized = sanitizeFullStatus(response);
+    this.cachedStatusSummary = { ...sanitized.summary };
+    return sanitized;
   }
 
-  private sanitiseAndCacheSummary(response: WorldStateStatusSummary) {
-    const sanitised = sanitiseSummary(response);
-    this.cachedStatusSummary = { ...sanitised };
-    return sanitised;
+  private sanitizeAndCacheSummary(response: WorldStateStatusSummary) {
+    const sanitized = sanitizeSummary(response);
+    this.cachedStatusSummary = { ...sanitized };
+    return sanitized;
   }
 
   private deleteCachedSummary(_: string) {
@@ -217,19 +252,19 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   }
 
   /**
-   * Advances the finalised block number to be the number provided
-   * @param toBlockNumber The block number that is now the tip of the finalised chain
+   * Advances the finalized block number to be the number provided
+   * @param toBlockNumber The block number that is now the tip of the finalized chain
    * @returns The new WorldStateStatus
    */
-  public async setFinalised(toBlockNumber: bigint) {
+  public async setFinalized(toBlockNumber: bigint) {
     try {
       await this.instance.call(
-        WorldStateMessageType.FINALISE_BLOCKS,
+        WorldStateMessageType.FINALIZE_BLOCKS,
         {
           toBlockNumber,
           canonical: true,
         },
-        this.sanitiseAndCacheSummary.bind(this),
+        this.sanitizeAndCacheSummary.bind(this),
         this.deleteCachedSummary.bind(this),
       );
     } catch (err) {
@@ -252,7 +287,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
           toBlockNumber,
           canonical: true,
         },
-        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.sanitizeAndCacheSummaryFromFull.bind(this),
         this.deleteCachedSummary.bind(this),
       );
     } catch (err) {
@@ -274,7 +309,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
           toBlockNumber,
           canonical: true,
         },
-        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.sanitizeAndCacheSummaryFromFull.bind(this),
         this.deleteCachedSummary.bind(this),
       );
     } catch (err) {
@@ -290,7 +325,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     return await this.instance.call(
       WorldStateMessageType.GET_STATUS,
       { canonical: true },
-      this.sanitiseAndCacheSummary.bind(this),
+      this.sanitizeAndCacheSummary.bind(this),
     );
   }
 
@@ -314,4 +349,25 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       ),
     );
   }
+
+  public async backupTo(
+    dstPath: string,
+    compact: boolean = true,
+  ): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>> {
+    await this.instance.call(WorldStateMessageType.COPY_STORES, {
+      dstPath,
+      compact,
+      canonical: true,
+    });
+    return fromEntries(NATIVE_WORLD_STATE_DBS.map(([name, dir]) => [name, join(dstPath, dir, 'data.mdb')] as const));
+  }
 }
+
+// The following paths are defined in cpp-land
+export const NATIVE_WORLD_STATE_DBS = [
+  ['l1-to-l2-message-tree', 'L1ToL2MessageTree'],
+  ['archive-tree', 'ArchiveTree'],
+  ['public-data-tree', 'PublicDataTree'],
+  ['note-hash-tree', 'NoteHashTree'],
+  ['nullifier-tree', 'NullifierTree'],
+] as const;