@buildonspark/spark-sdk 0.0.15 → 0.0.17

package/src/utils/keys.ts

@@ -0,0 +1,92 @@
+import { numberToBytesBE } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { HDKey } from "@scure/bip32";
+
+export function addPublicKeys(a: Uint8Array, b: Uint8Array): Uint8Array {
+  if (a.length !== 33 || b.length !== 33) {
+    throw new Error("Public keys must be 33 bytes");
+  }
+  const pubkeyA = secp256k1.ProjectivePoint.fromHex(a);
+  const pubkeyB = secp256k1.ProjectivePoint.fromHex(b);
+  return pubkeyA.add(pubkeyB).toRawBytes(true);
+}
+
+export function applyAdditiveTweakToPublicKey(
+  pubkey: Uint8Array,
+  tweak: Uint8Array,
+) {
+  if (pubkey.length !== 33) {
+    throw new Error("Public key must be 33 bytes");
+  }
+  if (tweak.length !== 32) {
+    throw new Error("Tweak must be 32 bytes");
+  }
+  const pubkeyPoint = secp256k1.ProjectivePoint.fromHex(pubkey);
+
+  const privTweek = secp256k1.utils.normPrivateKeyToScalar(tweak);
+  const pubTweek = secp256k1.getPublicKey(privTweek, true);
+  const tweekPoint = secp256k1.ProjectivePoint.fromHex(pubTweek);
+
+  return pubkeyPoint.add(tweekPoint).toRawBytes(true);
+}
+
+export function subtractPublicKeys(a: Uint8Array, b: Uint8Array) {
+  if (a.length !== 33 || b.length !== 33) {
+    throw new Error("Public keys must be 33 bytes");
+  }
+
+  const pubkeyA = secp256k1.ProjectivePoint.fromHex(a);
+  const pubkeyB = secp256k1.ProjectivePoint.fromHex(b);
+  return pubkeyA.subtract(pubkeyB).toRawBytes(true);
+}
+
+export function addPrivateKeys(a: Uint8Array, b: Uint8Array) {
+  if (a.length !== 32 || b.length !== 32) {
+    throw new Error("Private keys must be 32 bytes");
+  }
+
+  // Convert private keys to scalars (big integers)
+  const privA = secp256k1.utils.normPrivateKeyToScalar(a);
+  const privB = secp256k1.utils.normPrivateKeyToScalar(b);
+
+  // Add the scalars and reduce modulo the curve order
+  const sum = (privA + privB) % secp256k1.CURVE.n;
+
+  // Convert back to bytes
+  return numberToBytesBE(sum, 32);
+}
+
+export function subtractPrivateKeys(a: Uint8Array, b: Uint8Array) {
+  if (a.length !== 32 || b.length !== 32) {
+    throw new Error("Private keys must be 32 bytes");
+  }
+
+  const privA = secp256k1.utils.normPrivateKeyToScalar(a);
+  const privB = secp256k1.utils.normPrivateKeyToScalar(b);
+  const sum = (secp256k1.CURVE.n - privB + privA) % secp256k1.CURVE.n;
+
+  return numberToBytesBE(sum, 32);
+}
+
+export function sumOfPrivateKeys(keys: Uint8Array[]) {
+  return keys.reduce((sum, key) => {
+    if (key.length !== 32) {
+      throw new Error("Private keys must be 32 bytes");
+    }
+    return addPrivateKeys(sum, key);
+  });
+}
+
+export function lastKeyWithTarget(target: Uint8Array, keys: Uint8Array[]) {
+  if (target.length !== 32) {
+    throw new Error("Target must be 32 bytes");
+  }
+
+  const sum = sumOfPrivateKeys(keys);
+  return subtractPrivateKeys(target, sum);
+}
+
+export function getMasterHDKeyFromSeed(seed: Uint8Array): HDKey {
+  // TODO: This needs to be moved back to the signer
+  return HDKey.fromMasterSeed(seed);
+}

package/src/utils/mempool.ts

@@ -0,0 +1,42 @@
+import { BitcoinNetwork } from "../types/index.js";
+import { getNetworkFromAddress } from "./network.js";
+
+export async function getLatestDepositTxId(
+  address: string,
+): Promise<string | null> {
+  const network = getNetworkFromAddress(address);
+  const baseUrl =
+    network === BitcoinNetwork.REGTEST
+      ? "https://regtest-mempool.dev.dev.sparkinfra.net/api"
+      : "https://mempool.space/docs/api";
+  const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+
+  if (network === BitcoinNetwork.REGTEST) {
+    headers["Authorization"] = `Basic ${auth}`;
+  }
+
+  const response = await fetch(`${baseUrl}/address/${address}/txs`, {
+    headers,
+  });
+
+  const addressTxs = await response.json();
+
+  if (addressTxs && addressTxs.length > 0) {
+    const latestTx = addressTxs[0];
+
+    const outputIndex: number = latestTx.vout.findIndex(
+      (output: any) => output.scriptpubkey_address === address,
+    );
+
+    if (outputIndex === -1) {
+      return null;
+    }
+
+    return latestTx.txid;
+  }
+  return null;
+}

package/src/utils/network.ts

@@ -0,0 +1,70 @@
+import { NetworkType as Lrc20NetworkType } from "@buildonspark/lrc20-sdk";
+import * as btc from "@scure/btc-signer";
+import * as bitcoin from "bitcoinjs-lib";
+import { Network as NetworkProto } from "../proto/spark.js";
+import { BitcoinNetwork } from "../types/index.js";
+export enum Network {
+  MAINNET,
+  TESTNET,
+  SIGNET,
+  REGTEST,
+  LOCAL,
+}
+
+export type NetworkType = keyof typeof Network;
+
+export const NetworkToProto: Record<Network, NetworkProto> = {
+  [Network.MAINNET]: NetworkProto.MAINNET,
+  [Network.TESTNET]: NetworkProto.TESTNET,
+  [Network.SIGNET]: NetworkProto.SIGNET,
+  [Network.REGTEST]: NetworkProto.REGTEST,
+  [Network.LOCAL]: NetworkProto.REGTEST,
+};
+
+const NetworkConfig: Record<Network, typeof btc.NETWORK> = {
+  [Network.MAINNET]: btc.NETWORK,
+  [Network.TESTNET]: btc.TEST_NETWORK,
+  [Network.SIGNET]: btc.TEST_NETWORK,
+  [Network.REGTEST]: { ...btc.TEST_NETWORK, bech32: "bcrt" },
+  [Network.LOCAL]: { ...btc.TEST_NETWORK, bech32: "bcrt" },
+};
+
+export const getNetwork = (network: Network): typeof btc.NETWORK =>
+  NetworkConfig[network];
+
+export const LRC_WALLET_NETWORK = Object.freeze({
+  [Network.MAINNET]: bitcoin.networks.bitcoin,
+  [Network.TESTNET]: bitcoin.networks.testnet,
+  [Network.SIGNET]: bitcoin.networks.testnet,
+  [Network.REGTEST]: bitcoin.networks.regtest,
+  [Network.LOCAL]: bitcoin.networks.regtest,
+});
+
+export const LRC_WALLET_NETWORK_TYPE = Object.freeze({
+  [Network.MAINNET]: Lrc20NetworkType.MAINNET,
+  [Network.TESTNET]: Lrc20NetworkType.TESTNET,
+  [Network.SIGNET]: Lrc20NetworkType.TESTNET,
+  [Network.REGTEST]: Lrc20NetworkType.REGTEST,
+  [Network.LOCAL]: Lrc20NetworkType.REGTEST,
+});
+
+/**
+ * Utility function to determine the network from a Bitcoin address.
+ *
+ * @param {string} address - The Bitcoin address
+ * @returns {BitcoinNetwork | null} The detected network or null if not detected
+ */
+export function getNetworkFromAddress(address: string) {
+  try {
+    const decoded = bitcoin.address.fromBech32(address);
+    // HRP (human-readable part) determines the network
+    if (decoded.prefix === "bc") {
+      return BitcoinNetwork.MAINNET;
+    } else if (decoded.prefix === "bcrt") {
+      return BitcoinNetwork.REGTEST;
+    }
+  } catch (err) {
+    throw new Error("Invalid Bitcoin address");
+  }
+  return null;
+}

package/src/utils/proof.ts

@@ -0,0 +1,17 @@
+import { sha256 } from "@scure/btc-signer/utils";
+
+export function proofOfPossessionMessageHashForDepositAddress(
+  userPubkey: Uint8Array,
+  operatorPubkey: Uint8Array,
+  depositAddress: string,
+): Uint8Array {
+  const encoder = new TextEncoder();
+  const depositAddressBytes = encoder.encode(depositAddress);
+
+  const proofMsg = new Uint8Array([
+    ...userPubkey,
+    ...operatorPubkey,
+    ...depositAddressBytes,
+  ]);
+  return sha256(proofMsg);
+}

package/src/utils/response-validation.ts

@@ -0,0 +1,26 @@
+export function validateResponses<T>(
+  responses: PromiseSettledResult<T>[],
+): T[] {
+  // Get successful responses
+  const successfulResponses = responses
+    .filter(
+      (result): result is PromiseFulfilledResult<T> =>
+        result.status === "fulfilled",
+    )
+    .map((result) => result.value);
+
+  // If no successful responses, throw with all errors
+  if (successfulResponses.length === 0) {
+    const errors = responses
+      .filter(
+        (result): result is PromiseRejectedResult =>
+          result.status === "rejected",
+      )
+      .map((result) => result.reason)
+      .join("\n");
+
+    throw new Error(`All requests failed.\nErrors:\n${errors}`);
+  }
+
+  return successfulResponses;
+}

package/src/utils/secret-sharing.ts

@@ -0,0 +1,263 @@
+import { bytesToHex, equalBytes } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { getCrypto } from "./crypto.js";
+
+const crypto = getCrypto();
+
+type Polynomial = {
+  fieldModulus: bigint;
+  coefficients: bigint[];
+  proofs: Uint8Array[];
+};
+
+type SecretShare = {
+  fieldModulus: bigint;
+  threshold: number;
+  index: bigint;
+  share: bigint;
+};
+
+export type VerifiableSecretShare = SecretShare & {
+  proofs: Uint8Array[];
+};
+
+export function getRandomBigInt(max: bigint): bigint {
+  const byteLength = (max.toString(2).length + 7) >> 3;
+  const maxBigInt = max;
+
+  const mask = (1n << BigInt(max.toString(2).length)) - 1n;
+  while (true) {
+    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
+
+    const randValue = BigInt("0x" + bytesToHex(randBytes)) & mask;
+
+    if (randValue < maxBigInt) {
+      return randValue;
+    }
+  }
+}
+
+// Modular inverse using extended euclidean algorithm
+export function modInverse(a: bigint, m: bigint): bigint {
+  // Handle negative numbers by making them positive
+  a = ((a % m) + m) % m;
+
+  let [old_r, r] = [a, m];
+  let [old_s, s] = [1n, 0n];
+  let [old_t, t] = [0n, 1n];
+
+  while (r !== 0n) {
+    const quotient = old_r / r;
+    [old_r, r] = [r, old_r - quotient * r];
+    [old_s, s] = [s, old_s - quotient * s];
+    [old_t, t] = [t, old_t - quotient * t];
+  }
+
+  if (old_r !== 1n) {
+    throw new Error("Modular inverse does not exist");
+  }
+
+  return ((old_s % m) + m) % m;
+}
+
+// Evaluates a polynomial at a given point
+export function evaluatePolynomial(polynomial: Polynomial, x: bigint): bigint {
+  let result = 0n;
+  for (let i = 0; i < polynomial.coefficients.length; i++) {
+    const coeff = polynomial.coefficients[i];
+    if (!coeff) {
+      throw new Error("Coefficient is undefined");
+    }
+
+    const xPow = x ** BigInt(i) % polynomial.fieldModulus;
+
+    result = (result + xPow * coeff) % polynomial.fieldModulus;
+  }
+  return result;
+}
+
+// Divides two numbers in a given field modulus
+export function fieldDiv(
+  numerator: bigint,
+  denominator: bigint,
+  fieldModulus: bigint,
+): bigint {
+  if (denominator === 0n) {
+    throw new Error("Division by zero");
+  }
+
+  const inverse = modInverse(denominator, fieldModulus);
+  return (numerator * inverse) % fieldModulus;
+}
+
+// Computes the Lagrange coefficient for a given index and a set of points
+export function computerLagrangeCoefficients(
+  index: bigint,
+  points: SecretShare[],
+) {
+  let numerator = 1n;
+  let denominator = 1n;
+  let fieldModulus = points[0]?.fieldModulus;
+  if (!fieldModulus) {
+    throw new Error("Field modulus is undefined");
+  }
+
+  for (const point of points) {
+    if (point.index === index) {
+      continue;
+    }
+    numerator = numerator * point.index;
+    const value = point.index - index;
+    denominator = denominator * value;
+  }
+
+  return fieldDiv(numerator, denominator, fieldModulus);
+}
+
+// Generates a polynomial for secret sharing
+export function generatePolynomialForSecretSharing(
+  fieldModulus: bigint,
+  secret: bigint,
+  degree: number,
+): Polynomial {
+  const coefficients: bigint[] = new Array(degree);
+  const proofs: Uint8Array[] = new Array(degree);
+
+  coefficients[0] = secret;
+  proofs[0] = secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
+
+  for (let i = 1; i < degree; i++) {
+    const coefficient = getRandomBigInt(fieldModulus);
+    coefficients[i] = coefficient;
+    proofs[i] =
+      secp256k1.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
+  }
+  return {
+    fieldModulus,
+    coefficients,
+    proofs: proofs,
+  };
+}
+
+// Splits a secret into a list of shares
+export function splitSecret(
+  fieldModulus: bigint,
+  secret: bigint,
+  threshold: number,
+  numberOfShares: number,
+) {
+  const polynomial = generatePolynomialForSecretSharing(
+    fieldModulus,
+    secret,
+    threshold,
+  );
+
+  const shares: SecretShare[] = [];
+  for (let i = 1; i <= numberOfShares; i++) {
+    const share = evaluatePolynomial(polynomial, BigInt(i));
+    shares.push({
+      fieldModulus,
+      threshold,
+      index: BigInt(i),
+      share,
+    });
+  }
+
+  return shares;
+}
+
+// Splits a secret into a list of shares with proofs
+export function splitSecretWithProofs(
+  secret: bigint,
+  fieldModulus: bigint,
+  threshold: number,
+  numberOfShares: number,
+) {
+  const polynomial = generatePolynomialForSecretSharing(
+    fieldModulus,
+    secret,
+    threshold - 1,
+  );
+
+  const shares: VerifiableSecretShare[] = [];
+  for (let i = 1; i <= numberOfShares; i++) {
+    const share = evaluatePolynomial(polynomial, BigInt(i));
+    shares.push({
+      fieldModulus,
+      threshold,
+      index: BigInt(i),
+      share,
+      proofs: polynomial.proofs,
+    });
+  }
+
+  return shares;
+}
+
+// Recovers a secret from a list of shares
+export function recoverSecret(shares: VerifiableSecretShare[]) {
+  if (shares.length === 0) return 0n;
+
+  const threshold = shares[0]?.threshold;
+  const fieldModulus = shares[0]?.fieldModulus;
+
+  if (!threshold || !fieldModulus) {
+    throw new Error("Shares are not valid");
+  }
+
+  if (shares.length < threshold) {
+    throw new Error("Not enough shares to recover secret");
+  }
+
+  let result = 0n;
+  for (const share of shares) {
+    const coeff = computerLagrangeCoefficients(share.index, shares);
+    const item = (share.share * coeff) % fieldModulus;
+
+    result = (result + item) % fieldModulus;
+  }
+
+  return result;
+}
+
+// Validates a share of a secret
+export function validateShare(share: VerifiableSecretShare) {
+  const targetPubkey = secp256k1.ProjectivePoint.fromPrivateKey(
+    share.share,
+  ).toRawBytes(true);
+
+  let resultPubkey = share.proofs[0];
+  if (!resultPubkey) {
+    throw new Error("Result pubkey is not valid");
+  }
+
+  for (let i = 1; i < share.proofs.length; i++) {
+    const pubkey = share.proofs[i];
+    if (!pubkey) {
+      throw new Error("Pubkey is not valid");
+    }
+    const value = share.index ** BigInt(i) % share.fieldModulus;
+
+    const scaledPoint =
+      secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
+    resultPubkey = secp256k1.ProjectivePoint.fromHex(resultPubkey)
+      .add(scaledPoint)
+      .toRawBytes(true);
+  }
+
+  if (!equalBytes(resultPubkey, targetPubkey)) {
+    throw new Error("Share is not valid");
+  }
+}
+
+// Converts a bigint to a private key since imported package doesn't support bigint
+export function bigIntToPrivateKey(value: bigint): Uint8Array {
+  const hex = value.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;
+}

package/src/utils/signing.ts

@@ -0,0 +1,96 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import type { SigningCommitment, SigningNonce } from "../signer/signer.js";
+import {
+  SigningCommitment as WasmSigningCommitment,
+  SigningNonce as WasmSigningNonce,
+} from "../wasm/spark_bindings.js";
+
+export function getRandomSigningNonce(): SigningNonce {
+  const binding = secp256k1.utils.randomPrivateKey();
+  const hiding = secp256k1.utils.randomPrivateKey();
+  return createSigningNonce(binding, hiding);
+}
+
+export function createSigningNonce(
+  binding: Uint8Array,
+  hiding: Uint8Array,
+): SigningNonce {
+  if (binding.length !== 32 || hiding.length !== 32) {
+    throw new Error("Invalid nonce length");
+  }
+
+  return {
+    binding,
+    hiding,
+  };
+}
+
+export function getSigningCommitmentFromNonce(
+  nonce: SigningNonce,
+): SigningCommitment {
+  const bindingPubKey = secp256k1.getPublicKey(nonce.binding, true);
+  const hidingPubKey = secp256k1.getPublicKey(nonce.hiding, true);
+  return {
+    binding: bindingPubKey,
+    hiding: hidingPubKey,
+  };
+}
+
+export function encodeSigningNonceToBytes(nonce: SigningNonce): Uint8Array {
+  return new Uint8Array([...nonce.binding, ...nonce.hiding]);
+}
+
+export function decodeBytesToSigningNonce(bytes: Uint8Array): SigningNonce {
+  if (bytes.length !== 64) {
+    throw new Error("Invalid nonce length");
+  }
+  return {
+    binding: bytes.slice(32, 64),
+    hiding: bytes.slice(0, 32),
+  };
+}
+
+export function createSigningCommitment(
+  binding: Uint8Array,
+  hiding: Uint8Array,
+): SigningCommitment {
+  if (binding.length !== 33 || hiding.length !== 33) {
+    throw new Error("Invalid nonce commitment length");
+  }
+  return {
+    binding,
+    hiding,
+  };
+}
+
+export function encodeSigningCommitmentToBytes(
+  commitment: SigningCommitment,
+): Uint8Array {
+  if (commitment.binding.length !== 33 || commitment.hiding.length !== 33) {
+    throw new Error("Invalid nonce commitment length");
+  }
+
+  return new Uint8Array([...commitment.binding, ...commitment.hiding]);
+}
+
+export function decodeBytesToSigningCommitment(
+  bytes: Uint8Array,
+): SigningCommitment {
+  if (bytes.length !== 66) {
+    throw new Error("Invalid nonce commitment length");
+  }
+  return {
+    binding: bytes.slice(33, 66),
+    hiding: bytes.slice(0, 33),
+  };
+}
+
+export function createWasmSigningNonce(nonce: SigningNonce): WasmSigningNonce {
+  return new WasmSigningNonce(nonce.hiding, nonce.binding);
+}
+
+export function createWasmSigningCommitment(
+  commitment: SigningCommitment,
+): WasmSigningCommitment {
+  return new WasmSigningCommitment(commitment.hiding, commitment.binding);
+}