@aztec/world-state 0.0.0-test.0

package/README.md

@@ -0,0 +1,40 @@
+# World State
+
+## Overview
+
+The primary functions of the world state package are to maintain the collection of Merkle Trees comprising the global state of the system and to offer an interface with which the trees can be queried.
+
+### The Merkle Tree DB, a collection of Merkle Trees of varying types.
+
+As of the time of writing the collection consisted of the following trees.
+
+#### Standard 'Append Only' trees
+
+- The Contract Tree. Every contract created within the system has a 'Function Tree', a tree of leaves generated from the functions on the contract. The root of the function tree is inserted as a leaf in the contracts tree.
+- The Contract Tree Roots Tree. A tree whose leaves are the historical roots of the contract tree.
+- The Note Hash Tree. A tree whose leaves are the note hashes of notes generated by the private contract function calls within the system.
+- The Note Hash Tree Roots Tree. A tree whose leaves are the historical roots of the note hash tree.
+
+#### Indexed trees
+
+- The Nullifier Tree. A tree whose leaves contain the consumed values (commitments, tx hashes etc) of the system.
+
+#### Sparse trees
+
+- The Public Data Tree. A tree whose leaves are the current value of every item of public state in the system, addressed as `leaf_index = hash(contract_address, storage_slot_in_contract)`
+
+### The Synchronizer
+
+The synchronizer's role is to periodically poll for new block information and reconcile that information with the current state of the Merkle Trees.
+
+Once a new block is received, the synchronizer checks the uncommitted root values of all of the trees against the roots published as part of the block. If they are all equal, the tree state is committed. If they are not equal, the tree states are rolled back to the last committed state before the published data is inserted and committed.
+
+### The Merkle Tree Interface
+
+The interface to the Merkle Tree DB offers a unified asynchronous API to the set of trees available. Reads from the Merkle Trees need to be marked as to whether they should include uncommitted state. For this reason, the MerkleTreeReadOperationsFacade exists to abstract this detail away from the end consumer.
+
+# Building/Testing
+
+Building the package is as simple as calling `yarn build` from the package root.
+
+Running `yarn test` will execute the packages unit tests.

package/dest/index.d.ts

@@ -0,0 +1,5 @@
+export * from './synchronizer/index.js';
+export * from './world-state-db/index.js';
+export * from './synchronizer/config.js';
+export * from './native/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC"}

package/dest/index.js

@@ -0,0 +1,4 @@
+export * from './synchronizer/index.js';
+export * from './world-state-db/index.js';
+export * from './synchronizer/config.js';
+export * from './native/index.js';

package/dest/instrumentation/instrumentation.d.ts

@@ -0,0 +1,22 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { WorldStateMessageType, type WorldStateStatusFull } from '../native/message.js';
+export declare class WorldStateInstrumentation {
+    readonly telemetry: TelemetryClient;
+    private log;
+    private dbMapSize;
+    private treeSize;
+    private unfinalisedHeight;
+    private finalisedHeight;
+    private oldestBlock;
+    private dbNumItems;
+    private dbUsedSize;
+    private requestHistogram;
+    private criticalErrors;
+    constructor(telemetry: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    private updateTreeStats;
+    private updateTreeDBStats;
+    updateWorldStateMetrics(worldStateStatus: WorldStateStatusFull): void;
+    recordRoundTrip(timeUs: number, request: WorldStateMessageType): void;
+    incCriticalErrors(errorType: 'synch_pending_block' | 'finalize_block' | 'prune_pending_block' | 'prune_historical_block'): void;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/dest/instrumentation/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/instrumentation/instrumentation.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAIL,qBAAqB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAa9B,qBAAa,yBAAyB;aAWR,SAAS,EAAE,eAAe;IAAE,OAAO,CAAC,GAAG;IAVnE,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,cAAc,CAAgB;gBAEV,SAAS,EAAE,eAAe,EAAU,GAAG,yCAA8C;IAiDjH,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,iBAAiB;IAWlB,uBAAuB,CAAC,gBAAgB,EAAE,oBAAoB;IAgC9D,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAQ9D,iBAAiB,CACtB,SAAS,EAAE,qBAAqB,GAAG,gBAAgB,GAAG,qBAAqB,GAAG,wBAAwB;CAMzG"}

package/dest/instrumentation/instrumentation.js

@@ -0,0 +1,117 @@
+import { createLogger } from '@aztec/foundation/log';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { WorldStateMessageType } from '../native/message.js';
+const durationTrackDenylist = new Set([
+    WorldStateMessageType.GET_INITIAL_STATE_REFERENCE,
+    WorldStateMessageType.CLOSE,
+    // these aren't used anymore, should be removed from the API
+    WorldStateMessageType.COMMIT,
+    WorldStateMessageType.ROLLBACK
+]);
+export class WorldStateInstrumentation {
+    telemetry;
+    log;
+    dbMapSize;
+    treeSize;
+    unfinalisedHeight;
+    finalisedHeight;
+    oldestBlock;
+    dbNumItems;
+    dbUsedSize;
+    requestHistogram;
+    criticalErrors;
+    constructor(telemetry, log = createLogger('world-state:instrumentation')){
+        this.telemetry = telemetry;
+        this.log = log;
+        const meter = telemetry.getMeter('World State');
+        this.dbMapSize = meter.createGauge(Metrics.WORLD_STATE_DB_MAP_SIZE, {
+            description: `The current configured map size for each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.treeSize = meter.createGauge(Metrics.WORLD_STATE_TREE_SIZE, {
+            description: `The current number of leaves in each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.unfinalisedHeight = meter.createGauge(Metrics.WORLD_STATE_UNFINALISED_HEIGHT, {
+            description: `The unfinalised block height of each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.finalisedHeight = meter.createGauge(Metrics.WORLD_STATE_FINALISED_HEIGHT, {
+            description: `The finalised block height of each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.oldestBlock = meter.createGauge(Metrics.WORLD_STATE_OLDEST_BLOCK, {
+            description: `The oldest historical block of each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.dbUsedSize = meter.createGauge(Metrics.WORLD_STATE_DB_USED_SIZE, {
+            description: `The current used database size for each db of each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.dbNumItems = meter.createGauge(Metrics.WORLD_STATE_DB_NUM_ITEMS, {
+            description: `The current number of items in each database of each merkle tree`,
+            valueType: ValueType.INT
+        });
+        this.requestHistogram = meter.createHistogram(Metrics.WORLD_STATE_REQUEST_TIME, {
+            description: 'The round trip time of world state requests',
+            unit: 'us',
+            valueType: ValueType.INT
+        });
+        this.criticalErrors = meter.createUpDownCounter(Metrics.WORLD_STATE_CRITICAL_ERROR_COUNT, {
+            description: 'The number of critical errors in the world state',
+            valueType: ValueType.INT
+        });
+    }
+    updateTreeStats(treeDbStats, treeMeta, tree) {
+        this.dbMapSize.record(Number(treeDbStats.mapSize), {
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.treeSize.record(Number(treeMeta.size), {
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.unfinalisedHeight.record(Number(treeMeta.unfinalisedBlockHeight), {
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.finalisedHeight.record(Number(treeMeta.finalisedBlockHeight), {
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.oldestBlock.record(Number(treeMeta.oldestHistoricBlock), {
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.updateTreeDBStats(treeDbStats.blockIndicesDBStats, 'block_indices', tree);
+        this.updateTreeDBStats(treeDbStats.blocksDBStats, 'blocks', tree);
+        this.updateTreeDBStats(treeDbStats.leafIndicesDBStats, 'leaf_indices', tree);
+        this.updateTreeDBStats(treeDbStats.leafPreimagesDBStats, 'leaf_preimage', tree);
+        this.updateTreeDBStats(treeDbStats.nodesDBStats, 'nodes', tree);
+    }
+    updateTreeDBStats(dbStats, dbType, tree) {
+        this.dbNumItems.record(Number(dbStats.numDataItems), {
+            [Attributes.WS_DB_DATA_TYPE]: dbType,
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+        this.dbUsedSize.record(Number(dbStats.totalUsedSize), {
+            [Attributes.WS_DB_DATA_TYPE]: dbType,
+            [Attributes.MERKLE_TREE_NAME]: MerkleTreeId[tree]
+        });
+    }
+    updateWorldStateMetrics(worldStateStatus) {
+        this.updateTreeStats(worldStateStatus.dbStats.archiveTreeStats, worldStateStatus.meta.archiveTreeMeta, MerkleTreeId.ARCHIVE);
+        this.updateTreeStats(worldStateStatus.dbStats.messageTreeStats, worldStateStatus.meta.messageTreeMeta, MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        this.updateTreeStats(worldStateStatus.dbStats.noteHashTreeStats, worldStateStatus.meta.noteHashTreeMeta, MerkleTreeId.NOTE_HASH_TREE);
+        this.updateTreeStats(worldStateStatus.dbStats.nullifierTreeStats, worldStateStatus.meta.nullifierTreeMeta, MerkleTreeId.NULLIFIER_TREE);
+        this.updateTreeStats(worldStateStatus.dbStats.publicDataTreeStats, worldStateStatus.meta.publicDataTreeMeta, MerkleTreeId.PUBLIC_DATA_TREE);
+    }
+    recordRoundTrip(timeUs, request) {
+        if (!durationTrackDenylist.has(request)) {
+            this.requestHistogram.record(Math.ceil(timeUs), {
+                [Attributes.WORLD_STATE_REQUEST_TYPE]: WorldStateMessageType[request]
+            });
+        }
+    }
+    incCriticalErrors(errorType) {
+        this.criticalErrors.add(1, {
+            [Attributes.ERROR_TYPE]: errorType
+        });
+    }
+}

package/dest/native/fork_checkpoint.d.ts

@@ -0,0 +1,10 @@
+import type { MerkleTreeCheckpointOperations } from '@aztec/stdlib/interfaces/server';
+export declare class ForkCheckpoint {
+    private readonly fork;
+    private completed;
+    private constructor();
+    static new(fork: MerkleTreeCheckpointOperations): Promise<ForkCheckpoint>;
+    commit(): Promise<void>;
+    revert(): Promise<void>;
+}
+//# sourceMappingURL=fork_checkpoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fork_checkpoint.d.ts","sourceRoot":"","sources":["../../src/native/fork_checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAEtF,qBAAa,cAAc;IAGL,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFzC,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO;WAEM,GAAG,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,cAAc,CAAC;IAKzE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IASvB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ9B"}

package/dest/native/fork_checkpoint.js

@@ -0,0 +1,26 @@
+export class ForkCheckpoint {
+    fork;
+    completed;
+    constructor(fork){
+        this.fork = fork;
+        this.completed = false;
+    }
+    static async new(fork) {
+        await fork.createCheckpoint();
+        return new ForkCheckpoint(fork);
+    }
+    async commit() {
+        if (this.completed) {
+            return;
+        }
+        await this.fork.commitCheckpoint();
+        this.completed = true;
+    }
+    async revert() {
+        if (this.completed) {
+            return;
+        }
+        await this.fork.revertCheckpoint();
+        this.completed = true;
+    }
+}

package/dest/native/index.d.ts

@@ -0,0 +1,3 @@
+export * from './native_world_state.js';
+export * from './fork_checkpoint.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/native/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

package/dest/native/index.js

@@ -0,0 +1,2 @@
+export * from './native_world_state.js';
+export * from './fork_checkpoint.js';

package/dest/native/merkle_trees_facade.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+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';
+import { type SerializedLeafValue, type WorldStateRevision } from './message.js';
+import type { NativeWorldStateInstance } from './native_world_state_instance.js';
+export declare class MerkleTreesFacade implements MerkleTreeReadOperations {
+    protected readonly instance: NativeWorldStateInstance;
+    protected readonly initialHeader: BlockHeader;
+    protected readonly revision: WorldStateRevision;
+    constructor(instance: NativeWorldStateInstance, initialHeader: BlockHeader, revision: WorldStateRevision);
+    getInitialHeader(): BlockHeader;
+    findLeafIndices(treeId: MerkleTreeId, values: MerkleTreeLeafType<MerkleTreeId>[]): Promise<(bigint | undefined)[]>;
+    findLeafIndicesAfter(treeId: MerkleTreeId, leaves: MerkleTreeLeafType<MerkleTreeId>[], startIndex: bigint): Promise<(bigint | undefined)[]>;
+    getLeafPreimage(treeId: IndexedTreeId, leafIndex: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
+    getLeafValue<ID extends MerkleTreeId>(treeId: ID, leafIndex: bigint): Promise<MerkleTreeLeafType<ID> | undefined>;
+    getPreviousValueIndex(treeId: IndexedTreeId, value: bigint): Promise<{
+        index: bigint;
+        alreadyPresent: boolean;
+    } | undefined>;
+    getSiblingPath<N extends number>(treeId: MerkleTreeId, leafIndex: bigint): Promise<SiblingPath<N>>;
+    getStateReference(): Promise<StateReference>;
+    getInitialStateReference(): Promise<StateReference>;
+    getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo>;
+    getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(treeId: ID, leafIndices: bigint[]): Promise<(bigint | undefined)[]>;
+}
+export declare class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTreeWriteOperations {
+    constructor(instance: NativeWorldStateInstance, initialHeader: BlockHeader, revision: WorldStateRevision);
+    updateArchive(header: BlockHeader): Promise<void>;
+    appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void>;
+    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>;
+    createCheckpoint(): Promise<void>;
+    commitCheckpoint(): Promise<void>;
+    revertCheckpoint(): Promise<void>;
+}
+export declare function serializeLeaf(leaf: Fr | NullifierLeaf | PublicDataTreeLeaf): SerializedLeafValue;
+//# sourceMappingURL=merkle_trees_facade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merkle_trees_facade.d.ts","sourceRoot":"","sources":["../../src/native/merkle_trees_facade.ts"],"names":[],"mappings":"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"}

package/dest/native/merkle_trees_facade.js

@@ -0,0 +1,240 @@
+import { Fr } from '@aztec/foundation/fields';
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { SiblingPath } from '@aztec/foundation/trees';
+import { MerkleTreeId, NullifierLeaf, NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
+import { PartialStateReference, StateReference } from '@aztec/stdlib/tx';
+import assert from 'assert';
+import { WorldStateMessageType, blockStateReference, treeStateReferenceToSnapshot } from './message.js';
+export class MerkleTreesFacade {
+    instance;
+    initialHeader;
+    revision;
+    constructor(instance, initialHeader, revision){
+        this.instance = instance;
+        this.initialHeader = initialHeader;
+        this.revision = revision;
+    }
+    getInitialHeader() {
+        return this.initialHeader;
+    }
+    findLeafIndices(treeId, values) {
+        return this.findLeafIndicesAfter(treeId, values, 0n);
+    }
+    async findLeafIndicesAfter(treeId, leaves, startIndex) {
+        const response = await this.instance.call(WorldStateMessageType.FIND_LEAF_INDICES, {
+            leaves: leaves.map((leaf)=>serializeLeaf(hydrateLeaf(treeId, leaf))),
+            revision: this.revision,
+            treeId,
+            startIndex
+        });
+        return response.indices.map((index)=>{
+            if (typeof index === 'number' || typeof index === 'bigint') {
+                return BigInt(index);
+            } else {
+                return undefined;
+            }
+        });
+    }
+    async getLeafPreimage(treeId, leafIndex) {
+        const resp = await this.instance.call(WorldStateMessageType.GET_LEAF_PREIMAGE, {
+            leafIndex,
+            revision: this.revision,
+            treeId
+        });
+        return resp ? deserializeIndexedLeaf(resp) : undefined;
+    }
+    async getLeafValue(treeId, leafIndex) {
+        const resp = await this.instance.call(WorldStateMessageType.GET_LEAF_VALUE, {
+            leafIndex,
+            revision: this.revision,
+            treeId
+        });
+        if (!resp) {
+            return undefined;
+        }
+        const leaf = deserializeLeafValue(resp);
+        if (leaf instanceof Fr) {
+            return leaf;
+        } else {
+            return leaf.toBuffer();
+        }
+    }
+    async getPreviousValueIndex(treeId, value) {
+        const resp = await this.instance.call(WorldStateMessageType.FIND_LOW_LEAF, {
+            key: new Fr(value),
+            revision: this.revision,
+            treeId
+        });
+        return {
+            alreadyPresent: resp.alreadyPresent,
+            index: BigInt(resp.index)
+        };
+    }
+    async getSiblingPath(treeId, leafIndex) {
+        const siblingPath = await this.instance.call(WorldStateMessageType.GET_SIBLING_PATH, {
+            leafIndex,
+            revision: this.revision,
+            treeId
+        });
+        return new SiblingPath(siblingPath.length, siblingPath);
+    }
+    async getStateReference() {
+        const resp = await this.instance.call(WorldStateMessageType.GET_STATE_REFERENCE, {
+            revision: this.revision
+        });
+        return new StateReference(treeStateReferenceToSnapshot(resp.state[MerkleTreeId.L1_TO_L2_MESSAGE_TREE]), new PartialStateReference(treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NOTE_HASH_TREE]), treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NULLIFIER_TREE]), treeStateReferenceToSnapshot(resp.state[MerkleTreeId.PUBLIC_DATA_TREE])));
+    }
+    async getInitialStateReference() {
+        const resp = await this.instance.call(WorldStateMessageType.GET_INITIAL_STATE_REFERENCE, {
+            canonical: true
+        });
+        return new StateReference(treeStateReferenceToSnapshot(resp.state[MerkleTreeId.L1_TO_L2_MESSAGE_TREE]), new PartialStateReference(treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NOTE_HASH_TREE]), treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NULLIFIER_TREE]), treeStateReferenceToSnapshot(resp.state[MerkleTreeId.PUBLIC_DATA_TREE])));
+    }
+    async getTreeInfo(treeId) {
+        const resp = await this.instance.call(WorldStateMessageType.GET_TREE_INFO, {
+            treeId: treeId,
+            revision: this.revision
+        });
+        return {
+            depth: resp.depth,
+            root: resp.root,
+            size: BigInt(resp.size),
+            treeId
+        };
+    }
+    async getBlockNumbersForLeafIndices(treeId, leafIndices) {
+        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));
+    }
+}
+export class MerkleTreesForkFacade extends MerkleTreesFacade {
+    constructor(instance, initialHeader, revision){
+        assert.notEqual(revision.forkId, 0, 'Fork ID must be set');
+        assert.equal(revision.includeUncommitted, true, 'Fork must include uncommitted data');
+        super(instance, initialHeader, revision);
+    }
+    async updateArchive(header) {
+        await this.instance.call(WorldStateMessageType.UPDATE_ARCHIVE, {
+            forkId: this.revision.forkId,
+            blockHeaderHash: (await header.hash()).toBuffer(),
+            blockStateRef: blockStateReference(header.state)
+        });
+    }
+    async appendLeaves(treeId, leaves) {
+        await this.instance.call(WorldStateMessageType.APPEND_LEAVES, {
+            leaves: leaves.map((leaf)=>leaf),
+            forkId: this.revision.forkId,
+            treeId
+        });
+    }
+    async batchInsert(treeId, rawLeaves, subtreeHeight) {
+        const leaves = rawLeaves.map((leaf)=>hydrateLeaf(treeId, leaf)).map(serializeLeaf);
+        const resp = await this.instance.call(WorldStateMessageType.BATCH_INSERT, {
+            leaves,
+            treeId,
+            forkId: this.revision.forkId,
+            subtreeDepth: subtreeHeight
+        });
+        return {
+            newSubtreeSiblingPath: new SiblingPath(resp.subtree_path.length, resp.subtree_path),
+            sortedNewLeaves: resp.sorted_leaves.map(([leaf])=>leaf).map(deserializeLeafValue).map(serializeToBuffer),
+            sortedNewLeavesIndexes: resp.sorted_leaves.map(([, index])=>index),
+            lowLeavesWitnessData: resp.low_leaf_witness_data.map((data)=>({
+                    index: BigInt(data.index),
+                    leafPreimage: deserializeIndexedLeaf(data.leaf),
+                    siblingPath: new SiblingPath(data.path.length, data.path)
+                }))
+        };
+    }
+    async sequentialInsert(treeId, rawLeaves) {
+        const leaves = rawLeaves.map((leaf)=>hydrateLeaf(treeId, leaf)).map(serializeLeaf);
+        const resp = await this.instance.call(WorldStateMessageType.SEQUENTIAL_INSERT, {
+            leaves,
+            treeId,
+            forkId: this.revision.forkId
+        });
+        return {
+            lowLeavesWitnessData: resp.low_leaf_witness_data.map((data)=>({
+                    index: BigInt(data.index),
+                    leafPreimage: deserializeIndexedLeaf(data.leaf),
+                    siblingPath: new SiblingPath(data.path.length, data.path)
+                })),
+            insertionWitnessData: resp.insertion_witness_data.map((data)=>({
+                    index: BigInt(data.index),
+                    leafPreimage: deserializeIndexedLeaf(data.leaf),
+                    siblingPath: new SiblingPath(data.path.length, data.path)
+                }))
+        };
+    }
+    async close() {
+        assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+        await this.instance.call(WorldStateMessageType.DELETE_FORK, {
+            forkId: this.revision.forkId
+        });
+    }
+    async createCheckpoint() {
+        assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+        await this.instance.call(WorldStateMessageType.CREATE_CHECKPOINT, {
+            forkId: this.revision.forkId
+        });
+    }
+    async commitCheckpoint() {
+        assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+        await this.instance.call(WorldStateMessageType.COMMIT_CHECKPOINT, {
+            forkId: this.revision.forkId
+        });
+    }
+    async revertCheckpoint() {
+        assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+        await this.instance.call(WorldStateMessageType.REVERT_CHECKPOINT, {
+            forkId: this.revision.forkId
+        });
+    }
+}
+function hydrateLeaf(treeId, leaf) {
+    if (leaf instanceof Fr) {
+        return leaf;
+    } else if (treeId === MerkleTreeId.NULLIFIER_TREE) {
+        return NullifierLeaf.fromBuffer(leaf);
+    } else if (treeId === MerkleTreeId.PUBLIC_DATA_TREE) {
+        return PublicDataTreeLeaf.fromBuffer(leaf);
+    } else {
+        return Fr.fromBuffer(leaf);
+    }
+}
+export function serializeLeaf(leaf) {
+    if (leaf instanceof Fr) {
+        return leaf.toBuffer();
+    } else if (leaf instanceof NullifierLeaf) {
+        return {
+            value: leaf.nullifier.toBuffer()
+        };
+    } else {
+        return {
+            value: leaf.value.toBuffer(),
+            slot: leaf.slot.toBuffer()
+        };
+    }
+}
+function deserializeLeafValue(leaf) {
+    if (Buffer.isBuffer(leaf)) {
+        return Fr.fromBuffer(leaf);
+    } else if ('slot' in leaf) {
+        return new PublicDataTreeLeaf(Fr.fromBuffer(leaf.slot), Fr.fromBuffer(leaf.value));
+    } else {
+        return new NullifierLeaf(Fr.fromBuffer(leaf.value));
+    }
+}
+function deserializeIndexedLeaf(leaf) {
+    if ('slot' in leaf.value) {
+        return new PublicDataTreeLeafPreimage(Fr.fromBuffer(leaf.value.slot), Fr.fromBuffer(leaf.value.value), Fr.fromBuffer(leaf.nextValue), BigInt(leaf.nextIndex));
+    } else if ('value' in leaf.value) {
+        return new NullifierLeafPreimage(Fr.fromBuffer(leaf.value.value), Fr.fromBuffer(leaf.nextValue), BigInt(leaf.nextIndex));
+    } else {
+        throw new Error('Invalid leaf type');
+    }
+}