@cloak.dev/sdk 0.1.8 → 0.2.0

package/dist/chunk-YX5SCAMR.js

@@ -0,0 +1,594 @@
+// src/core/utxo.ts
+import { PublicKey } from "@solana/web3.js";
+import { buildPoseidon as buildPoseidon2 } from "circomlibjs";
+import { blake3 } from "@noble/hashes/blake3";
+
+// src/utils/crypto.ts
+import { buildPoseidon } from "circomlibjs";
+
+// src/core/types.ts
+var CloakError = class extends Error {
+  constructor(message, category, retryable = false, originalError) {
+    super(message);
+    this.category = category;
+    this.retryable = retryable;
+    this.originalError = originalError;
+    this.name = "CloakError";
+  }
+};
+
+// src/utils/crypto.ts
+var poseidon = null;
+async function getPoseidon() {
+  if (!poseidon) {
+    poseidon = await buildPoseidon();
+  }
+  return poseidon;
+}
+async function poseidonHash(inputs) {
+  const p = await getPoseidon();
+  const hash = p(inputs.map((x) => p.F.e(x)));
+  return p.F.toObject(hash);
+}
+function splitTo2Limbs(value) {
+  const mask = (1n << 128n) - 1n;
+  const lo = value & mask;
+  const hi = value >> 128n;
+  return [lo, hi];
+}
+function pubkeyToLimbs(pubkey) {
+  const bytes = typeof pubkey.toBytes === "function" ? pubkey.toBytes() : pubkey;
+  const value = BigInt("0x" + Buffer.from(bytes).toString("hex"));
+  return splitTo2Limbs(value);
+}
+async function computeMerkleRoot(leaf, pathElements, pathIndices) {
+  let current = leaf;
+  for (let i = 0; i < pathElements.length; i++) {
+    if (pathIndices[i] === 0) {
+      current = await poseidonHash([current, pathElements[i]]);
+    } else {
+      current = await poseidonHash([pathElements[i], current]);
+    }
+  }
+  return current;
+}
+function hexToBigint(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return BigInt("0x" + cleanHex);
+}
+async function computeCommitment(amount, r, sk_spend) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  const [r0, r1] = splitTo2Limbs(r);
+  const pk_spend = await poseidonHash([sk0, sk1]);
+  return await poseidonHash([amount, r0, r1, pk_spend]);
+}
+async function generateCommitmentAsync(amountLamports, r, skSpend) {
+  const amount = BigInt(amountLamports);
+  const rValue = hexToBigint(bytesToHex(r));
+  const skValue = hexToBigint(bytesToHex(skSpend));
+  return await computeCommitment(amount, rValue, skValue);
+}
+function generateCommitment(_amountLamports, _r, _skSpend) {
+  throw new Error("generateCommitment is deprecated. Use generateCommitmentAsync instead.");
+}
+async function computeNullifier(sk_spend, leafIndex) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  return await poseidonHash([sk0, sk1, leafIndex]);
+}
+async function computeNullifierAsync(skSpend, leafIndex) {
+  const skValue = typeof skSpend === "string" ? hexToBigint(skSpend) : hexToBigint(bytesToHex(skSpend));
+  return await computeNullifier(skValue, BigInt(leafIndex));
+}
+function computeNullifierSync(_skSpend, _leafIndex) {
+  throw new Error("computeNullifierSync is deprecated. Use computeNullifierAsync instead.");
+}
+async function computeOutputsHashAsync(outputs) {
+  let hash = 0n;
+  for (const output of outputs) {
+    const [lo, hi] = pubkeyToLimbs(output.recipient);
+    hash = await poseidonHash([hash, lo, hi, BigInt(output.amount)]);
+  }
+  return hash;
+}
+async function computeOutputsHash(outAddr, outAmount, outFlags) {
+  let hash = 0n;
+  for (let i = 0; i < 5; i++) {
+    if (outFlags[i] === 1) {
+      hash = await poseidonHash([hash, outAddr[i][0], outAddr[i][1], outAmount[i]]);
+    }
+  }
+  return hash;
+}
+function computeOutputsHashSync(_outputs) {
+  throw new Error("computeOutputsHashSync is deprecated. Use computeOutputsHashAsync instead.");
+}
+async function computeSwapOutputsHash(inputMintLimbs, outputMintLimbs, recipientAtaLimbs, minOutputAmount, publicAmount) {
+  return await poseidonHash([
+    inputMintLimbs[0],
+    inputMintLimbs[1],
+    outputMintLimbs[0],
+    outputMintLimbs[1],
+    recipientAtaLimbs[0],
+    recipientAtaLimbs[1],
+    minOutputAmount,
+    publicAmount
+  ]);
+}
+async function computeSwapOutputsHashAsync(inputMint, outputMint, recipientAta, minOutputAmount, amount) {
+  const inputMintLimbs = pubkeyToLimbs(inputMint);
+  const outputMintLimbs = pubkeyToLimbs(outputMint);
+  const recipientAtaLimbs = pubkeyToLimbs(recipientAta);
+  return await computeSwapOutputsHash(
+    inputMintLimbs,
+    outputMintLimbs,
+    recipientAtaLimbs,
+    BigInt(minOutputAmount),
+    BigInt(amount)
+  );
+}
+function computeSwapOutputsHashSync(_outputMint, _recipientAta, _minOutputAmount, _amount) {
+  throw new Error("computeSwapOutputsHashSync is deprecated. Use computeSwapOutputsHashAsync instead.");
+}
+function bigintToBytes32(n) {
+  const hex = n.toString(16).padStart(64, "0");
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes, prefix = false) {
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return prefix ? `0x${hex}` : hex;
+}
+var InsecureRandomnessError = class extends CloakError {
+  constructor(message, originalError) {
+    super(message, "environment", false, originalError);
+    this.name = "InsecureRandomnessError";
+  }
+};
+var GET_RANDOM_VALUES_MAX_BYTES = 65536;
+function describeFailure(err) {
+  if (err instanceof Error) {
+    return err.message ? `${err.name}: ${err.message}` : err.name;
+  }
+  return String(err);
+}
+function resolveWebCrypto() {
+  const g = globalThis;
+  const cryptoObj = g?.crypto ?? g?.self?.crypto ?? g?.window?.crypto;
+  return cryptoObj && typeof cryptoObj.getRandomValues === "function" ? cryptoObj : void 0;
+}
+function resolveNodeCrypto() {
+  const proc = globalThis?.process;
+  if (typeof proc?.getBuiltinModule !== "function") return void 0;
+  return proc.getBuiltinModule("node:crypto");
+}
+function randomBytes(length) {
+  if (!Number.isInteger(length) || length < 0) {
+    throw new InsecureRandomnessError(
+      `randomBytes(length) requires a non-negative integer length, received ${String(length)}`
+    );
+  }
+  const bytes = new Uint8Array(length);
+  if (length === 0) return bytes;
+  const failures = [];
+  const webCrypto = resolveWebCrypto();
+  if (webCrypto) {
+    try {
+      for (let offset = 0; offset < length; offset += GET_RANDOM_VALUES_MAX_BYTES) {
+        const end = Math.min(offset + GET_RANDOM_VALUES_MAX_BYTES, length);
+        webCrypto.getRandomValues(bytes.subarray(offset, end));
+      }
+      return bytes;
+    } catch (err) {
+      failures.push(`globalThis.crypto.getRandomValues -> ${describeFailure(err)}`);
+    }
+  } else {
+    failures.push("globalThis.crypto.getRandomValues -> not available in this runtime");
+  }
+  try {
+    const nodeCrypto = resolveNodeCrypto();
+    if (nodeCrypto && typeof nodeCrypto.randomFillSync === "function") {
+      nodeCrypto.randomFillSync(bytes);
+      return bytes;
+    }
+    failures.push(
+      nodeCrypto ? "node:crypto.randomFillSync -> not a function on the resolved node:crypto module" : "node:crypto -> not available (process.getBuiltinModule missing; needs Node >= 20.16)"
+    );
+  } catch (err) {
+    failures.push(`node:crypto.randomFillSync -> ${describeFailure(err)}`);
+  }
+  throw new InsecureRandomnessError(
+    `No cryptographically secure random source is available; refusing to produce ${length} bytes of secret material. Cloak fails closed here because note spend keys, blindings and nonces derived from a predictable generator are permanently compromised. Attempted sources: ${failures.join(" | ")}. Fix the runtime (Node >= 18, a browser/worker with Web Crypto, or install a crypto.getRandomValues polyfill such as react-native-get-random-values).`
+  );
+}
+function isValidHex(hex, expectedLength) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (!/^[0-9a-f]*$/i.test(cleanHex)) {
+    return false;
+  }
+  if (cleanHex.length % 2 !== 0) {
+    return false;
+  }
+  if (expectedLength !== void 0) {
+    return cleanHex.length === expectedLength * 2;
+  }
+  return true;
+}
+var BN254_MODULUS = BigInt("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47");
+function proofToBytes(proof) {
+  const pi_a_x = BigInt(proof.pi_a[0]);
+  const pi_a_y = BigInt(proof.pi_a[1]);
+  const pi_a_y_neg = (BN254_MODULUS - pi_a_y) % BN254_MODULUS;
+  const pi_a_x_le = bigintToBytes32LE(pi_a_x);
+  const pi_a_y_neg_le = bigintToBytes32LE(pi_a_y_neg);
+  const pi_a_le = new Uint8Array(64);
+  pi_a_le.set(pi_a_x_le, 0);
+  pi_a_le.set(pi_a_y_neg_le, 32);
+  const pi_a_be = convertEndianness32(pi_a_le);
+  const pi_b_x1 = BigInt(proof.pi_b[0][0]);
+  const pi_b_x2 = BigInt(proof.pi_b[0][1]);
+  const pi_b_y1 = BigInt(proof.pi_b[1][0]);
+  const pi_b_y2 = BigInt(proof.pi_b[1][1]);
+  const pi_b_x1_le = bigintToBytes32LE(pi_b_x1);
+  const pi_b_x2_le = bigintToBytes32LE(pi_b_x2);
+  const pi_b_y1_le = bigintToBytes32LE(pi_b_y1);
+  const pi_b_y2_le = bigintToBytes32LE(pi_b_y2);
+  const pi_b_le = new Uint8Array(128);
+  pi_b_le.set(pi_b_x1_le, 0);
+  pi_b_le.set(pi_b_x2_le, 32);
+  pi_b_le.set(pi_b_y1_le, 64);
+  pi_b_le.set(pi_b_y2_le, 96);
+  const pi_b_be = convertEndianness64(pi_b_le);
+  const pi_c_x = BigInt(proof.pi_c[0]);
+  const pi_c_y = BigInt(proof.pi_c[1]);
+  const pi_c_x_le = bigintToBytes32LE(pi_c_x);
+  const pi_c_y_le = bigintToBytes32LE(pi_c_y);
+  const pi_c_le = new Uint8Array(64);
+  pi_c_le.set(pi_c_x_le, 0);
+  pi_c_le.set(pi_c_y_le, 32);
+  const pi_c_be = convertEndianness32(pi_c_le);
+  const result = new Uint8Array(256);
+  result.set(pi_a_be, 0);
+  result.set(pi_b_be, 64);
+  result.set(pi_c_be, 192);
+  return result;
+}
+function bigintToBytes32LE(n) {
+  const bytes = new Uint8Array(32);
+  let value = n % BN254_MODULUS;
+  if (value < 0) {
+    value = (value + BN254_MODULUS) % BN254_MODULUS;
+  }
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Number(value & BigInt(255));
+    value = value >> BigInt(8);
+  }
+  return bytes;
+}
+function convertEndianness32(bytes) {
+  if (bytes.length !== 64) {
+    throw new Error("convertEndianness32 expects 64 bytes");
+  }
+  const result = new Uint8Array(64);
+  for (let i = 0; i < 32; i++) {
+    result[i] = bytes[31 - i];
+  }
+  for (let i = 0; i < 32; i++) {
+    result[32 + i] = bytes[63 - i];
+  }
+  return result;
+}
+function convertEndianness64(bytes) {
+  if (bytes.length !== 128) {
+    throw new Error("convertEndianness64 expects 128 bytes");
+  }
+  const result = new Uint8Array(128);
+  for (let i = 0; i < 64; i++) {
+    result[i] = bytes[63 - i];
+  }
+  for (let i = 0; i < 64; i++) {
+    result[64 + i] = bytes[127 - i];
+  }
+  return result;
+}
+function buildPublicInputsBytes(root, nullifier, outputsHash, publicAmount) {
+  const result = new Uint8Array(104);
+  result.set(bigintToBytes32(root), 0);
+  result.set(bigintToBytes32(nullifier), 32);
+  result.set(bigintToBytes32(outputsHash), 64);
+  const amountBytes = new Uint8Array(8);
+  let amt = publicAmount;
+  for (let i = 7; i >= 0; i--) {
+    amountBytes[i] = Number(amt & 0xffn);
+    amt = amt >> 8n;
+  }
+  result.set(amountBytes, 96);
+  return result;
+}
+
+// src/core/utxo.ts
+var FIELD_MODULUS = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+var KEYPAIR_DOMAIN_TAG = BigInt("5423839527465210463");
+var UTXO_KEY_DOMAIN = new TextEncoder().encode("cloak_utxo_priv_v1");
+var NATIVE_SOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
+var poseidonInstance = null;
+async function getPoseidon2() {
+  if (!poseidonInstance) {
+    poseidonInstance = await buildPoseidon2();
+  }
+  return poseidonInstance;
+}
+function randomFieldElement() {
+  const bytes = randomBytes(32);
+  let value = BigInt(0);
+  for (let i = 0; i < 32; i++) {
+    value = value << BigInt(8) | BigInt(bytes[i]);
+  }
+  return value % (FIELD_MODULUS >> BigInt(4));
+}
+async function generateUtxoKeypair() {
+  const poseidon2 = await getPoseidon2();
+  const privateKey = randomFieldElement();
+  const publicKeyHash = poseidon2([privateKey], KEYPAIR_DOMAIN_TAG);
+  const publicKey = poseidon2.F.toObject(publicKeyHash);
+  return { privateKey, publicKey };
+}
+async function deriveUtxoKeypairFromSpendKey(skSpend) {
+  if (!skSpend || !(skSpend instanceof Uint8Array) || skSpend.length !== 32) {
+    throw new Error("skSpend must be 32 bytes");
+  }
+  const preimage = new Uint8Array(UTXO_KEY_DOMAIN.length + skSpend.length);
+  preimage.set(UTXO_KEY_DOMAIN, 0);
+  preimage.set(skSpend, UTXO_KEY_DOMAIN.length);
+  const hash = blake3(preimage);
+  let value = BigInt(0);
+  for (let i = 0; i < 32; i++) {
+    value = value << BigInt(8) | BigInt(hash[i]);
+  }
+  const privateKey = value % (FIELD_MODULUS >> BigInt(4));
+  const publicKey = await derivePublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+async function derivePublicKey(privateKey) {
+  const poseidon2 = await getPoseidon2();
+  const hash = poseidon2([privateKey], KEYPAIR_DOMAIN_TAG);
+  return poseidon2.F.toObject(hash);
+}
+async function createUtxo(amount, keypair, mintAddress = NATIVE_SOL_MINT) {
+  const blinding = randomFieldElement();
+  const utxo = {
+    amount,
+    keypair,
+    blinding,
+    mintAddress
+  };
+  utxo.commitment = await computeCommitment2(utxo);
+  return utxo;
+}
+async function createZeroUtxo(mintAddress = NATIVE_SOL_MINT, salt) {
+  const poseidon2 = await getPoseidon2();
+  const effectiveSalt = salt ?? randomFieldElement();
+  const publicKeyHash = poseidon2([effectiveSalt], KEYPAIR_DOMAIN_TAG);
+  const publicKey = poseidon2.F.toObject(publicKeyHash);
+  const keypair = { privateKey: effectiveSalt, publicKey };
+  const utxo = {
+    amount: BigInt(0),
+    keypair,
+    blinding: BigInt(0),
+    mintAddress
+  };
+  utxo.commitment = await computeCommitment2(utxo);
+  utxo.index = 0;
+  return utxo;
+}
+function pubkeyToFieldElement(pubkey) {
+  const bytes = pubkey.toBytes();
+  let value = BigInt(0);
+  for (let i = 0; i < 32; i++) {
+    value = value << BigInt(8) | BigInt(bytes[i]);
+  }
+  return value % FIELD_MODULUS;
+}
+function pubkeyToFieldLimbs(pubkey) {
+  const bytes = pubkey.toBytes();
+  let hi = BigInt(0);
+  let lo = BigInt(0);
+  for (let i = 0; i < 16; i++) {
+    hi = hi << BigInt(8) | BigInt(bytes[i]);
+  }
+  for (let i = 16; i < 32; i++) {
+    lo = lo << BigInt(8) | BigInt(bytes[i]);
+  }
+  return [hi, lo];
+}
+async function computeCommitment2(utxo) {
+  const poseidon2 = await getPoseidon2();
+  const mintField = pubkeyToFieldElement(utxo.mintAddress);
+  const hash = poseidon2([
+    utxo.amount,
+    utxo.keypair.publicKey,
+    utxo.blinding,
+    mintField
+  ]);
+  return poseidon2.F.toObject(hash);
+}
+async function computeSignature(privateKey, commitment, pathIndex) {
+  const poseidon2 = await getPoseidon2();
+  const hash = poseidon2([privateKey, commitment, pathIndex]);
+  return poseidon2.F.toObject(hash);
+}
+async function computeNullifier2(utxo) {
+  if (utxo.index === void 0) {
+    throw new Error("UTXO must have an index to compute nullifier");
+  }
+  const poseidon2 = await getPoseidon2();
+  const commitment = utxo.commitment ?? await computeCommitment2(utxo);
+  const pathIndex = BigInt(utxo.index);
+  const signature = await computeSignature(
+    utxo.keypair.privateKey,
+    commitment,
+    pathIndex
+  );
+  const hash = poseidon2([commitment, pathIndex, signature]);
+  return poseidon2.F.toObject(hash);
+}
+function serializeUtxo(utxo) {
+  const buffer = new ArrayBuffer(128);
+  const view = new DataView(buffer);
+  const amountBytes = bigintToBytes(utxo.amount, 8);
+  for (let i = 0; i < 8; i++) {
+    view.setUint8(i, amountBytes[i]);
+  }
+  const privkeyBytes = bigintToBytes(utxo.keypair.privateKey, 32);
+  for (let i = 0; i < 32; i++) {
+    view.setUint8(8 + i, privkeyBytes[i]);
+  }
+  const blindingBytes = bigintToBytes(utxo.blinding, 32);
+  for (let i = 0; i < 32; i++) {
+    view.setUint8(40 + i, blindingBytes[i]);
+  }
+  const mintBytes = utxo.mintAddress.toBytes();
+  for (let i = 0; i < 32; i++) {
+    view.setUint8(72 + i, mintBytes[i]);
+  }
+  view.setUint32(104, utxo.index ?? 0, true);
+  return new Uint8Array(buffer);
+}
+async function deserializeUtxo(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset);
+  const amountBytes = bytes.slice(0, 8);
+  const amount = bytesToBigint(amountBytes);
+  const privkeyBytes = bytes.slice(8, 40);
+  const privateKey = bytesToBigint(privkeyBytes);
+  const publicKey = await derivePublicKey(privateKey);
+  const blindingBytes = bytes.slice(40, 72);
+  const blinding = bytesToBigint(blindingBytes);
+  const mintBytes = bytes.slice(72, 104);
+  const mintAddress = new PublicKey(mintBytes);
+  const index = view.getUint32(104, true);
+  const utxo = {
+    amount,
+    keypair: { privateKey, publicKey },
+    blinding,
+    mintAddress,
+    index: index > 0 ? index : void 0
+  };
+  utxo.commitment = await computeCommitment2(utxo);
+  return utxo;
+}
+function bigintToBytes(value, length) {
+  const result = new Uint8Array(length);
+  let remaining = value;
+  for (let i = 0; i < length; i++) {
+    result[i] = Number(remaining & BigInt(255));
+    remaining >>= BigInt(8);
+  }
+  return result;
+}
+function bytesToBigint(bytes) {
+  let result = BigInt(0);
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    result = result << BigInt(8) | BigInt(bytes[i]);
+  }
+  return result;
+}
+function bigintToHex(value) {
+  return value.toString(16).padStart(64, "0");
+}
+function hexToBigint2(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return BigInt("0x" + cleanHex);
+}
+function bigintToBytes322(value) {
+  const result = new Uint8Array(32);
+  let remaining = value;
+  for (let i = 31; i >= 0; i--) {
+    result[i] = Number(remaining & BigInt(255));
+    remaining >>= BigInt(8);
+  }
+  return result;
+}
+async function utxoEquals(a, b) {
+  const commitmentA = a.commitment ?? await computeCommitment2(a);
+  const commitmentB = b.commitment ?? await computeCommitment2(b);
+  return commitmentA === commitmentB;
+}
+function sumUtxoAmounts(utxos) {
+  return utxos.reduce((sum, utxo) => sum + utxo.amount, BigInt(0));
+}
+function selectUtxos(available, targetAmount) {
+  const sorted = [...available].sort(
+    (a, b) => Number(b.amount - a.amount)
+  );
+  const selected = [];
+  let total = BigInt(0);
+  for (const utxo of sorted) {
+    if (total >= targetAmount) break;
+    selected.push(utxo);
+    total += utxo.amount;
+  }
+  if (total < targetAmount) {
+    return null;
+  }
+  return selected;
+}
+
+export {
+  CloakError,
+  poseidonHash,
+  splitTo2Limbs,
+  pubkeyToLimbs,
+  computeMerkleRoot,
+  hexToBigint,
+  computeCommitment,
+  generateCommitmentAsync,
+  generateCommitment,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHashAsync,
+  computeOutputsHash,
+  computeOutputsHashSync,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
+  bigintToBytes32,
+  hexToBytes,
+  bytesToHex,
+  InsecureRandomnessError,
+  randomBytes,
+  isValidHex,
+  BN254_MODULUS,
+  proofToBytes,
+  buildPublicInputsBytes,
+  NATIVE_SOL_MINT,
+  randomFieldElement,
+  generateUtxoKeypair,
+  deriveUtxoKeypairFromSpendKey,
+  derivePublicKey,
+  createUtxo,
+  createZeroUtxo,
+  pubkeyToFieldElement,
+  pubkeyToFieldLimbs,
+  computeCommitment2,
+  computeSignature,
+  computeNullifier2,
+  serializeUtxo,
+  deserializeUtxo,
+  bigintToHex,
+  hexToBigint2,
+  bigintToBytes322,
+  utxoEquals,
+  sumUtxoAmounts,
+  selectUtxos
+};