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

package/dist/keys/derive.js

@@ -1,112 +0,0 @@
-/**
- * Key derivation for Unlink wallets using SLIP-10.
- *
- * SLIP-10 is a standard for BIP-32-style HD key derivation on non-secp256k1 curves.
- * We use "babyjubjub seed" as the curve identifier (standard convention: "<curve> seed").
- *
- * Derivation paths (BIP-44 style):
- * - Spending: m/44'/1984'/0'/0'/{index}'
- * - Viewing:  m/420'/1984'/0'/0'/{index}'
- *
- * @see https://github.com/satoshilabs/slips/blob/master/slip-0010.md
- */
-import { getPublicKey, hashes } from "@noble/ed25519";
-import { hmac } from "@noble/hashes/hmac.js";
-import { sha512 } from "@noble/hashes/sha2.js";
-import { deriveSpendingPublicKey, poseidon } from "../crypto-adapters/index.js";
-import { ValidationError } from "../errors.js";
-import { Hex } from "./hex.js";
-// Configure ed25519 to use sha512
-hashes.sha512 = sha512;
-hashes.sha512Async = async (m) => sha512(m);
-// SLIP-10 curve identifier (convention: "<curve> seed")
-const CURVE_SEED = new TextEncoder().encode("babyjubjub seed");
-// BIP-44 paths: m/purpose'/coin_type'/account'/change'/{index}'
-// 1984 = coin type for Unlink
-const SPENDING_PATH = [44, 1984, 0, 0]; // + index
-const VIEWING_PATH = [420, 1984, 0, 0]; // + index
-/**
- * SLIP-10 master key derivation from seed.
- * I = HMAC-SHA512(Key = curve_seed, Data = seed)
- * Returns left 32 bytes as key, right 32 bytes as chain code.
- */
-function deriveMasterKey(seed) {
-    const I = hmac(sha512, CURVE_SEED, seed);
-    return {
-        key: I.slice(0, 32),
-        chainCode: I.slice(32, 64),
-    };
-}
-/**
- * SLIP-10 hardened child key derivation.
- * For hardened keys (index >= 0x80000000), we use:
- * I = HMAC-SHA512(Key = chainCode, Data = 0x00 || key || index)
- */
-function deriveHardenedChild(key, chainCode, index) {
-    // Data = 0x00 || key (32 bytes) || index (4 bytes, big-endian)
-    const data = new Uint8Array(37);
-    data[0] = 0x00;
-    data.set(key, 1);
-    // Hardened index: original index + 0x80000000
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    view.setUint32(33, 0x80000000 + index, false); // big-endian
-    const I = hmac(sha512, chainCode, data);
-    return {
-        key: I.slice(0, 32),
-        chainCode: I.slice(32, 64),
-    };
-}
-/**
- * Derive a key by traversing a BIP-32 path (all hardened).
- */
-function deriveKeyFromPath(seed, path) {
-    let { key, chainCode } = deriveMasterKey(seed);
-    for (const index of path) {
-        ({ key, chainCode } = deriveHardenedChild(key, chainCode, index));
-    }
-    return key;
-}
-/**
- * Derive spending key pair (BabyJubJub) for an account.
- */
-export function deriveSpendingKeyPair(seed, index) {
-    const path = [...SPENDING_PATH, index];
-    const privateKey = deriveKeyFromPath(seed, path);
-    const pubkey = deriveSpendingPublicKey(privateKey);
-    return { privateKey, pubkey };
-}
-/**
- * Derive viewing key pair (Ed25519) for an account.
- */
-export async function deriveViewingKeyPair(seed, index) {
-    const path = [...VIEWING_PATH, index];
-    const privateKey = deriveKeyFromPath(seed, path);
-    const pubkey = await getPublicKey(privateKey);
-    return { privateKey, pubkey };
-}
-/**
- * Compute nullifying key from viewing private key using Poseidon hash.
- */
-export function computeNullifyingKey(viewingPrivateKey) {
-    if (viewingPrivateKey.length !== 32) {
-        throw new ValidationError("Viewing private key must be 32 bytes");
-    }
-    return poseidon([Hex.toBigInt(Hex.fromBytes(viewingPrivateKey))]);
-}
-/**
- * Compute master public key from spending public key and nullifying key.
- * MPK = Poseidon(spendingPubkey[0], spendingPubkey[1], nullifyingKey)
- */
-export function computeMasterPublicKey(spendingPubkey, nullifyingKey) {
-    return poseidon([...spendingPubkey, nullifyingKey]);
-}
-/**
- * Derive all account keys from a seed.
- */
-export async function deriveAccountKeys(seed, index) {
-    const spending = deriveSpendingKeyPair(seed, index);
-    const viewing = await deriveViewingKeyPair(seed, index);
-    const nullifyingKey = computeNullifyingKey(viewing.privateKey);
-    const masterPublicKey = computeMasterPublicKey(spending.pubkey, nullifyingKey);
-    return { spending, viewing, nullifyingKey, masterPublicKey };
-}

package/dist/keys/hex.js

@@ -1,66 +0,0 @@
-import { ValidationError } from "../errors.js";
-export var FieldSize;
-(function (FieldSize) {
-    FieldSize[FieldSize["SCALAR"] = 32] = "SCALAR";
-    FieldSize[FieldSize["SEED"] = 64] = "SEED";
-})(FieldSize || (FieldSize = {}));
-const HEX_REGEX = /^[0-9a-f]*$/i;
-export class Hex {
-    static strip(value) {
-        return value.startsWith("0x") ? value.slice(2) : value;
-    }
-    static encode(data) {
-        if (typeof data === "string")
-            return Hex.strip(data).toLowerCase();
-        if (typeof data === "number" || typeof data === "bigint") {
-            if (data < 0)
-                throw new ValidationError("Cannot hexlify negative values");
-            const hex = data.toString(16);
-            return hex.length % 2 === 0 ? hex : `0${hex}`;
-        }
-        return Hex.fromBytes(data instanceof Uint8Array ? data : Uint8Array.from(data));
-    }
-    static fromBytes(bytes) {
-        return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-    }
-    static toBytes(hex) {
-        const h = Hex.strip(hex).toLowerCase();
-        if (h.length % 2 !== 0)
-            throw new ValidationError("Hex string must have an even length");
-        if (!HEX_REGEX.test(h))
-            throw new ValidationError("Invalid hex string");
-        return Uint8Array.from({ length: h.length / 2 }, (_, i) => parseInt(h.slice(i * 2, i * 2 + 2), 16));
-    }
-    static decode(data) {
-        if (data instanceof Uint8Array)
-            return new Uint8Array(data);
-        if (typeof data === "string")
-            return Hex.toBytes(data);
-        if (typeof data === "number" || typeof data === "bigint")
-            return Hex.toBytes(Hex.encode(data));
-        return Uint8Array.from(data);
-    }
-    static toBigInt(hex) {
-        return BigInt(`0x${Hex.strip(hex)}`);
-    }
-    static pad(data, bytes, side = "left") {
-        const hex = Hex.encode(data);
-        const target = bytes * 2;
-        if (hex.length > target)
-            throw new ValidationError("Cannot pad data that exceeds target length");
-        return side === "left"
-            ? hex.padStart(target, "0")
-            : hex.padEnd(target, "0");
-    }
-    static padToSize(data, size) {
-        const hex = Hex.encode(data);
-        const target = size * 2;
-        return hex.length > target
-            ? hex.slice(0, target)
-            : hex.padStart(target, "0");
-    }
-    static fromBigInt(value, size, prefix = false) {
-        const hex = value.toString(16).padStart(size * 2, "0");
-        return prefix ? `0x${hex}` : hex;
-    }
-}

package/dist/keys/index.js

@@ -1,4 +0,0 @@
-export { Mnemonic } from "./mnemonic.js";
-export { deriveAccountKeys, deriveSpendingKeyPair, deriveViewingKeyPair, computeNullifyingKey, computeMasterPublicKey, } from "./derive.js";
-export { encodeAddress, decodeAddress, } from "./address.js";
-export { Hex, FieldSize } from "./hex.js";

package/dist/keys/mnemonic.js

@@ -1,23 +0,0 @@
-import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, mnemonicToSeedSync, validateMnemonic, } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { Hex } from "./hex.js";
-export class Mnemonic {
-    static generate(strength = 128) {
-        return generateMnemonic(wordlist, strength);
-    }
-    static validate(mnemonic) {
-        return validateMnemonic(mnemonic, wordlist);
-    }
-    static toSeed(mnemonic, password = "") {
-        const seed = mnemonicToSeedSync(mnemonic, password);
-        return Hex.fromBytes(seed);
-    }
-    static toEntropy(mnemonic) {
-        const entropy = mnemonicToEntropy(mnemonic, wordlist);
-        return Hex.fromBytes(entropy);
-    }
-    static fromEntropy(entropyHex) {
-        const entropy = Hex.toBytes(entropyHex);
-        return entropyToMnemonic(entropy, wordlist);
-    }
-}

package/dist/keys.js

@@ -1,45 +0,0 @@
-import { KeyValidationError } from "./errors.js";
-export const RESERVED_PREFIXES = [
-    "meta:",
-    "history:",
-    "notes:",
-    "leaves:",
-    "roots:",
-    "nullifiers:",
-    "ciphertexts:",
-    "jobs:",
-    "proof_cache:",
-    "cfg:",
-    "idx:",
-    "locks:",
-];
-/** Canonical builders for storage key namespaces used across core */
-export const keys = {
-    note: (c, i) => `notes:${c}:${i}`,
-    historyEntry: (id) => `history:${id}`,
-    historyPrefix: (chainId, mpk) => `history:${chainId}:${mpk}:`,
-    historyMeta: (chainId, mpk) => `history:${chainId}:${mpk}:__meta__`,
-    leaf: (c, i) => `leaves:${c}:${i}`,
-    ciphertext: (c, i) => `ciphertexts:${c}:${i}`,
-    /** Track note indices that remain unspent for a given master public key (mpk acts as the account identifier). */
-    unspent: (c, mpk, i) => `idx:notes:unspent:${c}:${mpk}:${i}`,
-    unspentPrefix: (c, mpk) => `idx:notes:unspent:${c}:${mpk}:`,
-    nullifierObs: (c, n) => `nullifiers:${c}:${n}`,
-    nullToIndex: (c, n) => `idx:nullifier:${c}:${n}`,
-    nullifier: (c, n) => `nullifiers:${c}:${n}`,
-    root: (c, value) => `roots:${c}:${value}`,
-    latestRoot: (c) => `roots:latest:${c}`,
-    rootCursor: (c) => `meta:roots:cursor:${c}`,
-    cursor: (c) => `meta:sync:cursors:${c}`,
-    aggregate: (c, a) => `idx:notes:agg:${c}:${a}`,
-    job: (relayId) => `jobs:${relayId}`,
-};
-export const MAX_KEY_LEN = 512;
-export function validateKey(key) {
-    if (!key)
-        throw new KeyValidationError("key must not be empty");
-    if (key.length > MAX_KEY_LEN)
-        throw new KeyValidationError(`key exceeds ${MAX_KEY_LEN}`);
-    if (!RESERVED_PREFIXES.some((p) => key.startsWith(p)))
-        throw new KeyValidationError("key must start with a reserved namespace prefix");
-}

package/dist/prover/config.js

@@ -1,70 +0,0 @@
-/**
- * Configuration for the prover system
- * Handles artifact loading from local files or remote artifact server
- */
-/**
- * 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) {
-    // 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,291 +0,0 @@
-import * as snarkjs from "snarkjs";
-import { ProofError } from "../errors.js";
-import { ArtifactType, buildArtifactUrl, 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 ProofError if no matching circuit is found
- */
-function selectCircuit(inputs, outputs) {
-    const config = getCircuitConfig(inputs, outputs);
-    if (!config) {
-        throw new ProofError(`No circuit available for ${inputs} inputs and ${outputs} outputs. ` +
-            `Supported circuits: ${SUPPORTED_CIRCUITS.join(", ")}`);
-    }
-    return config;
-}
-/**
- * Fetch circuit artifacts from server or local files (for tests)
- * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
- * @param rpcUrl Base URL for fetching artifacts
- * @returns Artifacts object with wasm, zkey, and vkey
- */
-async function fetchCircuitArtifacts(circuitName, rpcUrl) {
-    // Check cache first
-    if (artifactCache[circuitName]) {
-        return artifactCache[circuitName];
-    }
-    // Browser: always requires rpcUrl and fetches from server
-    if (Runtime.isBrowser()) {
-        if (!rpcUrl) {
-            throw new ProofError("rpcUrl is required. Please configure it via UnlinkProvider or pass it to the SDK.");
-        }
-        return fetchFromServer(circuitName, rpcUrl);
-    }
-    // Node.js: try server first if rpcUrl provided, fall back to local files
-    if (rpcUrl) {
-        try {
-            return await fetchFromServer(circuitName, rpcUrl);
-        }
-        catch {
-            // Server not available, fall back to local files (useful for tests)
-        }
-    }
-    // Node.js: try local files (for tests and development)
-    try {
-        return await fetchFromLocalFiles(circuitName);
-    }
-    catch {
-        throw new ProofError("rpcUrl is required. Local artifacts not found. " +
-            "If running tests, ensure artifacts are built with 'pnpm run zk:build'.");
-    }
-}
-async function fetchFromServer(circuitName, rpcUrl) {
-    const wasmUrl = buildArtifactUrl(circuitName, ArtifactType.WASM, rpcUrl);
-    const zkeyUrl = buildArtifactUrl(circuitName, ArtifactType.ZKEY, rpcUrl);
-    const vkeyUrl = buildArtifactUrl(circuitName, ArtifactType.VKEY, rpcUrl);
-    const [wasmRes, zkeyRes, vkeyRes] = await Promise.all([
-        fetch(wasmUrl),
-        fetch(zkeyUrl),
-        fetch(vkeyUrl),
-    ]);
-    if (!wasmRes.ok || !zkeyRes.ok || !vkeyRes.ok) {
-        throw new ProofError(`Failed to fetch artifacts for ${circuitName} from ${rpcUrl}. ` +
-            `Status: wasm=${wasmRes.status}, zkey=${zkeyRes.status}, vkey=${vkeyRes.status}`);
-    }
-    const wasm = new Uint8Array(await wasmRes.arrayBuffer());
-    const zkey = new Uint8Array(await zkeyRes.arrayBuffer());
-    const vkey = (await vkeyRes.json());
-    const artifacts = { wasm, zkey, vkey };
-    artifactCache[circuitName] = artifacts;
-    return artifacts;
-}
-async function fetchFromLocalFiles(circuitName) {
-    const wasmCandidates = getLocalArtifactPath(circuitName, ArtifactType.WASM);
-    const zkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.ZKEY);
-    const vkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.VKEY);
-    let wasm;
-    let zkey;
-    let 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 ProofError(`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 ProofError(`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 ProofError(`Could not find verification key for ${circuitName}. ` +
-            `Please run 'pnpm run build:all' in the circuits package.`);
-    }
-    // Cache the artifacts for future calls
-    // TypeScript now knows these are defined after the check above
-    const artifacts = { wasm: wasm, zkey: zkey, vkey: 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 ProofError(`failed to fetch ${relativePath}: ${response.statusText}`);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    catch (error) {
-        throw new ProofError(`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 ProofError(`failed to fetch ${relativePath}: ${response.statusText}`);
-    }
-    return response.text();
-}
-export async function proveTransaction(input, options) {
-    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, options?.rpcUrl);
-        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 ProofError("generated proof is invalid");
-        }
-        return {
-            proof,
-            publicSignals,
-        };
-    }
-    catch (error) {
-        throw new ProofError("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)
- * @param options Configuration including rpcUrl
- * @returns Verification key for the circuit
- */
-export async function getVerificationKey(inputs, outputs, options) {
-    try {
-        const circuit = selectCircuit(inputs, outputs);
-        const { vkey } = await fetchCircuitArtifacts(circuit.name, options?.rpcUrl);
-        return vkey;
-    }
-    catch (error) {
-        throw new ProofError("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
- * @param options Optional configuration including rpcUrl
- * @returns True if proof is valid
- */
-export async function verifyProof(proof, publicSignals, options) {
-    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, options?.rpcUrl);
-                vkey = artifacts.vkey;
-                break;
-            }
-        }
-        if (!vkey) {
-            throw new ProofError(`Could not determine circuit from ${totalLength} public signals`);
-        }
-        return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-    }
-    catch (error) {
-        throw new ProofError("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)
- * @param options Optional configuration including rpcUrl
- * @returns True if proof is valid
- */
-export async function verifyProofWithCircuit(proof, publicSignals, inputs, outputs, options) {
-    try {
-        const circuit = selectCircuit(inputs, outputs);
-        const { vkey } = await fetchCircuitArtifacts(circuit.name, options?.rpcUrl);
-        return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-    }
-    catch (error) {
-        throw new ProofError("proof verification failed: " + error.message);
-    }
-}

package/dist/prover/registry.js

@@ -1,18 +0,0 @@
-import circuitsJson from "../circuits.json" with { type: "json" };
-// Build registry from circuits.json — keyed by "NxM" (inputs x outputs)
-const registry = {};
-for (const [name, def] of Object.entries(circuitsJson)) {
-    const params = def.params;
-    const inputs = params[0];
-    const outputs = params[1];
-    const depth = params[2];
-    registry[`${inputs}x${outputs}`] = { name, inputs, outputs, depth };
-}
-export const CIRCUIT_REGISTRY = registry;
-export const SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY);
-export function getCircuitConfig(inputs, outputs) {
-    return CIRCUIT_REGISTRY[`${inputs}x${outputs}`];
-}
-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/index.js

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