@unlink-xyz/core 0.1.0 → 0.1.3-canary.01ac52d

package/dist/prover/config.js

@@ -1,80 +0,0 @@
-/**
- * Configuration for the prover system
- * Handles artifact loading from local files or remote artifact server
- */
-/**
- * Default configuration
- * Can be overridden via environment variables
- */
-export const DEFAULT_CONFIG = {
-    rpcUrl: typeof process !== "undefined" && process.env?.UNLINK_RPC_URL
-        ? process.env.UNLINK_RPC_URL
-        : "http://localhost:3000",
-    enableCache: true,
-};
-/**
- * Artifact file types
- */
-export var ArtifactType;
-(function (ArtifactType) {
-    ArtifactType["WASM"] = "joinsplit.wasm";
-    ArtifactType["ZKEY"] = "joinsplit.zkey";
-    ArtifactType["VKEY"] = "joinsplit.vkey.json";
-})(ArtifactType || (ArtifactType = {}));
-/**
- * Build artifact URL for a given circuit and artifact type
- * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
- * @param artifactType Type of artifact to fetch
- * @param baseUrl Base URL of the artifact server
- * @returns Full URL to the artifact
- */
-export function buildArtifactUrl(circuitName, artifactType, baseUrl = DEFAULT_CONFIG.rpcUrl) {
-    // Remove trailing slash from baseUrl
-    const cleanBaseUrl = baseUrl.replace(/\/$/, "");
-    return `${cleanBaseUrl}/artifacts/${circuitName}/${artifactType}`;
-}
-/**
- * Get relative path for local artifact loading
- * Used in Node.js environment when artifacts are bundled
- * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
- * @param artifactType Type of artifact
- * @returns Relative path to artifact
- */
-export function getLocalArtifactPath(circuitName, artifactType) {
-    // Return multiple candidate paths for different build scenarios
-    return [
-        // When compiled: dist/prover/ -> ../../artifacts/circuits/{circuit}/
-        `../../artifacts/circuits/${circuitName}/${artifactType}`,
-        // When in source: prover/ -> ../artifacts/circuits/{circuit}/
-        `../artifacts/circuits/${circuitName}/${artifactType}`,
-    ];
-}
-/**
- * Runtime detection utilities
- */
-export const Runtime = {
-    /**
-     * Check if running in browser environment
-     */
-    isBrowser() {
-        return typeof window !== "undefined" && typeof document !== "undefined";
-    },
-    /**
-     * Check if running in Node.js environment
-     */
-    isNode() {
-        return (typeof process !== "undefined" &&
-            process.versions != null &&
-            process.versions.node != null);
-    },
-    /**
-     * Get environment description for debugging
-     */
-    getEnvironment() {
-        if (this.isBrowser())
-            return "browser";
-        if (this.isNode())
-            return "node";
-        return "unknown";
-    },
-};

package/dist/prover/index.js

@@ -1 +0,0 @@
-export * from "./prover.js";

package/dist/prover/prover.js

@@ -1,274 +0,0 @@
-import * as snarkjs from "snarkjs";
-import { CoreError } from "../errors.js";
-import { ArtifactType, buildArtifactUrl, DEFAULT_CONFIG, getLocalArtifactPath, Runtime, } from "./config.js";
-import { getCircuitConfig, SUPPORTED_CIRCUITS, } from "./registry.js";
-// Cache for loaded artifacts to avoid reloading 18MB of files on every call
-// Now keyed by circuit name to support multiple circuits
-const artifactCache = {};
-/**
- * Select the appropriate circuit based on input/output dimensions
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns Circuit configuration
- * @throws CoreError if no matching circuit is found
- */
-function selectCircuit(inputs, outputs) {
-    const config = getCircuitConfig(inputs, outputs);
-    if (!config) {
-        throw new CoreError(`No circuit available for ${inputs} inputs and ${outputs} outputs. ` +
-            `Supported circuits: ${SUPPORTED_CIRCUITS.join(", ")}`);
-    }
-    return config;
-}
-/**
- * Fetch circuit artifacts for a specific circuit
- * Supports both browser (remote) and Node.js (local) environments
- * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
- * @returns Artifacts object with wasm, zkey, and vkey
- */
-async function fetchCircuitArtifacts(circuitName) {
-    // Check cache first
-    if (artifactCache[circuitName]) {
-        return artifactCache[circuitName];
-    }
-    let wasm;
-    let zkey;
-    let vkey;
-    // Browser environment: fetch from artifact server
-    if (Runtime.isBrowser()) {
-        try {
-            const baseUrl = DEFAULT_CONFIG.rpcUrl;
-            const wasmUrl = buildArtifactUrl(circuitName, ArtifactType.WASM, baseUrl);
-            const zkeyUrl = buildArtifactUrl(circuitName, ArtifactType.ZKEY, baseUrl);
-            const vkeyUrl = buildArtifactUrl(circuitName, ArtifactType.VKEY, baseUrl);
-            const [wasmRes, zkeyRes, vkeyRes] = await Promise.all([
-                fetch(wasmUrl),
-                fetch(zkeyUrl),
-                fetch(vkeyUrl),
-            ]);
-            if (!wasmRes.ok || !zkeyRes.ok || !vkeyRes.ok) {
-                throw new CoreError(`Failed to fetch artifacts for ${circuitName} from ${baseUrl}. ` +
-                    `Status: wasm=${wasmRes.status}, zkey=${zkeyRes.status}, vkey=${vkeyRes.status}`);
-            }
-            wasm = new Uint8Array(await wasmRes.arrayBuffer());
-            zkey = new Uint8Array(await zkeyRes.arrayBuffer());
-            vkey = await vkeyRes.json();
-        }
-        catch (error) {
-            throw new CoreError(`Failed to fetch artifacts from server for ${circuitName}: ${error.message}`);
-        }
-    }
-    // Node.js environment: try local file paths
-    else {
-        const wasmCandidates = getLocalArtifactPath(circuitName, ArtifactType.WASM);
-        const zkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.ZKEY);
-        const vkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.VKEY);
-        let wasmLoaded = false;
-        for (const candidate of wasmCandidates) {
-            try {
-                wasm = await readBinaryResource(candidate);
-                wasmLoaded = true;
-                break;
-            }
-            catch {
-                // Try next candidate
-            }
-        }
-        if (!wasmLoaded) {
-            throw new CoreError(`Could not find WASM artifact for ${circuitName}. ` +
-                `Please run 'pnpm run build:all' in the circuits package.`);
-        }
-        // Load zkey
-        let zkeyLoaded = false;
-        for (const candidate of zkeyCandidates) {
-            try {
-                zkey = await readBinaryResource(candidate);
-                zkeyLoaded = true;
-                break;
-            }
-            catch {
-                // Try next candidate
-            }
-        }
-        if (!zkeyLoaded) {
-            throw new CoreError(`Could not find zkey artifact for ${circuitName}. ` +
-                `Please run 'pnpm run build:all' in the circuits package.`);
-        }
-        // Load vkey
-        let vkeyLoaded = false;
-        for (const candidate of vkeyCandidates) {
-            try {
-                const vkeyText = await readTextResource(candidate);
-                vkey = JSON.parse(vkeyText);
-                vkeyLoaded = true;
-                break;
-            }
-            catch {
-                // Try next candidate
-            }
-        }
-        if (!vkeyLoaded) {
-            throw new CoreError(`Could not find verification key for ${circuitName}. ` +
-                `Please run 'pnpm run build:all' in the circuits package.`);
-        }
-    }
-    // Verify all artifacts were loaded
-    if (!wasm || !zkey || !vkey) {
-        throw new CoreError(`Failed to load all artifacts for ${circuitName}. ` +
-            `Missing: ${!wasm ? "wasm " : ""}${!zkey ? "zkey " : ""}${!vkey ? "vkey" : ""}`);
-    }
-    // Cache the artifacts for future calls
-    // TypeScript now knows these are defined after the check above
-    const artifacts = { wasm, zkey, vkey };
-    artifactCache[circuitName] = artifacts;
-    return artifacts;
-}
-async function readBinaryResource(relativePath) {
-    const url = new URL(relativePath, import.meta.url);
-    try {
-        if (url.protocol === "file:") {
-            const fs = (await import("fs")).default;
-            const readPromise = new Promise((resolve, reject) => {
-                fs.readFile(url.pathname, (err, data) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(data);
-                    }
-                });
-            });
-            const buf = await readPromise;
-            return new Uint8Array(buf);
-        }
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new CoreError(`failed to fetch ${relativePath}: ${response.statusText}`);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    catch (error) {
-        throw new CoreError(`failed to read binary resource ${relativePath}: ${error.message}`);
-    }
-}
-async function readTextResource(relativePath) {
-    const url = new URL(relativePath, import.meta.url);
-    if (url.protocol === "file:") {
-        const fs = (await import("fs")).default;
-        const readPromise = new Promise((resolve, reject) => {
-            fs.readFile(url.pathname, (err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
-        const buf = await readPromise;
-        return buf.toString("utf-8");
-    }
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new CoreError(`failed to fetch ${relativePath}: ${response.statusText}`);
-    }
-    return response.text();
-}
-export async function proveTransaction(input) {
-    try {
-        // Auto-detect circuit based on input dimensions
-        const nInputs = input.nullifiers.length;
-        const nOutputs = input.commitmentsOut.length;
-        const circuit = selectCircuit(nInputs, nOutputs);
-        // Fetch circuit artifacts (wasm and zkey)
-        const { wasm, vkey, zkey } = await fetchCircuitArtifacts(circuit.name);
-        const inputSignals = input;
-        const { proof, publicSignals } = await snarkjs.groth16.fullProve(inputSignals, wasm, zkey);
-        // Additional verification step (optional)
-        const isValid = await snarkjs.groth16.verify(vkey, publicSignals, proof);
-        if (!isValid) {
-            throw new CoreError("generated proof is invalid");
-        }
-        return {
-            proof,
-            publicSignals,
-        };
-    }
-    catch (error) {
-        throw new CoreError("proof generation failed: " + error.message);
-    }
-}
-/**
- * Get verification key for a specific circuit configuration
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns Verification key for the circuit
- */
-export async function getVerificationKey(inputs, outputs) {
-    try {
-        const circuit = selectCircuit(inputs, outputs);
-        const { vkey } = await fetchCircuitArtifacts(circuit.name);
-        return vkey;
-    }
-    catch (error) {
-        throw new CoreError("failed to load verification key: " + error.message);
-    }
-}
-/**
- * Verify a proof with public signals
- * Auto-detects the circuit from the public signals structure
- * @param proof Groth16 proof
- * @param publicSignals Public signals array
- * @returns True if proof is valid
- */
-export async function verifyProof(proof, publicSignals) {
-    try {
-        // Public signals structure: [merkleRoot, boundParamsHash, ...nullifiers, ...commitments]
-        // We need to determine the circuit from the length
-        // This is tricky without additional context, so we'll need to try to infer
-        // or require explicit circuit specification
-        // For now, extract nullifier and commitment counts from the public signals
-        // The caller should know this information, but we can make an educated guess
-        // based on the total length and circuit registry
-        // Length = 2 (root + hash) + nInputs + nOutputs
-        const totalLength = publicSignals.length;
-        const variableCount = totalLength - 2; // Remove merkleRoot and boundParamsHash
-        // Try to find a matching circuit
-        let vkey = null;
-        for (const circuitKey of SUPPORTED_CIRCUITS) {
-            const parts = circuitKey.split("x");
-            const config = getCircuitConfig(parseInt(parts[0]), parseInt(parts[1]));
-            if (config && config.inputs + config.outputs === variableCount) {
-                const artifacts = await fetchCircuitArtifacts(config.name);
-                vkey = artifacts.vkey;
-                break;
-            }
-        }
-        if (!vkey) {
-            throw new CoreError(`Could not determine circuit from ${totalLength} public signals`);
-        }
-        return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-    }
-    catch (error) {
-        throw new CoreError("proof verification failed: " + error.message);
-    }
-}
-/**
- * Verify a proof with explicit circuit specification
- * Preferred method when you know the circuit dimensions
- * @param proof Groth16 proof
- * @param publicSignals Public signals array
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns True if proof is valid
- */
-export async function verifyProofWithCircuit(proof, publicSignals, inputs, outputs) {
-    try {
-        const circuit = selectCircuit(inputs, outputs);
-        const { vkey } = await fetchCircuitArtifacts(circuit.name);
-        return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-    }
-    catch (error) {
-        throw new CoreError("proof verification failed: " + error.message);
-    }
-}

package/dist/prover/registry.js

@@ -1,57 +0,0 @@
-// AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
-// Generated by scripts/generate-registry.ts
-// Source: circuits/circuits.json
-// Generated at: 2025-11-25T13:26:58.576Z
-/**
- * Registry of available circuits
- * Auto-generated from circuits/circuits.json
- */
-export const CIRCUIT_REGISTRY = {
-    "3x3": {
-        name: "joinsplit_3x3_16",
-        inputs: 3,
-        outputs: 3,
-        depth: 16,
-    },
-    "2x3": {
-        name: "joinsplit_2x3_16",
-        inputs: 2,
-        outputs: 3,
-        depth: 16,
-    },
-    "1x2": {
-        name: "joinsplit_1x2_16",
-        inputs: 1,
-        outputs: 2,
-        depth: 16,
-    },
-    "1x1": {
-        name: "joinsplit_1x1_16",
-        inputs: 1,
-        outputs: 1,
-        depth: 16,
-    },
-};
-/**
- * Get list of all supported circuit keys
- */
-export const SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY);
-/**
- * Get circuit configuration by dimensions
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns Circuit configuration or undefined if not supported
- */
-export function getCircuitConfig(inputs, outputs) {
-    const key = `${inputs}x${outputs}`;
-    return CIRCUIT_REGISTRY[key];
-}
-/**
- * Check if a circuit configuration is supported
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns True if supported
- */
-export function isCircuitSupported(inputs, outputs) {
-    return getCircuitConfig(inputs, outputs) !== undefined;
-}

package/dist/schema.js

@@ -1,14 +0,0 @@
-import { SchemaMismatchError } from "./errors.js";
-export const CORE_SCHEMA_VERSION = 1;
-export async function migrate(storage) {
-    await storage.open();
-    const current = await storage.getSchemaVersion();
-    if (current === 0) {
-        // seed structures if needed
-        await storage.setSchemaVersion(CORE_SCHEMA_VERSION);
-        return;
-    }
-    if (current !== CORE_SCHEMA_VERSION) {
-        throw new SchemaMismatchError(current, CORE_SCHEMA_VERSION);
-    }
-}

package/dist/state/ciphertext-store.d.ts

@@ -1,12 +0,0 @@
-import type { Storage } from "../types.js";
-export declare function createCiphertextStore(storage: Storage): {
-    /**
-     * Store encrypted note payloads alongside their on-chain commitments.
-     */
-    putCiphertext(chainId: number, index: number, payload: Uint8Array): Promise<void>;
-    /**
-     * Retrieve encrypted note payloads; returns null when the ciphertext is missing.
-     */
-    getCiphertext(chainId: number, index: number): Promise<Uint8Array<ArrayBuffer> | null>;
-};
-//# sourceMappingURL=ciphertext-store.d.ts.map

package/dist/state/ciphertext-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ciphertext-store.d.ts","sourceRoot":"","sources":["../../state/ciphertext-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO;IAElD;;OAEG;2BAC0B,MAAM,SAAS,MAAM,WAAW,UAAU;IAQvE;;OAEG;2BAC0B,MAAM,SAAS,MAAM;EAOrD"}

package/dist/state/ciphertext-store.js

@@ -1,25 +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;
-        },
-    };
-}

package/dist/state/index.js

@@ -1,2 +0,0 @@
-export * from "./merkle/index.js";
-export * from "./store/index.js";

package/dist/state/leaf-store.d.ts

@@ -1,17 +0,0 @@
-import type { Storage } from "../types.js";
-import type { LeafRecord } from "./records.js";
-export declare function createLeafStore(storage: Storage): {
-    /**
-     * Cache public leaf data pulled from the on-chain Merkle tree.
-     */
-    putLeaf(leaf: LeafRecord): Promise<void>;
-    /**
-     * Load a leaf commitment by tree index.
-     */
-    getLeaf(chainId: number, index: number): Promise<LeafRecord | null>;
-    /**
-     * Remove all cached leaves for a chain.
-     */
-    clearLeaves(chainId: number): Promise<void>;
-};
-//# sourceMappingURL=leaf-store.d.ts.map

package/dist/state/leaf-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leaf-store.d.ts","sourceRoot":"","sources":["../../state/leaf-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO;IAE5C;;OAEG;kBACiB,UAAU;IAM9B;;OAEG;qBACoB,MAAM,SAAS,MAAM;IAM5C;;OAEG;yBACwB,MAAM;EASpC"}

package/dist/state/leaf-store.js

@@ -1,35 +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) {
-            ensureChainId(chainId);
-            ensurePositiveInt("leaf index", index);
-            return getJson(storage, keys.leaf(chainId, index));
-        },
-        /**
-         * Remove all cached leaves for a chain.
-         */
-        async clearLeaves(chainId) {
-            ensureChainId(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/merkle/hydrator.js

@@ -1,36 +0,0 @@
-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 Error(`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 Error("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, } from "./merkle-tree.js";
-export { hydrateChain, rebuildTreeFromStore, } from "./hydrator.js";

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

@@ -1,104 +0,0 @@
-import { poseidon } from "@railgun-community/circomlibjs";
-import { IMT, } from "@zk-kit/imt";
-import { ByteLength, ByteUtils } from "../../key-derivation/bytes.js";
-import { ensureChainId } from "../../utils/validators.js";
-const DEFAULT_DEPTH = 16;
-const DEFAULT_ARITY = 2;
-const ZERO_BYTE_LENGTH = ByteLength.UINT_256;
-// Simple adapter: IMTNode[] -> poseidon(bigint[])
-const hash = (values) => poseidon(values.map((v) => BigInt(v)));
-const formatNode = (value) => ByteUtils.nToHex(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 Error("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 Error("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 Error("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);
-        },
-    };
-}