@cloak.ag/sdk 1.0.6 → 1.0.7

package/dist/chunk-QDMAIFO4.js

@@ -0,0 +1,389 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/crypto.ts
+import { buildPoseidon } from "circomlibjs";
+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;
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const g = globalThis;
+  try {
+    const cryptoObj = g?.crypto || g?.window?.crypto || g?.self?.crypto;
+    if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+      cryptoObj.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  try {
+    const nodeCrypto = __require("crypto");
+    if (nodeCrypto?.randomBytes) {
+      const buffer = nodeCrypto.randomBytes(length);
+      bytes.set(buffer);
+      return bytes;
+    }
+    if (nodeCrypto?.webcrypto?.getRandomValues) {
+      nodeCrypto.webcrypto.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return bytes;
+}
+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/utils/onchain-proof.ts
+var MERKLE_TREE_HEIGHT = 32;
+var SUBTREES_OFFSET = 40;
+var ROOT_OFFSET = 40 + MERKLE_TREE_HEIGHT * 32;
+var POSEIDON_ZERO_VALUES = [
+  "0000000000000000000000000000000000000000000000000000000000000000"
+  // level 0
+];
+var zeroValuesComputed = false;
+async function ensureZeroValues() {
+  if (zeroValuesComputed) return;
+  for (let i = 1; i <= MERKLE_TREE_HEIGHT; i++) {
+    const prevZeroHex = POSEIDON_ZERO_VALUES[i - 1];
+    const prevZeroBigInt = BigInt("0x" + prevZeroHex);
+    const hash = await poseidonHash([prevZeroBigInt, prevZeroBigInt]);
+    POSEIDON_ZERO_VALUES[i] = hash.toString(16).padStart(64, "0");
+  }
+  zeroValuesComputed = true;
+}
+async function readMerkleTreeState(connection, merkleTreePDA) {
+  const accountInfo = await connection.getAccountInfo(merkleTreePDA);
+  if (!accountInfo) {
+    throw new Error("Merkle tree account not found");
+  }
+  const data = accountInfo.data;
+  const nextIndex = Number(data.readBigUInt64LE(32));
+  const subtrees = [];
+  for (let i = 0; i < MERKLE_TREE_HEIGHT; i++) {
+    const offset = SUBTREES_OFFSET + i * 32;
+    const subtree = data.slice(offset, offset + 32);
+    subtrees.push(Buffer.from(subtree).toString("hex"));
+  }
+  const root = Buffer.from(data.slice(ROOT_OFFSET, ROOT_OFFSET + 32)).toString("hex");
+  return { nextIndex, root, subtrees };
+}
+async function computeProofFromChain(connection, merkleTreePDA, leafIndex) {
+  await ensureZeroValues();
+  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
+  if (leafIndex >= nextIndex) {
+    throw new Error(`Leaf index ${leafIndex} is beyond next_index ${nextIndex}`);
+  }
+  const pathElements = [];
+  const pathIndices = [];
+  let index = leafIndex;
+  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
+    pathIndices.push(index % 2);
+    if (index % 2 === 0) {
+      const siblingIndex = index + 1;
+      const levelNextIndex = Math.ceil(nextIndex / (1 << level));
+      if (siblingIndex >= levelNextIndex) {
+        pathElements.push(POSEIDON_ZERO_VALUES[level]);
+      } else {
+        pathElements.push(POSEIDON_ZERO_VALUES[level]);
+      }
+    } else {
+      pathElements.push(subtrees[level]);
+    }
+    index = Math.floor(index / 2);
+  }
+  return { pathElements, pathIndices, root };
+}
+async function computeProofForLatestDeposit(connection, merkleTreePDA) {
+  await ensureZeroValues();
+  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
+  if (nextIndex === 0) {
+    throw new Error("No leaves in tree");
+  }
+  const leafIndex = nextIndex - 1;
+  const proof = await computeProofInternal(leafIndex, nextIndex, subtrees);
+  return { ...proof, root, leafIndex };
+}
+async function computeProofInternal(leafIndex, _nextIndex, subtrees) {
+  const pathElements = [];
+  const pathIndices = [];
+  let index = leafIndex;
+  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
+    pathIndices.push(index % 2);
+    if (index % 2 === 0) {
+      pathElements.push(POSEIDON_ZERO_VALUES[level]);
+    } else {
+      pathElements.push(subtrees[level]);
+    }
+    index = Math.floor(index / 2);
+  }
+  return { pathElements, pathIndices };
+}
+
+export {
+  __require,
+  poseidonHash,
+  splitTo2Limbs,
+  pubkeyToLimbs,
+  computeMerkleRoot,
+  hexToBigint,
+  computeCommitment,
+  generateCommitmentAsync,
+  generateCommitment,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHashAsync,
+  computeOutputsHash,
+  computeOutputsHashSync,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
+  bigintToBytes32,
+  hexToBytes,
+  bytesToHex,
+  randomBytes,
+  isValidHex,
+  proofToBytes,
+  buildPublicInputsBytes,
+  readMerkleTreeState,
+  computeProofFromChain,
+  computeProofForLatestDeposit
+};