@unlink-xyz/core 0.1.3 → 0.1.4

package/key-derivation/bip39.ts

@@ -1,76 +0,0 @@
-import {
-  entropyToMnemonic,
-  generateMnemonic,
-  mnemonicToEntropy,
-  mnemonicToSeedSync,
-  validateMnemonic,
-} from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { HDKey } from "ethereum-cryptography/hdkey";
-import { Mnemonic as EthersMnemonic, HDNodeWallet } from "ethers";
-
-import { ByteUtils } from "./bytes.js";
-
-/**
- * Standard ETH derivation path helper for convenience utilities below.
- * Not used for 0zk accounts but kept for backwards compatibility.
- */
-const derivationPath = (index = 0): string => {
-  return `m/44'/60'/0'/0/${index}`;
-};
-
-export class Mnemonic {
-  /**
-   * Generate a BIP-39 mnemonic using the English wordlist.
-   */
-  static generate(strength: 128 | 192 | 256 = 128): string {
-    return generateMnemonic(wordlist, strength);
-  }
-
-  /**
-   * Validate a mnemonic against the English wordlist checksum.
-   */
-  static validate(mnemonic: string): boolean {
-    return validateMnemonic(mnemonic, wordlist);
-  }
-
-  /**
-   * Convert a mnemonic to a hex-encoded BIP-39 seed. Optional password supported.
-   */
-  static toSeed(mnemonic: string, password: string = ""): string {
-    const seed = mnemonicToSeedSync(mnemonic, password);
-    return ByteUtils.bytesToHex(seed);
-  }
-
-  static toEntropy(mnemonic: string): string {
-    const entropy = mnemonicToEntropy(mnemonic, wordlist);
-    return ByteUtils.bytesToHex(entropy);
-  }
-
-  static fromEntropy(entropyHex: string): string {
-    const entropy = ByteUtils.hexStringToBytes(entropyHex);
-    return entropyToMnemonic(entropy, wordlist);
-  }
-
-  /**
-   * Convenience helper: derive a 0x private key for non-0zk flows.
-   */
-  static to0xPrivateKey(mnemonic: string, derivationIndex?: number): string {
-    const seed = mnemonicToSeedSync(mnemonic);
-    const node = HDKey.fromMasterSeed(Buffer.from(seed)).derive(
-      derivationPath(derivationIndex),
-    );
-    if (!node.privateKey) {
-      throw new Error("Failed to derive private key");
-    }
-    return ByteUtils.bytesToHex(node.privateKey);
-  }
-
-  static to0xAddress(mnemonic: string, derivationIndex?: number): string {
-    const wallet = HDNodeWallet.fromMnemonic(
-      EthersMnemonic.fromPhrase(mnemonic),
-      derivationPath(derivationIndex),
-    );
-    return wallet.address;
-  }
-}

package/key-derivation/bytes.ts

@@ -1,118 +0,0 @@
-export enum ByteLength {
-  UINT_256 = 32,
-  UINT_512 = 64,
-}
-
-export type BytesData =
-  | string
-  | number
-  | bigint
-  | Uint8Array
-  | ArrayLike<number>;
-
-const HEX_REGEX = /^[0-9a-f]*$/i;
-
-const isPrefixed = (value: string): boolean => value.startsWith("0x");
-
-const assertEvenLength = (hex: string): void => {
-  if (hex.length % 2 !== 0) {
-    throw new Error("Hex string must have an even length");
-  }
-};
-
-const assertHex = (hex: string): void => {
-  if (!HEX_REGEX.test(hex)) {
-    throw new Error("Invalid hex string");
-  }
-};
-
-export class ByteUtils {
-  static prefix0x(value: string): string {
-    return isPrefixed(value) ? value : `0x${value}`;
-  }
-
-  static strip0x(value: string): string {
-    return isPrefixed(value) ? value.slice(2) : value;
-  }
-
-  static hexlify(data: BytesData): string {
-    if (typeof data === "string") {
-      return ByteUtils.strip0x(data).toLowerCase();
-    }
-    if (typeof data === "number" || typeof data === "bigint") {
-      if (data < 0) throw new Error("Cannot hexlify negative values");
-      const hex = data.toString(16);
-      return hex.length % 2 === 0 ? hex : `0${hex}`;
-    }
-    const view = data instanceof Uint8Array ? data : Uint8Array.from(data);
-    return ByteUtils.bytesToHex(view);
-  }
-
-  static bytesToHex(bytes: Uint8Array): string {
-    let hex = "";
-    for (const byte of bytes) {
-      hex += byte.toString(16).padStart(2, "0");
-    }
-    return hex;
-  }
-
-  static hexStringToBytes(hex: string): Uint8Array {
-    const normalized = ByteUtils.strip0x(hex).toLowerCase();
-    assertEvenLength(normalized);
-    assertHex(normalized);
-    const byteLength = normalized.length / 2;
-    return Uint8Array.from({ length: byteLength }, (_, index) =>
-      parseInt(normalized.slice(index * 2, index * 2 + 2), 16),
-    );
-  }
-
-  static arrayify(data: BytesData): Uint8Array {
-    if (data instanceof Uint8Array) {
-      return new Uint8Array(data);
-    }
-    if (typeof data === "string") {
-      return ByteUtils.hexStringToBytes(data);
-    }
-    if (typeof data === "number" || typeof data === "bigint") {
-      return ByteUtils.hexStringToBytes(ByteUtils.hexlify(data));
-    }
-    return Uint8Array.from(data);
-  }
-
-  static hexToBigInt(hex: string): bigint {
-    return BigInt(`0x${ByteUtils.strip0x(hex)}`);
-  }
-
-  static padToLength(
-    data: BytesData,
-    length: number,
-    side: "left" | "right" = "left",
-  ): string {
-    const hex = ByteUtils.hexlify(data);
-    const targetLength = length * 2;
-    if (hex.length > targetLength) {
-      throw new Error("Cannot pad data that exceeds target length");
-    }
-    return side === "left"
-      ? hex.padStart(targetLength, "0")
-      : hex.padEnd(targetLength, "0");
-  }
-
-  static formatToByteLength(data: BytesData, length: ByteLength): string {
-    const hex = ByteUtils.hexlify(data);
-    if (hex.length > length * 2) {
-      return hex.slice(0, length * 2);
-    }
-    return hex.padStart(length * 2, "0");
-  }
-
-  static nToHex(value: bigint, length: ByteLength, prefix = false): string {
-    const hex = value.toString(16).padStart(length * 2, "0");
-    return prefix ? `0x${hex}` : hex;
-  }
-}
-
-export function fromUTF8String(value: string): string {
-  const encoder = new TextEncoder();
-  return ByteUtils.hexlify(encoder.encode(value));
-}

package/key-derivation/hash.ts

@@ -1,13 +0,0 @@
-import { hmac } from "@noble/hashes/hmac";
-import { sha512 } from "@noble/hashes/sha2";
-
-import { BytesData, ByteUtils } from "./bytes.js";
-
-const toBytes = (data: BytesData): Uint8Array => {
-  return ByteUtils.arrayify(data);
-};
-
-export function sha512HMAC(key: BytesData, data: BytesData): string {
-  const mac = hmac(sha512, toBytes(key), toBytes(data));
-  return ByteUtils.bytesToHex(mac);
-}

package/key-derivation/index.ts

@@ -1,7 +0,0 @@
-export * from "./babyjubjub.js";
-export * from "./bip32.js";
-export * from "./bip39.js";
-export * from "./bech32.js";
-export * from "./bytes.js";
-export * from "./hash.js";
-export * from "./wallet-node.js";

package/key-derivation/wallet-node.ts

@@ -1,155 +0,0 @@
-import { Buffer } from "buffer";
-import { getPublicKey, hashes } from "@noble/ed25519";
-import { sha512 } from "@noble/hashes/sha2";
-import { eddsa, poseidon } from "@railgun-community/circomlibjs";
-
-import {
-  childKeyDerivationHardened,
-  getMasterKeyFromSeed,
-  getPathSegments,
-  KeyNode,
-} from "./bip32.js";
-import { Mnemonic } from "./bip39.js";
-import { ByteUtils } from "./bytes.js";
-
-hashes.sha512 = sha512;
-hashes.sha512Async = async (message: Uint8Array) => sha512(message);
-
-const HARDENED_OFFSET = 0x80000000;
-
-export type SpendingPublicKey = [bigint, bigint];
-export type SpendingKeyPair = {
-  privateKey: Uint8Array;
-  pubkey: SpendingPublicKey;
-};
-export type ViewingKeyPair = { privateKey: Uint8Array; pubkey: Uint8Array };
-
-/**
- * Hardened base paths for spending/viewing keys. The final path becomes
- * m/.../{index}' for each account slot.
- */
-const DERIVATION_PATH_PREFIXES = {
-  SPENDING: "m/44'/1984'/0'/0'/",
-  VIEWING: "m/420'/1984'/0'/0'/",
-};
-
-const derivePathsForIndex = (index: number = 0) => ({
-  spending: `${DERIVATION_PATH_PREFIXES.SPENDING}${index}'`,
-  viewing: `${DERIVATION_PATH_PREFIXES.VIEWING}${index}'`,
-});
-
-export type WalletNodes = { spending: WalletNode; viewing: WalletNode };
-
-export const deriveNodes = (
-  mnemonic: string,
-  index: number = 0,
-): WalletNodes => {
-  const paths = derivePathsForIndex(index);
-  const root = WalletNode.fromMnemonic(mnemonic);
-  return {
-    spending: root.derive(paths.spending),
-    viewing: root.derive(paths.viewing),
-  };
-};
-
-export const deriveNodesFromSeed = (
-  seed: Uint8Array,
-  index: number = 0,
-): WalletNodes => {
-  const paths = derivePathsForIndex(index);
-  const root = WalletNode.fromSeed(seed);
-  return {
-    spending: root.derive(paths.spending),
-    viewing: root.derive(paths.viewing),
-  };
-};
-
-export class WalletNode {
-  private readonly chainKey: string;
-
-  private readonly chainCode: string;
-
-  constructor(node: KeyNode) {
-    this.chainKey = node.chainKey;
-    this.chainCode = node.chainCode;
-  }
-
-  static fromMnemonic(mnemonic: string): WalletNode {
-    const seedHex = Mnemonic.toSeed(mnemonic);
-    return new WalletNode(getMasterKeyFromSeed(seedHex));
-  }
-
-  /**
-   * Convenience constructor for callers that already hold a seed or mnemonic-derived hex.
-   */
-  static fromSeed(seed: Uint8Array | string): WalletNode {
-    const seedHex =
-      typeof seed === "string"
-        ? ByteUtils.hexlify(seed)
-        : ByteUtils.bytesToHex(seed);
-    return new WalletNode(getMasterKeyFromSeed(seedHex));
-  }
-
-  /**
-   * Traverse a derivation path, returning the resulting hardened node.
-   */
-  derive(path: string): WalletNode {
-    const segments = getPathSegments(path);
-    const derived = segments.reduce(
-      (parent, segment) =>
-        childKeyDerivationHardened(parent, segment, HARDENED_OFFSET),
-      { chainKey: this.chainKey, chainCode: this.chainCode },
-    );
-    return new WalletNode(derived);
-  }
-
-  /**
-   * Derive the BabyJubJub spending key pair (private scalar + affine point).
-   */
-  getSpendingKeyPair(): SpendingKeyPair {
-    const privateKey = ByteUtils.hexStringToBytes(this.chainKey);
-    if (privateKey.length !== 32) {
-      throw new Error("Spending private key must be 32 bytes");
-    }
-    const pubkey = eddsa.prv2pub(Buffer.from(privateKey)) as SpendingPublicKey;
-    return { privateKey, pubkey };
-  }
-
-  static getMasterPublicKey(
-    spendingPublicKey: SpendingPublicKey,
-    nullifyingKey: bigint,
-  ): bigint {
-    return poseidon([...spendingPublicKey, nullifyingKey]);
-  }
-
-  static getNullifyingKey(viewingPrivateKey: Uint8Array): bigint {
-    if (!(viewingPrivateKey instanceof Uint8Array)) {
-      throw new Error("Viewing private key must be a Uint8Array");
-    }
-    if (viewingPrivateKey.length !== 32) {
-      throw new Error("Viewing private key must be 32 bytes");
-    }
-    const privateKeyHex = ByteUtils.bytesToHex(viewingPrivateKey);
-    return poseidon([ByteUtils.hexToBigInt(privateKeyHex)]);
-  }
-
-  /**
-   * Derive the Ed25519 viewing key pair for encrypted note retrieval.
-   */
-  async getViewingKeyPair(): Promise<ViewingKeyPair> {
-    const privateKey = ByteUtils.hexStringToBytes(this.chainKey);
-    if (privateKey.length !== 32) {
-      throw new Error("Viewing private key must be 32 bytes");
-    }
-    const pubkey = await getPublicKey(privateKey);
-    return { privateKey, pubkey };
-  }
-
-  /**
-   * Compute the Poseidon-based nullifying key used in note nullifier generation.
-   */
-  async getNullifyingKey(): Promise<bigint> {
-    const { privateKey } = await this.getViewingKeyPair();
-    return WalletNode.getNullifyingKey(privateKey);
-  }
-}

package/keys.ts

@@ -1,47 +0,0 @@
-import { KeyValidationError } from "./errors.js";
-
-export const RESERVED_PREFIXES = [
-  "meta:",
-  "notes:",
-  "leaves:",
-  "roots:",
-  "nullifiers:",
-  "ciphertexts:",
-  "jobs:",
-  "proof_cache:",
-  "cfg:",
-  "idx:",
-  "locks:",
-] as const;
-
-/** Canonical builders for storage key namespaces used across core */
-export const keys = {
-  note: (c: number, i: number) => `notes:${c}:${i}`,
-  leaf: (c: number, i: number) => `leaves:${c}:${i}`,
-  ciphertext: (c: number, i: number) => `ciphertexts:${c}:${i}`,
-  /** Track note indices that remain unspent for a given master public key (mpk acts as the account identifier). */
-  unspent: (c: number, mpk: string, i: number) =>
-    `idx:notes:unspent:${c}:${mpk}:${i}`,
-  unspentPrefix: (c: number, mpk: string) => `idx:notes:unspent:${c}:${mpk}:`,
-  nullifierObs: (c: number, n: string) => `nullifiers:${c}:${n}`,
-  nullToIndex: (c: number, n: string) => `idx:nullifier:${c}:${n}`,
-  nullifier: (c: number, n: string) => `nullifiers:${c}:${n}`,
-  root: (c: number, value: string) => `roots:${c}:${value}`,
-  latestRoot: (c: number) => `roots:latest:${c}`,
-  rootCursor: (c: number) => `meta:roots:cursor:${c}`,
-  cursor: (c: number) => `meta:sync:cursors:${c}`,
-  aggregate: (c: number, a: string) => `idx:notes:agg:${c}:${a}`,
-  job: (relayId: string) => `jobs:${relayId}`,
-};
-
-export const MAX_KEY_LEN = 512;
-
-export function validateKey(key: string) {
-  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/prover/config.ts

@@ -1,104 +0,0 @@
-/**
- * Configuration for the prover system
- * Handles artifact loading from local files or remote artifact server
- */
-
-/**
- * Environment-based configuration for artifact loading
- */
-export interface ProverConfig {
-  /** Base URL for the artifact server (browser mode) */
-  rpcUrl: string;
-  /** Whether to enable artifact caching */
-  enableCache: boolean;
-}
-
-/**
- * Default configuration
- * Can be overridden via environment variables
- */
-export const DEFAULT_CONFIG: ProverConfig = {
-  rpcUrl:
-    typeof process !== "undefined" && process.env?.UNLINK_RPC_URL
-      ? process.env.UNLINK_RPC_URL
-      : "http://localhost:3000",
-  enableCache: true,
-};
-
-/**
- * Artifact file types
- */
-export enum ArtifactType {
-  WASM = "joinsplit.wasm",
-  ZKEY = "joinsplit.zkey",
-  VKEY = "joinsplit.vkey.json",
-}
-
-/**
- * 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: string,
-  artifactType: ArtifactType,
-  baseUrl: string = DEFAULT_CONFIG.rpcUrl,
-): string {
-  // 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: string,
-  artifactType: ArtifactType,
-): string[] {
-  // 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(): boolean {
-    return typeof window !== "undefined" && typeof document !== "undefined";
-  },
-
-  /**
-   * Check if running in Node.js environment
-   */
-  isNode(): boolean {
-    return (
-      typeof process !== "undefined" &&
-      process.versions != null &&
-      process.versions.node != null
-    );
-  },
-
-  /**
-   * Get environment description for debugging
-   */
-  getEnvironment(): string {
-    if (this.isBrowser()) return "browser";
-    if (this.isNode()) return "node";
-    return "unknown";
-  },
-};

package/prover/index.ts

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

package/prover/prover.integration.test.ts

@@ -1,162 +0,0 @@
-import { access } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import * as snarkjs from "snarkjs";
-import { beforeAll, describe, expect, it } from "vitest";
-
-import {
-  getVerificationKey,
-  proveTransaction,
-  type JoinsplitProofInput,
-} from "./prover.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-describe("prover integration tests", () => {
-  beforeAll(async () => {
-    // Check if artifacts exist for 2x3 circuit (used in integration tests)
-    try {
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.wasm",
-        ),
-      );
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.zkey",
-        ),
-      );
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.vkey.json",
-        ),
-      );
-    } catch (error) {
-      throw new Error(
-        "Circuit artifacts not found. Please run 'pnpm run circuits:build' first.",
-      );
-    }
-  });
-
-  it("generates and verifies a proof generated from circuits input data", async () => {
-    const rawInput = {
-      merkleRoot:
-        "6651503891008261868318637545520517015441423030408583353730529205210575769897",
-      boundParamsHash:
-        "4367284183670237676694687139389936823583752501847632190787848034614846786866",
-      nullifiers: [
-        "11485370912550667629147418652010973429416469356401563507077544465653018582229",
-        "12458947539527367086074368910577127304083837870968412606004383792911977699092",
-      ],
-      commitmentsOut: [
-        "21220431320512498255211940241902464585964672736998306204392012684848332107713",
-        "10812352772790655187825976376417683652931326614980053685809861928409318557101",
-        "2361786391388492851501376027004057215483918983555223791892300314116572980398",
-      ],
-      token: "611382286831621467233887798921843936019654057231",
-      publicKey: [
-        "17403090114984634995691076088606286689905312870166298587771402004938333701956",
-        "11686443728124206965533675395218715181279824020209406379329530395240161730269",
-      ],
-      signature: [
-        "13337325824273672513648456655099758722924690095445255254284844332733013061113",
-        "11478044465897161338488651611555416955979346707535934533682695529282557178771",
-        "2690614056970046123325708657516589911150638516730022213521930951131599801259",
-      ],
-      randomIn: [
-        "311410881652967579423188304066739460260",
-        "161576146678088229090350665564580980145",
-      ],
-      valueIn: ["10000000000", "20000000000"],
-      pathElements: [
-        [
-          "14943413005531767156170859665453505874291109952298492592265028467982121566535",
-          "17140872132393658386372884137443465756166862794960926853080892710475197765189",
-          "6371505487407425546372285321506278506957375353941268479986307401454583028710",
-          "14682603619753984551536111997488330801501968646131197748838572499913532539651",
-          "4177329909171803290170279196019319447087145475250139657920728261184066492383",
-          "9144726083425293457189930182175584375755866170755203037168330473435257599943",
-          "8236371367060628245320813572019740297071112030680295018688014025332724941914",
-          "20704513355749821470300998799414731362245300238021178553122435057113528378476",
-          "16736886623818773524263138779809916105169520362832964900272252437275369959388",
-          "16415580715665869864634788741927065679186058985255106992778939765291984104497",
-          "5715205213015845364387052206849889843188282449933545435544812025608946666822",
-          "11013175031749877081979736330659999751637067247483574805902945041305483682579",
-          "10708260192616993577686743465610377735773279483333447100671640147037242870779",
-          "17708681376628530799996447981717676562184543188562031708516142906406141650368",
-          "3967876508977884960877910167550068853181553556854105674925421366723704424223",
-          "18077967785446169488603147322170139942753858441115263187838141084900323103797",
-        ],
-        [
-          "17155689016641574060256511555039569894135211745581590863068780884287641639347",
-          "17140872132393658386372884137443465756166862794960926853080892710475197765189",
-          "6371505487407425546372285321506278506957375353941268479986307401454583028710",
-          "14682603619753984551536111997488330801501968646131197748838572499913532539651",
-          "4177329909171803290170279196019319447087145475250139657920728261184066492383",
-          "9144726083425293457189930182175584375755866170755203037168330473435257599943",
-          "8236371367060628245320813572019740297071112030680295018688014025332724941914",
-          "20704513355749821470300998799414731362245300238021178553122435057113528378476",
-          "16736886623818773524263138779809916105169520362832964900272252437275369959388",
-          "16415580715665869864634788741927065679186058985255106992778939765291984104497",
-          "5715205213015845364387052206849889843188282449933545435544812025608946666822",
-          "11013175031749877081979736330659999751637067247483574805902945041305483682579",
-          "10708260192616993577686743465610377735773279483333447100671640147037242870779",
-          "17708681376628530799996447981717676562184543188562031708516142906406141650368",
-          "3967876508977884960877910167550068853181553556854105674925421366723704424223",
-          "18077967785446169488603147322170139942753858441115263187838141084900323103797",
-        ],
-      ],
-      leavesIndices: [0, 1],
-      nullifyingKey:
-        "18659841675752504949640201002407906598138517454751630186524244551004513393000",
-      npkOut: [
-        "5969622909025228762817370697760280284869505282539549033240181049624056088653",
-        "2100582032716223613287570049117084073292258181991442907862227237312284306360",
-        "742175203644052806963513562623187657396500499529893903278346823527475860966",
-      ],
-      valueOut: ["10000000000", "10000000000", "10000000000"],
-    };
-
-    // Format circuit inputs (convert strings to bigints)
-    // Using the exact field names the circuit expects
-    const circuitInput: JoinsplitProofInput = {
-      merkleRoot: BigInt(rawInput.merkleRoot),
-      boundParamsHash: BigInt(rawInput.boundParamsHash),
-      nullifiers: rawInput.nullifiers.map((n: string) => BigInt(n)),
-      commitmentsOut: rawInput.commitmentsOut.map((c: string) => BigInt(c)),
-      token: BigInt(rawInput.token),
-      publicKey: rawInput.publicKey.map((pk: string) => BigInt(pk)),
-      signature: rawInput.signature.map((s: string) => BigInt(s)),
-      randomIn: rawInput.randomIn.map((r: string) => BigInt(r)),
-      valueIn: rawInput.valueIn.map((v: string) => BigInt(v)),
-      pathElements: rawInput.pathElements.map((pe: string[]) =>
-        pe.map((e) => BigInt(e)),
-      ),
-      leavesIndices: rawInput.leavesIndices.map((i: number) => BigInt(i)),
-      nullifyingKey: BigInt(rawInput.nullifyingKey),
-      npkOut: rawInput.npkOut.map((npk: string) => BigInt(npk)),
-      valueOut: rawInput.valueOut.map((v: string) => BigInt(v)),
-    };
-
-    // Generate proof using real circuit (automatically selects 2x3 based on input dimensions)
-    const { proof, publicSignals } = await proveTransaction(circuitInput);
-
-    // Verify the generated proof (2 inputs, 3 outputs)
-    const vkey = await getVerificationKey(2, 3);
-    const isValid = await snarkjs.groth16.verify(vkey, publicSignals, proof);
-
-    // Assertions
-    expect(isValid).toBe(true);
-    expect(proof.protocol).toBe("groth16");
-    expect(proof.curve).toBe("bn128");
-    expect(publicSignals).toHaveLength(7); // Should match nPublic
-
-    // Verify public signals match expected values from circuit
-    expect(publicSignals[0]).toBe(rawInput.merkleRoot);
-    expect(publicSignals[1]).toBe(rawInput.boundParamsHash);
-  }, 30000); // Increase timeout as proof generation can take time
-});