@unlink-xyz/core 0.1.3 → 0.1.4

package/prover/registry.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  CIRCUIT_REGISTRY,
-  getCircuitConfig,
-  isCircuitSupported,
-  SUPPORTED_CIRCUITS,
-  type CircuitKey,
-} from "./registry.js";
-
-describe("Circuit Registry", () => {
-  it("should have all expected circuits", () => {
-    const expectedCircuits: CircuitKey[] = ["1x1", "1x2", "2x3", "3x3"];
-    expect(SUPPORTED_CIRCUITS).toEqual(
-      expect.arrayContaining(expectedCircuits),
-    );
-  });
-
-  it("should correctly map circuit keys to configurations", () => {
-    const config2x3 = CIRCUIT_REGISTRY["2x3"];
-    expect(config2x3).toBeDefined();
-    expect(config2x3.name).toBe("joinsplit_2x3_16");
-    expect(config2x3.inputs).toBe(2);
-    expect(config2x3.outputs).toBe(3);
-    expect(config2x3.depth).toBe(16);
-  });
-
-  describe("getCircuitConfig", () => {
-    it("should return config for valid circuit dimensions", () => {
-      const config = getCircuitConfig(2, 3);
-      expect(config).toBeDefined();
-      expect(config?.name).toBe("joinsplit_2x3_16");
-      expect(config?.inputs).toBe(2);
-      expect(config?.outputs).toBe(3);
-    });
-
-    it("should return undefined for unsupported dimensions", () => {
-      const config = getCircuitConfig(4, 5);
-      expect(config).toBeUndefined();
-    });
-
-    it("should handle all supported circuit dimensions", () => {
-      const testCases = [
-        { inputs: 1, outputs: 1, name: "joinsplit_1x1_16" },
-        { inputs: 1, outputs: 2, name: "joinsplit_1x2_16" },
-        { inputs: 2, outputs: 3, name: "joinsplit_2x3_16" },
-        { inputs: 3, outputs: 3, name: "joinsplit_3x3_16" },
-      ];
-
-      for (const testCase of testCases) {
-        const config = getCircuitConfig(testCase.inputs, testCase.outputs);
-        expect(config).toBeDefined();
-        expect(config?.name).toBe(testCase.name);
-        expect(config?.inputs).toBe(testCase.inputs);
-        expect(config?.outputs).toBe(testCase.outputs);
-      }
-    });
-  });
-
-  describe("isCircuitSupported", () => {
-    it("should return true for supported circuits", () => {
-      expect(isCircuitSupported(1, 1)).toBe(true);
-      expect(isCircuitSupported(1, 2)).toBe(true);
-      expect(isCircuitSupported(2, 3)).toBe(true);
-      expect(isCircuitSupported(3, 3)).toBe(true);
-    });
-
-    it("should return false for unsupported circuits", () => {
-      expect(isCircuitSupported(4, 4)).toBe(false);
-      expect(isCircuitSupported(0, 0)).toBe(false);
-      expect(isCircuitSupported(1, 3)).toBe(false);
-      expect(isCircuitSupported(2, 2)).toBe(false);
-    });
-  });
-
-  it("should have consistent registry entries", () => {
-    for (const [key, config] of Object.entries(CIRCUIT_REGISTRY)) {
-      // Key should match inputs x outputs
-      const [inputs, outputs] = key.split("x").map(Number);
-      expect(config.inputs).toBe(inputs);
-      expect(config.outputs).toBe(outputs);
-
-      // Name should contain the key
-      expect(config.name).toContain(`${inputs}x${outputs}`);
-
-      // Depth should be 16 for all current circuits
-      expect(config.depth).toBe(16);
-    }
-  });
-});

package/prover/registry.ts

@@ -1,82 +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
-
-/**
- * Circuit registry for automatic prover selection
- * Maps circuit dimensions (inputs x outputs) to circuit configurations
- */
-
-export interface CircuitConfig {
-  /** Full circuit name (e.g., "joinsplit_2x3_16") */
-  readonly name: string;
-  /** Number of inputs (nullifiers) */
-  readonly inputs: number;
-  /** Number of outputs (commitments) */
-  readonly outputs: number;
-  /** Merkle tree depth */
-  readonly depth: number;
-}
-
-export type CircuitKey = "3x3" | "2x3" | "1x2" | "1x1";
-
-/**
- * Registry of available circuits
- * Auto-generated from circuits/circuits.json
- */
-export const CIRCUIT_REGISTRY: Record<CircuitKey, CircuitConfig> = {
-  "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,
-  },
-} as const;
-
-/**
- * Get list of all supported circuit keys
- */
-export const SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY) as CircuitKey[];
-
-/**
- * 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: number,
-  outputs: number,
-): CircuitConfig | undefined {
-  const key = `${inputs}x${outputs}` as CircuitKey;
-  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: number, outputs: number): boolean {
-  return getCircuitConfig(inputs, outputs) !== undefined;
-}

package/schema.ts

@@ -1,17 +0,0 @@
-import { SchemaMismatchError } from "./errors.js";
-import type { Storage } from "./types.js";
-
-export const CORE_SCHEMA_VERSION = 1;
-
-export async function migrate(storage: 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/setup-artifacts.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-
-# Script to setup SDK artifacts from circuits build
-# Creates symlinks to avoid duplicating large files
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SDK_ARTIFACTS="$SCRIPT_DIR/artifacts/circuits"
-CIRCUITS_ARTIFACTS="$SCRIPT_DIR/../../circuits/artifacts"
-
-echo "Setting up SDK circuit artifacts..."
-echo "Source: $CIRCUITS_ARTIFACTS"
-echo "Target: $SDK_ARTIFACTS"
-
-mkdir -p "$SDK_ARTIFACTS"
-
-# Check if circuits artifacts exist
-if [ ! -d "$CIRCUITS_ARTIFACTS" ]; then
-    echo "❌ Error: Circuit artifacts not found at $CIRCUITS_ARTIFACTS"
-    echo "Please run 'pnpm run circuits:build' in the root directory first."
-    exit 1
-fi
-
-# Remove old flat structure if it exists
-if [ -f "$SDK_ARTIFACTS/joinsplit.wasm" ]; then
-    echo "Removing old artifact structure..."
-    rm -f "$SDK_ARTIFACTS/joinsplit.wasm"
-    rm -f "$SDK_ARTIFACTS/joinsplit.zkey"
-    rm -f "$SDK_ARTIFACTS/joinsplit.vkey.json"
-fi
-
-# Create circuit-specific directories and symlink artifacts
-for circuit_dir in "$CIRCUITS_ARTIFACTS"/*; do
-    if [ -d "$circuit_dir" ]; then
-        circuit_name=$(basename "$circuit_dir")
-        target_dir="$SDK_ARTIFACTS/$circuit_name"
-
-        echo "Setting up $circuit_name..."
-
-        # Create target directory
-        mkdir -p "$target_dir"
-
-        # Create symlinks
-        ln -sf "$circuit_dir/joinsplit.wasm" "$target_dir/joinsplit.wasm"
-        ln -sf "$circuit_dir/joinsplit.zkey" "$target_dir/joinsplit.zkey"
-        ln -sf "$circuit_dir/joinsplit.vkey.json" "$target_dir/joinsplit.vkey.json"
-
-        echo "  ✓ Linked $circuit_name artifacts"
-    fi
-done
-
-echo ""
-echo "✓ SDK artifacts setup complete!"
-echo ""
-echo "Available circuits:"
-ls -1 "$SDK_ARTIFACTS"

package/state/index.ts

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

package/state/merkle/hydrator.ts

@@ -1,69 +0,0 @@
-import { parseHexToBigInt } from "../../utils/bigint.js";
-
-export type LeafLoader = (
-  chainId: number,
-  index: number,
-) => Promise<{ commitment: string } | null>;
-
-export async function rebuildTreeFromStore({
-  chainId,
-  trees,
-  loadLeaf,
-}: {
-  chainId: number;
-  trees: {
-    reset(chainId: number): void;
-    addLeaf(chainId: number, value: bigint): { index: number };
-    getLeafCount?(chainId: number): number;
-  };
-  loadLeaf: LeafLoader;
-}) {
-  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;
-}
-
-export type HydrateChainParams = {
-  chainId: number;
-  trees: {
-    reset(chainId: number): void;
-    addLeaf(chainId: number, value: bigint): { index: number };
-  };
-  loadLeaf: LeafLoader;
-  hydrated: Set<number>;
-};
-
-// 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,
-}: HydrateChainParams) {
-  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/state/merkle/index.ts

@@ -1,12 +0,0 @@
-export {
-  createLocalMerkleTree,
-  createMerkleTrees,
-  type LocalMerkleTree,
-  type LocalMerkleTrees,
-  type MerkleProof,
-} from "./merkle-tree.js";
-export {
-  hydrateChain,
-  rebuildTreeFromStore,
-  type HydrateChainParams,
-} from "./hydrator.js";

package/state/merkle/merkle-tree.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createLocalMerkleTree } from "./merkle-tree.js";
-
-describe("local merkle tree", () => {
-  it("returns deterministic roots for identical insert sequences", () => {
-    const inserts = [0x01n, 0x02n, 0x03n];
-
-    const treeA = createLocalMerkleTree();
-    const rootsA = inserts.map((leaf) => treeA.addLeaf(leaf).root);
-
-    const treeB = createLocalMerkleTree();
-    const rootsB = inserts.map((leaf) => treeB.addLeaf(leaf).root);
-
-    expect(rootsA).toEqual(rootsB);
-    expect(treeA.getRoot()).toBe(treeB.getRoot());
-  });
-
-  it("tracks inserted leaf count and updates root", () => {
-    const tree = createLocalMerkleTree();
-    const initialRoot = tree.getRoot();
-
-    const first = tree.addLeaf(1n);
-    expect(tree.getLeafCount()).toBe(1);
-    expect(first.index).toBe(0);
-    expect(first.root).not.toBe(initialRoot);
-
-    const second = tree.addLeaf(0x02n);
-    expect(tree.getLeafCount()).toBe(2);
-    expect(second.index).toBe(1);
-    expect(second.root).not.toBe(first.root);
-  });
-
-  it("exposes zero hashes for valid levels and rejects invalid ones", () => {
-    const tree = createLocalMerkleTree();
-
-    expect(tree.getZero(0)).toMatch(/^0x[0-9a-f]+$/);
-    expect(() => tree.getZero(-1)).toThrow("invalid level");
-    expect(() => tree.getZero(tree.depth + 1)).toThrow("invalid level");
-  });
-
-  it("starts with zero root until the first insert", () => {
-    const tree = createLocalMerkleTree();
-    const emptyRoot = tree.getRoot();
-
-    expect(emptyRoot).toBe(tree.getZero(tree.depth));
-    tree.addLeaf(5n);
-    expect(tree.getRoot()).not.toBe(emptyRoot);
-  });
-});

package/state/merkle/merkle-tree.ts

@@ -1,163 +0,0 @@
-import { poseidon } from "@railgun-community/circomlibjs";
-import {
-  IMT,
-  IMTMerkleProof,
-  type IMTHashFunction,
-  type IMTNode,
-} from "@zk-kit/imt";
-
-import { ByteLength, ByteUtils } from "../../key-derivation/bytes.js";
-import { ensureChainId } from "../../utils/validators.js";
-
-type BigIntTree = IMT & {
-  root: bigint;
-  zeroes: bigint[];
-  leaves: bigint[];
-};
-
-export type AddLeafResult = {
-  index: number;
-  root: string;
-};
-
-export type MerkleProof = {
-  root: string;
-  leaf: string;
-  pathElements: string[][];
-  pathIndices: number[];
-  leafIndex: number;
-};
-
-const DEFAULT_DEPTH = 16;
-const DEFAULT_ARITY = 2;
-const ZERO_BYTE_LENGTH = ByteLength.UINT_256;
-
-// Simple adapter: IMTNode[] -> poseidon(bigint[])
-const hash: IMTHashFunction = (values: IMTNode[]) =>
-  poseidon(values.map((v) => BigInt(v)));
-
-const formatNode = (value: bigint) =>
-  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,
-  ) as BigIntTree;
-
-  function addLeaf(value: bigint): AddLeafResult {
-    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: number) {
-    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: number): IMTMerkleProof {
-    return tree.createProof(index);
-  }
-
-  return {
-    addLeaf,
-    getRoot,
-    getLeafCount,
-    getLeaf,
-    createMerkleProof,
-    getZero(level: number) {
-      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 type LocalMerkleTree = ReturnType<typeof createLocalMerkleTree>;
-
-export type LocalMerkleTrees = {
-  get(chainId: number): LocalMerkleTree | undefined;
-  getOrCreate(chainId: number): LocalMerkleTree;
-  addLeaf(chainId: number, value: bigint): AddLeafResult;
-  createMerkleProof(chainId: number, index: number): IMTMerkleProof;
-  getRoot(chainId: number): string;
-  getLeafCount(chainId: number): number;
-  reset(chainId: number): void;
-};
-
-export function createMerkleTrees(): LocalMerkleTrees {
-  const trees = new Map<number, LocalMerkleTree>();
-
-  const resetTree = (chainId: number) => {
-    ensureChainId(chainId);
-    const tree = createLocalMerkleTree();
-    trees.set(chainId, tree);
-    return tree;
-  };
-  const getOrCreate = (chainId: number) => {
-    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);
-    },
-  };
-}

package/state/store/ciphertext-store.ts

@@ -1,28 +0,0 @@
-import { keys, validateKey } from "../../keys.js";
-import type { Storage } from "../../types.js";
-import { ensureChainId, ensurePositiveInt } from "../../utils/validators.js";
-
-export function createCiphertextStore(storage: Storage) {
-  return {
-    /**
-     * Store encrypted note payloads alongside their on-chain commitments.
-     */
-    async putCiphertext(chainId: number, index: number, payload: Uint8Array) {
-      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: number, index: number) {
-      ensureChainId(chainId);
-      ensurePositiveInt("ciphertext index", index);
-      const data = await storage.get(keys.ciphertext(chainId, index));
-      return data ? new Uint8Array(data) : null;
-    },
-  };
-}

package/state/store/index.ts

@@ -1,24 +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 { createJobStore } from "./job-store.js";
-export {
-  DEFAULT_JOB_TIMEOUT_MS,
-  type JobStatus,
-  type PendingJobKind,
-  type PendingJobRecord,
-  type PendingDepositJob,
-  type PendingTransactJob,
-  type PendingTransactContext,
-  type PendingTransactOutput,
-} from "./jobs.js";
-export type {
-  LeafRecord,
-  NoteInsert,
-  NoteRecord,
-  NullifierRecord,
-  RootRecord,
-} from "./records.js";