@aztec/world-state 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/dest/native/ipc_world_state_instance.js

@@ -0,0 +1,628 @@
+import { AsyncApi } from '@aztec/bb.js/aztec-wsdb';
+import { ARCHIVE_HEIGHT, DomainSeparator, L1_TO_L2_MSG_TREE_HEIGHT, MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NOTE_HASH_TREE_HEIGHT, NULLIFIER_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import assert from 'assert';
+import { Decoder, Encoder } from 'msgpackr';
+import { WorldStateMessageType, isWithCanonical, isWithForkId, isWithRevision } from './message.js';
+import { WorldStateOpsQueue } from './world_state_ops_queue.js';
+// ————— Msgpack helpers —————
+const msgpackEncoder = new Encoder({
+    useRecords: false
+});
+const msgpackDecoder = new Decoder({
+    useRecords: false
+});
+/** Msgpack-encode a SerializedLeafValue into bytes for IPC transport. */ function serializeLeafToBytes(leaf) {
+    return Buffer.from(msgpackEncoder.pack(leaf));
+}
+// ————— Request conversion helpers —————
+function toWsdbRevision(rev) {
+    return {
+        forkid: rev.forkId,
+        blocknumber: Number(rev.blockNumber),
+        includeuncommitted: rev.includeUncommitted
+    };
+}
+function blockStateRefToMap(ref) {
+    const result = new Map();
+    for (const [treeId, [root, size]] of ref.entries()){
+        result.set(treeId, [
+            new Uint8Array(root),
+            Number(size)
+        ]);
+    }
+    return result;
+}
+// ————— Response conversion helpers —————
+/** Convert Uint8Array fields to Buffer recursively (for opaque blob responses). */ function convertUint8ArraysToBuffers(obj) {
+    if (obj instanceof Uint8Array) {
+        return Buffer.from(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(convertUint8ArraysToBuffers);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)){
+            result[key] = convertUint8ArraysToBuffers(value);
+        }
+        return result;
+    }
+    return obj;
+}
+/** Decode a msgpack-encoded leaf value blob and convert Uint8Arrays to Buffers. */ function decodeLeafValue(encoded) {
+    const decoded = msgpackDecoder.unpack(Buffer.from(encoded));
+    return convertUint8ArraysToBuffers(decoded);
+}
+/** Decode a msgpack-encoded indexed leaf preimage blob. */ function decodeLeafPreimage(encoded) {
+    const decoded = msgpackDecoder.unpack(Buffer.from(encoded));
+    return convertUint8ArraysToBuffers(decoded);
+}
+/** Convert Wsdb state reference (Record<number, [Uint8Array, number]>) to NAPI format. */ function convertStateRef(state) {
+    const result = {};
+    for (const [key, [root, size]] of Object.entries(state)){
+        result[Number(key)] = [
+            Buffer.from(root),
+            BigInt(size)
+        ];
+    }
+    return result;
+}
+/** Convert Wsdb WorldStateStatusSummary (lowercase) to NAPI format (camelCase). */ function convertStatusSummary(s) {
+    return {
+        unfinalizedBlockNumber: s.unfinalizedblocknumber,
+        finalizedBlockNumber: s.finalizedblocknumber,
+        oldestHistoricalBlock: s.oldesthistoricalblock,
+        treesAreSynched: s.treesaresynched
+    };
+}
+function convertDBStats(s) {
+    return {
+        name: s.name,
+        numDataItems: s.numdataitems,
+        totalUsedSize: s.totalusedsize
+    };
+}
+function convertTreeDBStats(s) {
+    return {
+        mapSize: s.mapsize,
+        physicalFileSize: s.physicalfilesize,
+        blocksDBStats: convertDBStats(s.blocksdbstats),
+        nodesDBStats: convertDBStats(s.nodesdbstats),
+        leafPreimagesDBStats: convertDBStats(s.leafpreimagesdbstats),
+        leafIndicesDBStats: convertDBStats(s.leafindicesdbstats),
+        blockIndicesDBStats: convertDBStats(s.blockindicesdbstats)
+    };
+}
+function convertWorldStateDBStats(s) {
+    return {
+        noteHashTreeStats: convertTreeDBStats(s.notehashtreestats),
+        messageTreeStats: convertTreeDBStats(s.messagetreestats),
+        archiveTreeStats: convertTreeDBStats(s.archivetreestats),
+        publicDataTreeStats: convertTreeDBStats(s.publicdatatreestats),
+        nullifierTreeStats: convertTreeDBStats(s.nullifiertreestats)
+    };
+}
+function convertTreeMeta(m) {
+    return {
+        name: m.name,
+        depth: m.depth,
+        size: m.size,
+        committedSize: m.committedsize,
+        root: m.root,
+        initialSize: m.initialsize,
+        initialRoot: m.initialroot,
+        oldestHistoricBlock: m.oldesthistoricblock,
+        unfinalizedBlockHeight: m.unfinalizedblockheight,
+        finalizedBlockHeight: m.finalizedblockheight
+    };
+}
+function convertWorldStateMeta(m) {
+    return {
+        noteHashTreeMeta: convertTreeMeta(m.notehashtreemeta),
+        messageTreeMeta: convertTreeMeta(m.messagetreemeta),
+        archiveTreeMeta: convertTreeMeta(m.archivetreemeta),
+        publicDataTreeMeta: convertTreeMeta(m.publicdatatreemeta),
+        nullifierTreeMeta: convertTreeMeta(m.nullifiertreemeta)
+    };
+}
+function convertStatusFull(s) {
+    return {
+        summary: convertStatusSummary(s.summary),
+        dbStats: convertWorldStateDBStats(s.dbstats),
+        meta: convertWorldStateMeta(s.meta)
+    };
+}
+/** Convert Wsdb SiblingPathAndIndex to NAPI format. */ function convertSiblingPathAndIndex(s) {
+    if (!s) {
+        return undefined;
+    }
+    return {
+        index: BigInt(s.index),
+        path: s.path.map((p)=>Buffer.from(p))
+    };
+}
+/**
+ * IPC-backed world state instance.
+ * Uses WsdbBackend (spawns aztec-wsdb binary) and the generated AsyncApi
+ * to communicate via the NamedUnion IPC protocol.
+ */ export class IpcWorldState {
+    wsdbBackend;
+    instrumentation;
+    log;
+    open;
+    queues;
+    api;
+    /** Tracks checkpoint depth per fork (WSDB IPC doesn't return depth in response). */ checkpointDepths;
+    constructor(wsdbBackend, instrumentation, bindings, log = createLogger('world-state:ipc-database', bindings)){
+        this.wsdbBackend = wsdbBackend;
+        this.instrumentation = instrumentation;
+        this.log = log;
+        this.open = true;
+        this.queues = new Map();
+        this.checkpointDepths = new Map();
+        this.api = new AsyncApi(wsdbBackend);
+        this.queues.set(0, new WorldStateOpsQueue());
+        this.log.info('Created IPC-backed world state instance');
+    }
+    /** Returns the socket path of the underlying wsdb server. */ getSocketPath() {
+        return this.wsdbBackend.getSocketPath();
+    }
+    /**
+   * Required by `NativeWorldStateInstance` for compatibility with the in-process
+   * NAPI path. The IPC backend does not expose an in-process pointer; callers that
+   * need to reach the WSDB process must use {@link getSocketPath} instead.
+   */ getHandle() {
+        throw new Error('IpcWorldState has no in-process handle; use getSocketPath() instead');
+    }
+    async call(messageType, body, responseHandler = (response)=>response, errorHandler = (_)=>{}) {
+        let forkId = -1;
+        let committedOnly = false;
+        if (isWithCanonical(body)) {
+            forkId = 0;
+        } else if (isWithForkId(body)) {
+            forkId = body.forkId;
+        } else if (isWithRevision(body)) {
+            forkId = body.revision.forkId;
+            committedOnly = body.revision.includeUncommitted === false;
+        } else {
+            const _ = body;
+            throw new Error(`Unable to determine forkId for message=${WorldStateMessageType[messageType]}`);
+        }
+        let requestQueue = this.queues.get(forkId);
+        if (requestQueue === undefined) {
+            requestQueue = new WorldStateOpsQueue();
+            this.queues.set(forkId, requestQueue);
+        }
+        // The per-fork queue is cleaned up in `finally` even on error, so the JS-side queues map cannot outlive
+        // the native fork (e.g. when the native fork was already destroyed by an unwind/historical-prune and
+        // DELETE_FORK rejects with "Fork not found").
+        try {
+            const response = await requestQueue.execute(async ()=>{
+                assert.notEqual(messageType, WorldStateMessageType.CLOSE, 'Use close() to close the IPC instance');
+                assert.equal(this.open, true, 'IPC instance is closed');
+                let response;
+                try {
+                    response = await this._sendMessage(messageType, body);
+                } catch (error) {
+                    errorHandler(error.message);
+                    throw error;
+                }
+                return responseHandler(response);
+            }, messageType, committedOnly);
+            return response;
+        } finally{
+            if (messageType === WorldStateMessageType.DELETE_FORK) {
+                await requestQueue.stop();
+                this.queues.delete(forkId);
+            }
+        }
+    }
+    async close() {
+        if (!this.open) {
+            return;
+        }
+        this.open = false;
+        const queue = this.queues.get(0);
+        // Send shutdown command. Under normal operation, the WSDB process sends its
+        // response before exiting (via ShutdownRequested in ipc_server.hpp). The
+        // try/catch is defensive: if the process is killed externally (SIGKILL, OOM)
+        // before responding, the pending IPC callback would be rejected by the socket
+        // close handler. We proceed to destroy the backend regardless.
+        try {
+            await queue.execute(async ()=>{
+                await this.api.wsdbShutdown({});
+            }, WorldStateMessageType.CLOSE, false);
+        } catch (err) {
+            this.log.debug(`wsdbShutdown completed with error: ${err.message}`);
+        }
+        await queue.stop();
+        if (this.wsdbBackend.destroy) {
+            await this.wsdbBackend.destroy();
+        }
+    }
+    async _sendMessage(messageType, body) {
+        const start = performance.now();
+        try {
+            const response = await this.dispatch(messageType, body);
+            const durationMs = performance.now() - start;
+            this.log.trace(`Call ${WorldStateMessageType[messageType]} took (ms)`, {
+                duration: durationMs
+            });
+            this.instrumentation.recordRoundTrip(durationMs * 1000, messageType);
+            return response;
+        } catch (error) {
+            this.log.error(`Call ${WorldStateMessageType[messageType]} failed: ${error}`, error);
+            throw error;
+        }
+    }
+    async dispatch(messageType, body) {
+        switch(messageType){
+            // ——— Tree info & state reference ———
+            case WorldStateMessageType.GET_TREE_INFO:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetTreeInfo({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision)
+                    });
+                    return {
+                        treeId: resp.treeid,
+                        root: Buffer.from(resp.root),
+                        size: resp.size,
+                        depth: resp.depth
+                    };
+                }
+            case WorldStateMessageType.GET_STATE_REFERENCE:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetStateReference({
+                        revision: toWsdbRevision(b.revision)
+                    });
+                    return {
+                        state: convertStateRef(resp.state)
+                    };
+                }
+            case WorldStateMessageType.GET_INITIAL_STATE_REFERENCE:
+                {
+                    const resp = await this.api.wsdbGetInitialStateReference({});
+                    return {
+                        state: convertStateRef(resp.state)
+                    };
+                }
+            // ——— Leaf queries ———
+            case WorldStateMessageType.GET_LEAF_VALUE:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetLeafValue({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leafindex: Number(b.leafIndex)
+                    });
+                    if (!resp.value) {
+                        return undefined;
+                    }
+                    return decodeLeafValue(resp.value);
+                }
+            case WorldStateMessageType.GET_LEAF_PREIMAGE:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetLeafPreimage({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leafindex: Number(b.leafIndex)
+                    });
+                    if (!resp.preimage) {
+                        return undefined;
+                    }
+                    return decodeLeafPreimage(resp.preimage);
+                }
+            case WorldStateMessageType.GET_SIBLING_PATH:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetSiblingPath({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leafindex: Number(b.leafIndex)
+                    });
+                    return resp.path.map((p)=>Buffer.from(p));
+                }
+            case WorldStateMessageType.GET_BLOCK_NUMBERS_FOR_LEAF_INDICES:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbGetBlockNumbersForLeafIndices({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leafindices: b.leafIndices.map(Number)
+                    });
+                    return {
+                        blockNumbers: resp.blocknumbers.map((n)=>n != null ? BigInt(n) : undefined)
+                    };
+                }
+            // ——— Find operations ———
+            case WorldStateMessageType.FIND_LEAF_INDICES:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbFindLeafIndices({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leaves: b.leaves.map(serializeLeafToBytes),
+                        startindex: Number(b.startIndex)
+                    });
+                    return {
+                        indices: resp.indices.map((n)=>n != null ? BigInt(n) : undefined)
+                    };
+                }
+            case WorldStateMessageType.FIND_LOW_LEAF:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbFindLowLeaf({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        key: new Uint8Array(b.key.toBuffer())
+                    });
+                    return {
+                        alreadyPresent: resp.alreadypresent,
+                        index: BigInt(resp.index)
+                    };
+                }
+            case WorldStateMessageType.FIND_SIBLING_PATHS:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbFindSiblingPaths({
+                        treeid: b.treeId,
+                        revision: toWsdbRevision(b.revision),
+                        leaves: b.leaves.map(serializeLeafToBytes)
+                    });
+                    return {
+                        paths: resp.paths.map(convertSiblingPathAndIndex)
+                    };
+                }
+            // ——— Mutations ———
+            case WorldStateMessageType.APPEND_LEAVES:
+                {
+                    const b = body;
+                    await this.api.wsdbAppendLeaves({
+                        treeid: b.treeId,
+                        leaves: b.leaves.map(serializeLeafToBytes),
+                        forkid: b.forkId
+                    });
+                    return undefined;
+                }
+            case WorldStateMessageType.BATCH_INSERT:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbBatchInsert({
+                        treeid: b.treeId,
+                        leaves: b.leaves.map(serializeLeafToBytes),
+                        subtreedepth: b.subtreeDepth,
+                        forkid: b.forkId
+                    });
+                    const decoded = msgpackDecoder.unpack(Buffer.from(resp.result));
+                    return convertUint8ArraysToBuffers(decoded);
+                }
+            case WorldStateMessageType.SEQUENTIAL_INSERT:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbSequentialInsert({
+                        treeid: b.treeId,
+                        leaves: b.leaves.map(serializeLeafToBytes),
+                        forkid: b.forkId
+                    });
+                    const decoded = msgpackDecoder.unpack(Buffer.from(resp.result));
+                    return convertUint8ArraysToBuffers(decoded);
+                }
+            case WorldStateMessageType.UPDATE_ARCHIVE:
+                {
+                    const b = body;
+                    await this.api.wsdbUpdateArchive({
+                        blockstateref: blockStateRefToMap(b.blockStateRef),
+                        blockheaderhash: new Uint8Array(b.blockHeaderHash),
+                        forkid: b.forkId
+                    });
+                    return undefined;
+                }
+            // ——— Commit / Rollback ———
+            case WorldStateMessageType.COMMIT:
+                {
+                    await this.api.wsdbCommit({});
+                    return undefined;
+                }
+            case WorldStateMessageType.ROLLBACK:
+                {
+                    await this.api.wsdbRollback({});
+                    return undefined;
+                }
+            // ——— Block sync ———
+            case WorldStateMessageType.SYNC_BLOCK:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbSyncBlock({
+                        blocknumber: Number(b.blockNumber),
+                        blockstateref: blockStateRefToMap(b.blockStateRef),
+                        blockheaderhash: new Uint8Array(b.blockHeaderHash),
+                        paddednotehashes: b.paddedNoteHashes.map((l)=>new Uint8Array(l)),
+                        paddedl1tol2messages: b.paddedL1ToL2Messages.map((l)=>new Uint8Array(l)),
+                        paddednullifiers: b.paddedNullifiers.map((l)=>({
+                                nullifier: new Uint8Array(l.nullifier)
+                            })),
+                        publicdatawrites: b.publicDataWrites.map((l)=>({
+                                slot: new Uint8Array(l.slot),
+                                value: new Uint8Array(l.value)
+                            }))
+                    });
+                    return convertStatusFull(resp.status);
+                }
+            // ——— Fork management ———
+            case WorldStateMessageType.CREATE_FORK:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbCreateFork({
+                        latest: b.latest,
+                        blocknumber: Number(b.blockNumber)
+                    });
+                    return {
+                        forkId: resp.forkid
+                    };
+                }
+            case WorldStateMessageType.DELETE_FORK:
+                {
+                    const b = body;
+                    await this.api.wsdbDeleteFork({
+                        forkid: b.forkId
+                    });
+                    return undefined;
+                }
+            // ——— Block finalization ———
+            case WorldStateMessageType.FINALIZE_BLOCKS:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbFinalizeBlocks({
+                        toblocknumber: Number(b.toBlockNumber)
+                    });
+                    return convertStatusSummary(resp.status);
+                }
+            case WorldStateMessageType.UNWIND_BLOCKS:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbUnwindBlocks({
+                        toblocknumber: Number(b.toBlockNumber)
+                    });
+                    return convertStatusFull(resp.status);
+                }
+            case WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS:
+                {
+                    const b = body;
+                    const resp = await this.api.wsdbRemoveHistoricalBlocks({
+                        toblocknumber: Number(b.toBlockNumber)
+                    });
+                    return convertStatusFull(resp.status);
+                }
+            // ——— Status ———
+            case WorldStateMessageType.GET_STATUS:
+                {
+                    const resp = await this.api.wsdbGetStatus({});
+                    return convertStatusSummary(resp.status);
+                }
+            // ——— Checkpoints ———
+            case WorldStateMessageType.CREATE_CHECKPOINT:
+                {
+                    const b = body;
+                    await this.api.wsdbCreateCheckpoint({
+                        forkid: b.forkId
+                    });
+                    const depth = (this.checkpointDepths.get(b.forkId) ?? 0) + 1;
+                    this.checkpointDepths.set(b.forkId, depth);
+                    return {
+                        depth
+                    };
+                }
+            case WorldStateMessageType.COMMIT_CHECKPOINT:
+                {
+                    const b = body;
+                    await this.api.wsdbCommitCheckpoint({
+                        forkid: b.forkId
+                    });
+                    const depth = Math.max(0, (this.checkpointDepths.get(b.forkId) ?? 0) - 1);
+                    this.checkpointDepths.set(b.forkId, depth);
+                    return undefined;
+                }
+            case WorldStateMessageType.REVERT_CHECKPOINT:
+                {
+                    const b = body;
+                    await this.api.wsdbRevertCheckpoint({
+                        forkid: b.forkId
+                    });
+                    const depth = Math.max(0, (this.checkpointDepths.get(b.forkId) ?? 0) - 1);
+                    this.checkpointDepths.set(b.forkId, depth);
+                    return undefined;
+                }
+            case WorldStateMessageType.COMMIT_ALL_CHECKPOINTS:
+                {
+                    const b = body;
+                    const targetDepth = b.depth ?? 0;
+                    const currentDepth = this.checkpointDepths.get(b.forkId) ?? 0;
+                    if (targetDepth === 0) {
+                        // Commit everything — use the bulk operation
+                        await this.api.wsdbCommitAllCheckpoints({
+                            forkid: b.forkId
+                        });
+                    } else {
+                        // Commit one level at a time down to target depth
+                        for(let d = currentDepth; d > targetDepth; d--){
+                            await this.api.wsdbCommitCheckpoint({
+                                forkid: b.forkId
+                            });
+                        }
+                    }
+                    this.checkpointDepths.set(b.forkId, targetDepth);
+                    return undefined;
+                }
+            case WorldStateMessageType.REVERT_ALL_CHECKPOINTS:
+                {
+                    const b = body;
+                    const targetDepth = b.depth ?? 0;
+                    const currentDepth = this.checkpointDepths.get(b.forkId) ?? 0;
+                    if (targetDepth === 0) {
+                        // Revert everything — use the bulk operation
+                        await this.api.wsdbRevertAllCheckpoints({
+                            forkid: b.forkId
+                        });
+                    } else {
+                        // Revert one level at a time down to target depth
+                        for(let d = currentDepth; d > targetDepth; d--){
+                            await this.api.wsdbRevertCheckpoint({
+                                forkid: b.forkId
+                            });
+                        }
+                    }
+                    this.checkpointDepths.set(b.forkId, targetDepth);
+                    return undefined;
+                }
+            // ——— Misc ———
+            case WorldStateMessageType.COPY_STORES:
+                {
+                    const b = body;
+                    await this.api.wsdbCopyStores({
+                        dstpath: b.dstPath,
+                        compact: b.compact
+                    });
+                    return undefined;
+                }
+            case WorldStateMessageType.CLOSE:
+                {
+                    await this.api.wsdbShutdown({});
+                    return undefined;
+                }
+            default:
+                throw new Error(`Unknown message type: ${messageType}`);
+        }
+    }
+}
+/**
+ * Helper to create WsdbOptions from standard world state config.
+ * Returns the options needed to construct a WsdbBackend.
+ */ export function getWsdbOptions(dataDir, wsTreeMapSizes) {
+    return {
+        treeHeights: {
+            [MerkleTreeId.NULLIFIER_TREE]: NULLIFIER_TREE_HEIGHT,
+            [MerkleTreeId.NOTE_HASH_TREE]: NOTE_HASH_TREE_HEIGHT,
+            [MerkleTreeId.PUBLIC_DATA_TREE]: PUBLIC_DATA_TREE_HEIGHT,
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: L1_TO_L2_MSG_TREE_HEIGHT,
+            [MerkleTreeId.ARCHIVE]: ARCHIVE_HEIGHT
+        },
+        treePrefill: {
+            [MerkleTreeId.NULLIFIER_TREE]: 2 * MAX_NULLIFIERS_PER_TX,
+            [MerkleTreeId.PUBLIC_DATA_TREE]: 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        },
+        mapSizes: {
+            [MerkleTreeId.NULLIFIER_TREE]: wsTreeMapSizes.nullifierTreeMapSizeKb,
+            [MerkleTreeId.NOTE_HASH_TREE]: wsTreeMapSizes.noteHashTreeMapSizeKb,
+            [MerkleTreeId.PUBLIC_DATA_TREE]: wsTreeMapSizes.publicDataTreeMapSizeKb,
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: wsTreeMapSizes.messageTreeMapSizeKb,
+            [MerkleTreeId.ARCHIVE]: wsTreeMapSizes.archiveTreeMapSizeKb
+        },
+        initialHeaderGeneratorPoint: DomainSeparator.BLOCK_HEADER_HASH
+    };
+}

package/dest/native/merkle_trees_facade.d.ts

@@ -1,6 +1,7 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+import { BlockHash } from '@aztec/stdlib/block';
 import type { BatchInsertionResult, IndexedTreeId, MerkleTreeLeafType, MerkleTreeReadOperations, MerkleTreeWriteOperations, SequentialInsertionResult, TreeInfo } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { type BlockHeader, StateReference } from '@aztec/stdlib/tx';
@@ -35,6 +36,7 @@ export declare class MerkleTreesFacade implements MerkleTreeReadOperations {
 export declare class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTreeWriteOperations {
     private opts;
     private log;
+    private closePromise;
     constructor(instance: NativeWorldStateInstance, initialHeader: BlockHeader, revision: WorldStateRevision, opts: {
         closeDelayMs?: number;
     });
@@ -43,12 +45,13 @@ export declare class MerkleTreesForkFacade extends MerkleTreesFacade implements
     batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(treeId: ID, rawLeaves: Buffer[], subtreeHeight: number): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
     sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(treeId: ID, rawLeaves: Buffer[]): Promise<SequentialInsertionResult<TreeHeight>>;
     close(): Promise<void>;
-    [Symbol.dispose](): Promise<void>;
-    createCheckpoint(): Promise<void>;
+    private doClose;
+    [Symbol.asyncDispose](): Promise<void>;
+    createCheckpoint(): Promise<number>;
     commitCheckpoint(): Promise<void>;
     revertCheckpoint(): Promise<void>;
-    commitAllCheckpoints(): Promise<void>;
-    revertAllCheckpoints(): Promise<void>;
+    commitAllCheckpointsTo(depth: number): Promise<void>;
+    revertAllCheckpointsTo(depth: number): Promise<void>;
 }
-export declare function serializeLeaf(leaf: Fr | NullifierLeaf | PublicDataTreeLeaf): SerializedLeafValue;
-//# sourceMappingURL=data:application/json;base64,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
+export declare function serializeLeaf(leaf: Fr | BlockHash | NullifierLeaf | PublicDataTreeLeaf): SerializedLeafValue;
+//# sourceMappingURL=data:application/json;base64,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