@unlink-xyz/core 0.1.3-canary.fd5dddf → 0.1.4

package/dist/state/merkle/hydrator.js

@@ -1,37 +0,0 @@
-import { CoreError } from "../../errors.js";
-import { parseHexToBigInt } from "../../utils/bigint.js";
-export async function rebuildTreeFromStore({ chainId, trees, loadLeaf, }) {
-    trees.reset(chainId);
-    let idx = 0;
-    for (;;) {
-        const leaf = await loadLeaf(chainId, idx);
-        if (!leaf)
-            break;
-        const { index } = trees.addLeaf(chainId, parseHexToBigInt(leaf.commitment));
-        if (index !== idx) {
-            throw new CoreError(`stored leaves are inconsistent with local tree, expected ${idx}, got ${index}`);
-        }
-        idx += 1;
-    }
-    return idx;
-}
-// TODO: Will be used for inmemory merkle tree handling for caching.
-// Atm everytime we need to access the tree we have to rebuild it from the store.
-// This function will help to avoid multiple rebuilds for the same chain
-export async function hydrateChain({ chainId, trees, loadLeaf, hydrated, }) {
-    if (hydrated.has(chainId))
-        return;
-    trees.reset(chainId);
-    let idx = 0;
-    for (;;) {
-        const leaf = await loadLeaf(chainId, idx);
-        if (!leaf)
-            break;
-        const { index } = trees.addLeaf(chainId, parseHexToBigInt(leaf.commitment));
-        if (index !== idx) {
-            throw new CoreError("stored leaves are inconsistent with local tree");
-        }
-        idx += 1;
-    }
-    hydrated.add(chainId);
-}

package/dist/state/merkle/index.js

@@ -1,2 +0,0 @@
-export { createLocalMerkleTree, createMerkleTrees, resolveMerkleTrees, } from "./merkle-tree.js";
-export { hydrateChain, rebuildTreeFromStore, } from "./hydrator.js";

package/dist/state/merkle/merkle-tree.js

@@ -1,113 +0,0 @@
-import { IMT, } from "@zk-kit/imt";
-import { poseidon } from "../../crypto-adapters/index.js";
-import { CoreError } from "../../errors.js";
-import { FieldSize, Hex } from "../../keys/hex.js";
-import { ensureChainId } from "../../utils/validators.js";
-const DEFAULT_DEPTH = 16;
-const DEFAULT_ARITY = 2;
-const ZERO_BYTE_LENGTH = FieldSize.SCALAR;
-// Simple adapter: IMTNode[] -> poseidon(bigint[])
-const hash = (values) => poseidon(values.map((v) => BigInt(v)));
-const formatNode = (value) => Hex.fromBigInt(value, ZERO_BYTE_LENGTH, true);
-export function createLocalMerkleTree() {
-    const zeroLeaf = 0n;
-    const capacity = 2 ** DEFAULT_DEPTH;
-    const tree = new IMT(hash, DEFAULT_DEPTH, zeroLeaf, DEFAULT_ARITY);
-    function addLeaf(value) {
-        if (tree.leaves.length >= capacity) {
-            throw new CoreError("merkle tree is full");
-        }
-        const insertedIndex = tree.leaves.length;
-        tree.insert(value);
-        return {
-            index: insertedIndex,
-            root: formatNode(tree.root),
-        };
-    }
-    function getRoot() {
-        return formatNode(tree.root);
-    }
-    function getLeafCount() {
-        return tree.leaves.length;
-    }
-    function getLeaf(index) {
-        const leaf = tree.leaves[index];
-        if (leaf === undefined) {
-            throw new CoreError("leaf does not exist in this tree");
-        }
-        return formatNode(BigInt(leaf));
-    }
-    function createMerkleProof(index) {
-        return tree.createProof(index);
-    }
-    return {
-        addLeaf,
-        getRoot,
-        getLeafCount,
-        getLeaf,
-        createMerkleProof,
-        getZero(level) {
-            if (level === tree.depth) {
-                return getRoot();
-            }
-            const zero = tree.zeroes[level];
-            if (zero === undefined) {
-                throw new CoreError("invalid level");
-            }
-            return formatNode(zero);
-        },
-        get depth() {
-            return tree.depth;
-        },
-        get capacity() {
-            return capacity;
-        },
-    };
-}
-export function createMerkleTrees() {
-    const trees = new Map();
-    const resetTree = (chainId) => {
-        ensureChainId(chainId);
-        const tree = createLocalMerkleTree();
-        trees.set(chainId, tree);
-        return tree;
-    };
-    const getOrCreate = (chainId) => {
-        ensureChainId(chainId);
-        let tree = trees.get(chainId);
-        if (!tree) {
-            tree = resetTree(chainId);
-        }
-        return tree;
-    };
-    return {
-        get(chainId) {
-            ensureChainId(chainId);
-            return trees.get(chainId);
-        },
-        getOrCreate,
-        addLeaf(chainId, value) {
-            return getOrCreate(chainId).addLeaf(value);
-        },
-        createMerkleProof(chainId, index) {
-            return getOrCreate(chainId).createMerkleProof(index);
-        },
-        getRoot(chainId) {
-            return getOrCreate(chainId).getRoot();
-        },
-        getLeafCount(chainId) {
-            return getOrCreate(chainId).getLeafCount();
-        },
-        reset(chainId) {
-            resetTree(chainId);
-        },
-    };
-}
-/**
- * Resolve merkle trees from options or create new instance.
- * @param opts - Options object that may contain merkle trees
- * @returns Merkle trees instance
- */
-export function resolveMerkleTrees(opts) {
-    return opts?.merkleTrees ?? createMerkleTrees();
-}

package/dist/state/store/ciphertext-store.js

@@ -1,37 +0,0 @@
-import { keys, validateKey } from "../../keys.js";
-import { ensureChainId, ensurePositiveInt } from "../../utils/validators.js";
-export function createCiphertextStore(storage) {
-    return {
-        /**
-         * Store encrypted note payloads alongside their on-chain commitments.
-         */
-        async putCiphertext(chainId, index, payload) {
-            ensureChainId(chainId);
-            ensurePositiveInt("ciphertext index", index);
-            const key = keys.ciphertext(chainId, index);
-            validateKey(key);
-            await storage.put(key, new Uint8Array(payload));
-        },
-        /**
-         * Retrieve encrypted note payloads; returns null when the ciphertext is missing.
-         */
-        async getCiphertext(chainId, index) {
-            ensureChainId(chainId);
-            ensurePositiveInt("ciphertext index", index);
-            const data = await storage.get(keys.ciphertext(chainId, index));
-            return data ? new Uint8Array(data) : null;
-        },
-        /**
-         * Remove all cached ciphertexts for a chain.
-         */
-        async clearCiphertexts(chainId) {
-            ensureChainId(chainId);
-            const prefix = `ciphertexts:${chainId}:`;
-            const entries = await storage.iter({ prefix });
-            if (entries.length === 0)
-                return;
-            const deletions = entries.map(({ key }) => ({ del: key }));
-            await storage.batch(deletions);
-        },
-    };
-}

package/dist/state/store/history-store.js

@@ -1,53 +0,0 @@
-import { keys } from "../../keys.js";
-import { decodeJson, encodeJson, } from "../../utils/json-codec.js";
-import { ensureChainId, ensureMpk } from "../../utils/validators.js";
-export function createHistoryStore(storage) {
-    async function putMeta(options) {
-        await storage.put(keys.historyMeta(options.chainId, options.mpk), encodeJson({ v: 1, updatedAtMs: Date.now() }));
-    }
-    return {
-        async putHistoryEntry(entry) {
-            ensureChainId(entry.chainId);
-            ensureMpk(entry.mpk);
-            const key = keys.historyEntry(entry.id);
-            await storage.put(key, encodeJson(entry));
-        },
-        async hasHistorySnapshot(options) {
-            ensureChainId(options.chainId);
-            ensureMpk(options.mpk);
-            const meta = await storage.get(keys.historyMeta(options.chainId, options.mpk));
-            return meta !== null;
-        },
-        async listHistoryEntries(options) {
-            ensureChainId(options.chainId);
-            ensureMpk(options.mpk);
-            const prefix = keys.historyPrefix(options.chainId, options.mpk);
-            const entries = await storage.iter({ prefix });
-            const decoded = entries
-                .filter(({ key }) => !key.endsWith(":__meta__"))
-                .map(({ value }) => decodeJson(value));
-            decoded.sort((a, b) => {
-                const at = a.timestamp ?? 0;
-                const bt = b.timestamp ?? 0;
-                if (at !== bt)
-                    return bt - at;
-                return b.txHash.localeCompare(a.txHash);
-            });
-            return decoded;
-        },
-        async clearHistoryEntries(options) {
-            ensureChainId(options.chainId);
-            ensureMpk(options.mpk);
-            const prefix = keys.historyPrefix(options.chainId, options.mpk);
-            const existing = await storage.iter({ prefix });
-            if (existing.length === 0)
-                return;
-            await storage.batch(existing.map(({ key }) => ({ del: key })));
-        },
-        async commitHistorySnapshot(options) {
-            ensureChainId(options.chainId);
-            ensureMpk(options.mpk);
-            await putMeta(options);
-        },
-    };
-}

package/dist/state/store/index.js

@@ -1,9 +0,0 @@
-export { createStateStore } from "./store.js";
-export { createLeafStore } from "./leaf-store.js";
-export { createNoteStore } from "./note-store.js";
-export { createNullifierStore } from "./nullifier-store.js";
-export { createRootStore } from "./root-store.js";
-export { createCiphertextStore } from "./ciphertext-store.js";
-export { createHistoryStore } from "./history-store.js";
-export { createJobStore } from "./job-store.js";
-export { DEFAULT_JOB_TIMEOUT_MS, } from "./jobs.js";

package/dist/state/store/job-store.js

@@ -1,144 +0,0 @@
-import { CoreError } from "../../errors.js";
-import { keys } from "../../keys.js";
-import { decodeJson, encodeJson, getJson } from "../../utils/json-codec.js";
-import { ensureAddress, ensureChainId, ensureMpk, ensurePositiveInt, } from "../../utils/validators.js";
-import { DEFAULT_JOB_TIMEOUT_MS } from "../store/jobs.js";
-const VALID_STATUSES = [
-    "pending",
-    "submitted",
-    "broadcasting",
-    "succeeded",
-    "failed",
-    "dead",
-];
-const VALID_KINDS = ["deposit", "transfer", "withdraw"];
-function assertStatus(status) {
-    if (!VALID_STATUSES.includes(status)) {
-        throw new CoreError(`invalid job status: ${status}`);
-    }
-}
-function assertKind(kind) {
-    if (!VALID_KINDS.includes(kind)) {
-        throw new CoreError(`invalid job kind: ${kind}`);
-    }
-}
-function normalizeTimestamps(job) {
-    const createdAt = typeof job.createdAt === "number" && Number.isFinite(job.createdAt)
-        ? job.createdAt
-        : Date.now();
-    const timeoutMs = typeof job.timeoutMs === "number" && job.timeoutMs > 0
-        ? job.timeoutMs
-        : DEFAULT_JOB_TIMEOUT_MS;
-    return {
-        ...job,
-        createdAt,
-        timeoutMs,
-    };
-}
-function validatePoolTransactionRecord(job) {
-    ensureAddress("pool address", job.poolAddress);
-    if (!job.calldata) {
-        throw new CoreError("calldata is required for pool transaction record");
-    }
-    if (!Array.isArray(job.transactions) || !job.transactions.length) {
-        throw new CoreError("transactions array is required");
-    }
-    for (let i = 0; i < job.transactions.length; i++) {
-        const tx = job.transactions[i];
-        ensureAddress(`transaction token at ${i}`, tx.token);
-        if (!Array.isArray(tx.nullifiers) || !tx.nullifiers.length) {
-            throw new CoreError(`nullifiers array is required at index ${i}`);
-        }
-        // predictedCommitments can be empty for withdrawals with no change
-        if (!Array.isArray(tx.predictedCommitments)) {
-            throw new CoreError(`predicted commitments array is required at index ${i}`);
-        }
-        // Only require non-empty commitments if there's no withdrawal
-        if (!tx.predictedCommitments.length && !tx.withdrawal) {
-            throw new CoreError(`predicted commitments are required at index ${i}`);
-        }
-        for (let j = 0; j < tx.predictedCommitments.length; j++) {
-            const c = tx.predictedCommitments[j];
-            if (!c.hex) {
-                throw new CoreError(`predicted commitment hex is required at index ${i}.${j}`);
-            }
-        }
-        if (tx.withdrawal) {
-            if (!tx.withdrawal.amount) {
-                throw new CoreError(`withdrawal amount is required at index ${i}`);
-            }
-            if (!tx.withdrawal.recipient) {
-                throw new CoreError(`withdrawal recipient is required at index ${i}`);
-            }
-        }
-    }
-}
-function validateDepositRecord(job) {
-    if (!Array.isArray(job.predictedCommitments) ||
-        !job.predictedCommitments.length) {
-        throw new CoreError("predicted commitments array is required for deposit");
-    }
-    for (let i = 0; i < job.predictedCommitments.length; i++) {
-        const c = job.predictedCommitments[i];
-        if (!c.hex) {
-            throw new CoreError(`predicted commitment hex is required at index ${i}`);
-        }
-        ensureAddress(`predicted commitment token at ${i}`, c.token);
-        if (!c.amount) {
-            throw new CoreError(`predicted commitment amount is required at index ${i}`);
-        }
-        if (c.index !== undefined) {
-            ensurePositiveInt(`predicted commitment index at ${i}`, c.index);
-        }
-    }
-}
-function validateJob(job) {
-    if (!job.relayId) {
-        throw new CoreError("relayId is required");
-    }
-    ensureChainId(job.chainId);
-    if (job.mpk !== undefined) {
-        ensureMpk(job.mpk);
-    }
-    assertStatus(job.status);
-    assertKind(job.kind);
-    ensurePositiveInt("job createdAt", job.createdAt);
-    ensurePositiveInt("job timeoutMs", job.timeoutMs);
-    if (job.lastCheckedAt !== undefined) {
-        ensurePositiveInt("job lastCheckedAt", job.lastCheckedAt);
-    }
-    if (job.kind === "deposit") {
-        validateDepositRecord(job);
-    }
-    else {
-        validatePoolTransactionRecord(job);
-    }
-}
-function buildJobKey(relayId) {
-    return keys.job(relayId);
-}
-export function createJobStore(storage) {
-    return {
-        async putJob(job) {
-            const normalized = normalizeTimestamps(job);
-            validateJob(normalized);
-            await storage.put(buildJobKey(normalized.relayId), encodeJson(normalized));
-        },
-        async getJob(relayId) {
-            return getJson(storage, buildJobKey(relayId));
-        },
-        async listJobs(filter = {}) {
-            const entries = await storage.iter({ prefix: "jobs:" });
-            const statuses = filter.statuses ?? VALID_STATUSES;
-            const filtered = entries
-                .map(({ value }) => decodeJson(value))
-                .filter((job) => (filter.kind === undefined || job.kind === filter.kind) &&
-                statuses.includes(job.status));
-            filtered.sort((a, b) => a.createdAt - b.createdAt);
-            return filtered;
-        },
-        async deleteJob(relayId) {
-            await storage.delete(buildJobKey(relayId));
-        },
-    };
-}

package/dist/state/store/jobs.js

@@ -1 +0,0 @@
-export const DEFAULT_JOB_TIMEOUT_MS = 5 * 60 * 1000;

package/dist/state/store/leaf-store.js

@@ -1,32 +0,0 @@
-import { keys } from "../../keys.js";
-import { getJson, putJson } from "../../utils/json-codec.js";
-import { ensureChainId, ensurePositiveInt } from "../../utils/validators.js";
-export function createLeafStore(storage) {
-    return {
-        /**
-         * Cache public leaf data pulled from the on-chain Merkle tree.
-         */
-        async putLeaf(leaf) {
-            ensureChainId(leaf.chainId);
-            ensurePositiveInt("leaf index", leaf.index);
-            await putJson(storage, keys.leaf(leaf.chainId, leaf.index), leaf);
-        },
-        /**
-         * Load a leaf commitment by tree index.
-         */
-        async getLeaf(chainId, index) {
-            return getJson(storage, keys.leaf(chainId, index));
-        },
-        /**
-         * Remove all cached leaves for a chain.
-         */
-        async clearLeaves(chainId) {
-            const prefix = `leaves:${chainId}:`;
-            const entries = await storage.iter({ prefix });
-            if (entries.length === 0)
-                return;
-            const deletions = entries.map(({ key }) => ({ del: key }));
-            await storage.batch(deletions);
-        },
-    };
-}

package/dist/state/store/note-store.js

@@ -1,146 +0,0 @@
-import { CoreError } from "../../errors.js";
-import { keys } from "../../keys.js";
-import { decodeJson, encodeJson, getJson, } from "../../utils/json-codec.js";
-import { ensureBigIntString, ensureChainId, ensureMpk, ensurePositiveInt, } from "../../utils/validators.js";
-export const emptyBytes = () => new Uint8Array(0);
-export function createNoteStore(storage) {
-    const persistNote = async (record) => {
-        ensureChainId(record.chainId);
-        ensurePositiveInt("note index", record.index);
-        ensureMpk(record.mpk);
-        ensureBigIntString("note value", record.value);
-        if (record.createdAt !== undefined) {
-            ensurePositiveInt("note createdAt", record.createdAt);
-        }
-        if (record.spentAt !== undefined) {
-            ensurePositiveInt("note spentAt", record.spentAt);
-        }
-        if (record.createdTxHash !== undefined &&
-            record.createdTxHash.length === 0) {
-            throw new CoreError("note createdTxHash must be a non-empty string");
-        }
-        if (record.createdEventType !== undefined &&
-            record.createdEventType.length === 0) {
-            throw new CoreError("note createdEventType must be a non-empty string");
-        }
-        if (record.spentTxHash !== undefined && record.spentTxHash.length === 0) {
-            throw new CoreError("note spentTxHash must be a non-empty string");
-        }
-        const noteKey = keys.note(record.chainId, record.index);
-        const previous = await getJson(storage, noteKey);
-        const ops = [
-            { put: [noteKey, encodeJson(record)] },
-        ];
-        if (previous && previous.spentAt === undefined) {
-            ops.push({
-                del: keys.unspent(previous.chainId, previous.mpk, previous.index),
-            });
-        }
-        if (record.spentAt === undefined) {
-            // idx:notes:unspent functions as a set, so we only persist the sentinel bytes.
-            ops.push({
-                put: [
-                    keys.unspent(record.chainId, record.mpk, record.index),
-                    emptyBytes(),
-                ],
-            });
-        }
-        else {
-            ops.push({
-                del: keys.unspent(record.chainId, record.mpk, record.index),
-            });
-        }
-        await storage.batch(ops);
-    };
-    const store = {
-        /**
-         * Upsert a note record and maintain the unspent-note index for fast balance queries.
-         * If the note already exists and is marked as spent, preserve spentAt unless the caller
-         * provides an explicit spentAt value (eg. upgrading from a local observation time to an
-         * on-chain timestamp from the indexer).
-         */
-        async putNote(note) {
-            const noteKey = keys.note(note.chainId, note.index);
-            const existing = await getJson(storage, noteKey);
-            if (existing?.spentAt !== undefined && note.spentAt === undefined) {
-                // Preserve spentAt if caller doesn't provide a value.
-                await persistNote({ ...note, spentAt: existing.spentAt });
-            }
-            else {
-                await persistNote({ ...note });
-            }
-        },
-        /**
-         * Fetch a note by (chainId, index) if it exists in local storage.
-         */
-        async getNote(chainId, index) {
-            return getJson(storage, keys.note(chainId, index));
-        },
-        /**
-         * List notes matching optional filters (by chainId, mpk) and spent state.
-         */
-        async listNotes(options = {}) {
-            const { chainId, mpk, token, includeSpent = true } = options;
-            const prefix = chainId !== undefined ? `notes:${chainId}:` : "notes:";
-            const entries = await storage.iter({ prefix });
-            const filtered = entries
-                .map(({ value }) => decodeJson(value))
-                .filter((note) => (chainId === undefined || note.chainId === chainId) &&
-                (mpk === undefined || note.mpk === mpk) &&
-                (token === undefined || note.token === token) &&
-                (includeSpent || note.spentAt === undefined));
-            filtered.sort((a, b) => a.index - b.index);
-            return filtered;
-        },
-        /**
-         * Mark a cached note as spent by setting its timestamp and transaction hash.
-         */
-        async markNoteSpent(chainId, index, spentAt = Date.now(), spentTxHash) {
-            const existing = await store.getNote(chainId, index);
-            if (!existing) {
-                throw new CoreError("note not found");
-            }
-            if (existing.spentAt === spentAt &&
-                existing.spentTxHash === spentTxHash) {
-                return existing;
-            }
-            const updated = { ...existing, spentAt, spentTxHash };
-            await persistNote(updated);
-            return updated;
-        },
-        /**
-         * Drop the spent marker from a cached note, returning it to the unspent index.
-         */
-        async markNoteUnspent(chainId, index) {
-            const existing = await store.getNote(chainId, index);
-            if (!existing) {
-                throw new CoreError("note not found");
-            }
-            if (existing.spentAt === undefined) {
-                return existing;
-            }
-            const updated = { ...existing };
-            delete updated.spentAt;
-            await persistNote(updated);
-            return updated;
-        },
-        /**
-         * Remove all cached notes and their unspent indices for a chain.
-         */
-        async clearNotes(chainId) {
-            const notePrefix = `notes:${chainId}:`;
-            const noteEntries = await storage.iter({ prefix: notePrefix });
-            // Also clear unspent indices for this chain (all mpks)
-            const unspentPrefix = `idx:notes:unspent:${chainId}:`;
-            const unspentEntries = await storage.iter({ prefix: unspentPrefix });
-            if (noteEntries.length === 0 && unspentEntries.length === 0)
-                return;
-            const deletions = [
-                ...noteEntries.map(({ key }) => ({ del: key })),
-                ...unspentEntries.map(({ key }) => ({ del: key })),
-            ];
-            await storage.batch(deletions);
-        },
-    };
-    return store;
-}

package/dist/state/store/nullifier-store.js

@@ -1,60 +0,0 @@
-import { keys } from "../../keys.js";
-import { getJson, putJson } from "../../utils/json-codec.js";
-import { ensureChainId } from "../../utils/validators.js";
-export function createNullifierStore(storage) {
-    return {
-        /**
-         * Record a nullifier observation so later syncs can de-duplicate work.
-         */
-        async putNullifier(nullifier) {
-            ensureChainId(nullifier.chainId);
-            await putJson(storage, keys.nullifier(nullifier.chainId, nullifier.nullifier), nullifier);
-        },
-        /**
-         * Lookup a previously observed nullifier by value.
-         */
-        async getNullifier(chainId, value) {
-            return getJson(storage, keys.nullifier(chainId, value));
-        },
-        /**
-         * Count all nullifiers stored locally for a given chain.
-         */
-        async countNullifiers(chainId) {
-            const prefix = `nullifiers:${chainId}:`;
-            const entries = await storage.iter({ prefix });
-            return entries.length;
-        },
-        /**
-         * Remove all cached nullifiers for a chain.
-         */
-        async clearNullifiers(chainId) {
-            const prefix = `nullifiers:${chainId}:`;
-            const entries = await storage.iter({ prefix });
-            if (entries.length === 0)
-                return;
-            await storage.batch(entries.map(({ key }) => ({ del: key })));
-        },
-        /**
-         * Remove cached nullifiers whose noteIndex >= fromIndex.
-         * Used by partial resync to keep the count-based optimization accurate.
-         */
-        async clearNullifiersFromIndex(chainId, fromIndex) {
-            const prefix = `nullifiers:${chainId}:`;
-            const entries = await storage.iter({ prefix });
-            const ops = [];
-            for (const { key, value } of entries) {
-                try {
-                    const record = JSON.parse(new TextDecoder().decode(value));
-                    if (record.noteIndex === undefined || record.noteIndex >= fromIndex) {
-                        ops.push({ del: key });
-                    }
-                }
-                catch {
-                    // Malformed entry — skip
-                }
-            }
-            if (ops.length > 0)
-                await storage.batch(ops);
-        },
-    };
-}

package/dist/state/store/records.js

@@ -1 +0,0 @@
-export {};

package/dist/state/store/root-store.js

@@ -1,26 +0,0 @@
-import { CoreError } from "../../errors.js";
-import { keys, validateKey } from "../../keys.js";
-import { getJson, putJson } from "../../utils/json-codec.js";
-import { ensureChainId } from "../../utils/validators.js";
-export function createRootStore(storage) {
-    return {
-        /**
-         * Persist a historical root snapshot for proof generation.
-         */
-        async putRoot(root) {
-            ensureChainId(root.chainId);
-            if (typeof root.root !== "string" || root.root.length === 0) {
-                throw new CoreError("root value must be a non-empty string");
-            }
-            const key = keys.root(root.chainId, root.root);
-            validateKey(key);
-            await putJson(storage, key, root);
-        },
-        /**
-         * Retrieve a root snapshot by Merkle root value.
-         */
-        async getRoot(chainId, value) {
-            return getJson(storage, keys.root(chainId, value));
-        },
-    };
-}