@buildonspark/spark-sdk 0.0.15 → 0.0.16

package/src/tests/utils/test-faucet.ts

@@ -0,0 +1,257 @@
+import { bytesToHex, hexToBytes } from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { Address, OutScript, SigHash, Transaction } from "@scure/btc-signer";
+import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt";
+import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
+import {
+  getP2TRAddressFromPublicKey,
+  getP2TRScriptFromPublicKey,
+} from "../../utils/bitcoin.js";
+import { getNetwork, Network } from "../../utils/network.js";
+import { SparkWallet } from "../../spark-sdk.js";
+import { sha256 } from "@noble/hashes/sha256";
+import * as btc from "@scure/btc-signer";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+
+export type FaucetCoin = {
+  key: Uint8Array;
+  outpoint: TransactionInput;
+  txout: TransactionOutput;
+};
+
+const COIN_AMOUNT = 10_000_000n;
+
+export class BitcoinFaucet {
+  private coins: FaucetCoin[] = [];
+  private static instance: BitcoinFaucet | null = null;
+
+  constructor(
+    private url: string,
+    private username: string,
+    private password: string,
+  ) {
+    if (BitcoinFaucet.instance) {
+      return BitcoinFaucet.instance;
+    }
+
+    BitcoinFaucet.instance = this;
+  }
+
+  async fund() {
+    // If no coins available, refill the faucet
+    if (this.coins.length === 0) {
+      await this.refill();
+    }
+
+    // Take the first coin from the faucet
+    const coin = this.coins[0];
+    // Remove the used coin from the array
+    this.coins = this.coins.slice(1);
+
+    return coin;
+  }
+
+  async refill() {
+    // Generate key for initial block reward
+    const key = secp256k1.utils.randomPrivateKey();
+    const pubKey = secp256k1.getPublicKey(key);
+    const address = getP2TRAddressFromPublicKey(pubKey, Network.LOCAL);
+
+    // Mine a block to this address
+    const blockHash = await this.generateToAddress(1, address);
+
+    // Get block and funding transaction
+    const block = await this.getBlock(blockHash[0]);
+    const fundingTx = Transaction.fromRaw(hexToBytes(block.tx[0].hex), {
+      allowUnknownOutputs: true,
+    });
+
+    // Mine 100 blocks to make funds spendable
+    const randomKey = secp256k1.utils.randomPrivateKey();
+    const randomPubKey = secp256k1.getPublicKey(randomKey);
+    const randomAddress = getP2TRAddressFromPublicKey(
+      randomPubKey,
+      Network.LOCAL,
+    );
+    await this.generateToAddress(100, randomAddress);
+
+    const fundingTxId = block.tx[0].txid;
+    const fundingOutpoint: TransactionInput = {
+      txid: fundingTxId,
+      index: 0,
+    };
+
+    const splitTx = new Transaction();
+    splitTx.addInput(fundingOutpoint);
+    let initialValue = fundingTx.getOutput(0)!.amount!;
+    const coinAmount = 10_000_000n;
+    const coinKeys: Uint8Array[] = [];
+
+    while (initialValue > coinAmount + 100_000n) {
+      const coinKey = secp256k1.utils.randomPrivateKey();
+      const coinPubKey = secp256k1.getPublicKey(coinKey);
+      coinKeys.push(coinKey);
+
+      const script = getP2TRScriptFromPublicKey(coinPubKey, Network.LOCAL);
+      splitTx.addOutput({
+        script,
+        amount: coinAmount,
+      });
+      initialValue -= coinAmount;
+    }
+    // Sign and broadcast
+    const signedSplitTx = await this.signFaucetCoin(
+      splitTx,
+      fundingTx.getOutput(0)!,
+      key,
+    );
+
+    await this.broadcastTx(bytesToHex(signedSplitTx.extract()));
+
+    // Create faucet coins
+    const splitTxId = signedSplitTx.id;
+    for (let i = 0; i < signedSplitTx.outputsLength; i++) {
+      this.coins.push({
+        // @ts-ignore - It's a test file
+        key: coinKeys[i],
+        outpoint: {
+          txid: hexToBytes(splitTxId),
+          index: i,
+        },
+        txout: signedSplitTx.getOutput(i)!,
+      });
+    }
+  }
+  async sendFaucetCoinToP2WPKHAddress(pubKey: Uint8Array) {
+    const sendToPubKeyTx = new Transaction();
+
+    // For P2WPKH, we need to hash the public key
+
+    // Create a P2WPKH address
+    const p2wpkhAddress = btc.p2wpkh(pubKey, getNetwork(Network.LOCAL)).address;
+    if (!p2wpkhAddress) {
+      throw new Error("Invalid P2WPKH address");
+    }
+
+    // Get the coin to spend
+    const coinToSend = await this.fund();
+    if (!coinToSend) {
+      throw new Error("No coins available");
+    }
+
+    // Add the input
+    sendToPubKeyTx.addInput(coinToSend.outpoint);
+
+    // Add the output using the address directly
+    sendToPubKeyTx.addOutputAddress(
+      p2wpkhAddress,
+      100_000n,
+      getNetwork(Network.LOCAL),
+    );
+
+    // Sign the transaction and get the signed result
+    const signedTx = await this.signFaucetCoin(
+      sendToPubKeyTx,
+      coinToSend.txout,
+      coinToSend.key,
+    );
+
+    // Broadcast the signed transaction
+    await this.broadcastTx(bytesToHex(signedTx.extract()));
+  }
+
+  async signFaucetCoin(
+    unsignedTx: Transaction,
+    fundingTxOut: TransactionOutput,
+    key: Uint8Array,
+  ): Promise<Transaction> {
+    const pubKey = secp256k1.getPublicKey(key);
+    const internalKey = pubKey.slice(1); // Remove the 0x02/0x03 prefix
+
+    const script = getP2TRScriptFromPublicKey(pubKey, Network.LOCAL);
+
+    unsignedTx.updateInput(0, {
+      tapInternalKey: internalKey,
+      witnessUtxo: {
+        script,
+        amount: fundingTxOut.amount!,
+      },
+    });
+
+    const sighash = unsignedTx.preimageWitnessV1(
+      0,
+      new Array(unsignedTx.inputsLength).fill(script),
+      SigHash.DEFAULT,
+      new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount!),
+    );
+
+    const merkleRoot = new Uint8Array();
+    const tweakedKey = taprootTweakPrivKey(key, merkleRoot);
+    if (!tweakedKey)
+      throw new Error("Invalid private key for taproot tweaking");
+
+    const signature = schnorr.sign(sighash, tweakedKey);
+
+    unsignedTx.updateInput(0, {
+      tapKeySig: signature,
+    });
+
+    unsignedTx.finalize();
+
+    return unsignedTx;
+  }
+
+  // MineBlocks mines the specified number of blocks to a random address
+  // and returns the block hashes.
+  async mineBlocks(numBlocks: number) {
+    // Mine 100 blocks to make funds spendable
+    const randomKey = secp256k1.utils.randomPrivateKey();
+    const randomPubKey = secp256k1.getPublicKey(randomKey);
+    const randomAddress = getP2TRAddressFromPublicKey(
+      randomPubKey,
+      Network.LOCAL,
+    );
+    return await this.generateToAddress(100, randomAddress);
+  }
+
+  private async call(method: string, params: any[]) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Basic " + btoa(`${this.username}:${this.password}`),
+        },
+        body: JSON.stringify({
+          jsonrpc: "1.0",
+          id: "spark-js",
+          method,
+          params,
+        }),
+      });
+
+      const data = await response.json();
+      if (data.error) {
+        console.error(`RPC Error for method ${method}:`, data.error);
+        throw new Error(`Bitcoin RPC error: ${data.error.message}`);
+      }
+
+      return data.result;
+    } catch (error) {
+      console.error("Error calling Bitcoin RPC:", error);
+      throw error;
+    }
+  }
+
+  async generateToAddress(numBlocks: number, address: string) {
+    return await this.call("generatetoaddress", [numBlocks, address]);
+  }
+
+  async getBlock(blockHash: string) {
+    return await this.call("getblock", [blockHash, 2]);
+  }
+
+  async broadcastTx(txHex: string) {
+    return await this.call("sendrawtransaction", [txHex, 0]);
+  }
+}

package/src/types/grpc.ts

@@ -0,0 +1,8 @@
+import { CallOptions } from "nice-grpc";
+
+export interface RetryOptions {
+  retry?: boolean;
+  retryMaxAttempts?: number;
+}
+
+export type SparkCallOptions = CallOptions & RetryOptions;

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "../graphql/objects/index.js";
+export * as CommonProto from "../proto/common.js";
+export * as SparkProto from "../proto/spark.js";

package/src/utils/adaptor-signature.ts

@@ -0,0 +1,189 @@
+import { mod } from "@noble/curves/abstract/modular";
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+
+export function generateSignatureFromExistingAdaptor(
+  signature: Uint8Array,
+  adaptorPrivateKeyBytes: Uint8Array,
+): Uint8Array {
+  const { r, s } = parseSignature(signature);
+
+  const sBigInt = bytesToNumberBE(s);
+  const tBigInt = bytesToNumberBE(adaptorPrivateKeyBytes);
+
+  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
+
+  const newSignature = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
+
+  return newSignature;
+}
+
+export function generateAdaptorFromSignature(signature: Uint8Array): {
+  adaptorSignature: Uint8Array;
+  adaptorPrivateKey: Uint8Array;
+} {
+  const adaptorPrivateKey = secp256k1.utils.randomPrivateKey();
+
+  const { r, s } = parseSignature(signature);
+
+  const sBigInt = bytesToNumberBE(s);
+  const tBigInt = bytesToNumberBE(adaptorPrivateKey);
+
+  // Calculate s - adaptorPrivateKey
+  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
+
+  const newSignature = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
+
+  return {
+    adaptorSignature: newSignature,
+    adaptorPrivateKey: adaptorPrivateKey,
+  };
+}
+
+export function validateOutboundAdaptorSignature(
+  pubkey: Uint8Array,
+  hash: Uint8Array,
+  signature: Uint8Array,
+  adaptorPubkey: Uint8Array,
+): boolean {
+  return schnorrVerifyWithAdaptor(
+    signature,
+    hash,
+    pubkey,
+    adaptorPubkey,
+    false,
+  );
+}
+
+export function applyAdaptorToSignature(
+  pubkey: Uint8Array,
+  hash: Uint8Array,
+  signature: Uint8Array,
+  adaptorPrivateKeyBytes: Uint8Array,
+): Uint8Array {
+  // Parse the signature
+  const { r, s } = parseSignature(signature);
+
+  // Convert values to bigints
+  const sBigInt = bytesToNumberBE(s);
+  const adaptorPrivateKey = bytesToNumberBE(adaptorPrivateKeyBytes);
+
+  // Try adding adaptor to s first
+  const newS = mod(sBigInt + adaptorPrivateKey, secp256k1.CURVE.n);
+  const newSig = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
+
+  if (schnorr.verify(newSig, hash, pubkey)) {
+    return newSig;
+  }
+
+  // If adding didn't work, try subtracting
+  const altS = mod(sBigInt - adaptorPrivateKey, secp256k1.CURVE.n);
+  const altSig = new Uint8Array([...r, ...numberToBytesBE(altS, 32)]);
+
+  if (schnorr.verify(altSig, hash, pubkey)) {
+    return altSig;
+  }
+
+  throw new Error("Cannot apply adaptor to signature");
+}
+
+// Step 1: P = lift_x(int(pk))
+// Step 2: r = int(sig[0:32])
+// Step 3: s = int(sig[32:64])
+// Step 4: e = int(tagged_hash("BIP0340/challenge", bytes(r) || bytes(P) || m)) mod n
+// Step 5: R = sG - eP
+// Step 6: R = R + T
+function schnorrVerifyWithAdaptor(
+  signature: Uint8Array,
+  hash: Uint8Array,
+  pubKeyBytes: Uint8Array,
+  adaptorPubkey: Uint8Array,
+  inbound: boolean,
+): boolean {
+  // Step 1: Verify message length
+  if (hash.length !== 32) {
+    throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
+  }
+
+  // Step 2: Lift x coordinate to curve point
+  const pubKey = schnorr.utils.lift_x(bytesToNumberBE(pubKeyBytes));
+  pubKey.assertValidity();
+
+  // Parse signature
+  // Step 3 and 4 is handled by parseSignature
+  const { r, s } = parseSignature(signature);
+
+  // Step 5: Compute challenge
+  const commitmenet = schnorr.utils.taggedHash(
+    "BIP0340/challenge",
+    r,
+    pubKey.toRawBytes().slice(1),
+    hash,
+  );
+  if (commitmenet.length > 32) {
+    throw new Error("hash of (r || P || m) too big");
+  }
+
+  const e = mod(bytesToNumberBE(commitmenet), secp256k1.CURVE.n);
+  const negE = mod(-e, secp256k1.CURVE.n); // Negate e before multiplication
+
+  // Step 6: Calculate R = sG - eP
+  const R = secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
+    pubKey,
+    bytesToNumberBE(s),
+    negE,
+  );
+  if (!R) {
+    throw new Error("R is undefined");
+  }
+
+  R.assertValidity();
+
+  // Step 6.5: Add adaptor public key T to R
+  const adaptorPoint = secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
+  const newR = R.add(adaptorPoint);
+
+  // Step 7: Check for point at infinity (if not inbound)
+  if (!inbound && newR.equals(secp256k1.ProjectivePoint.ZERO)) {
+    throw new Error("calculated R point is the point at infinity");
+  }
+
+  // Step 8: Check if R.y is odd
+  newR.assertValidity();
+  if (!newR.hasEvenY()) {
+    throw new Error("calculated R y-value is odd");
+  }
+
+  // Step 9: Check if R.x == r
+  const rNum = bytesToNumberBE(r);
+  if (newR.toAffine().x !== rNum) {
+    throw new Error("calculated R point was not given R");
+  }
+
+  return true;
+}
+
+function parseSignature(signature: Uint8Array): {
+  r: Uint8Array;
+  s: Uint8Array;
+} {
+  if (signature.length < 64) {
+    throw new Error(`malformed signature: too short: ${signature.length} < 64`);
+  }
+  if (signature.length > 64) {
+    throw new Error(`malformed signature: too long: ${signature.length} > 64`);
+  }
+
+  const r = signature.slice(0, 32);
+  const s = signature.slice(32, 64);
+
+  if (bytesToNumberBE(r) >= secp256k1.CURVE.Fp.ORDER) {
+    throw new Error(`invalid signature: r >= field prime`);
+  }
+
+  if (bytesToNumberBE(s) >= secp256k1.CURVE.n) {
+    throw new Error(`invalid signature: s >= group order`);
+  }
+
+  return { r, s };
+}

package/src/utils/bitcoin.ts

@@ -0,0 +1,138 @@
+import {
+  bytesToHex,
+  bytesToNumberBE,
+  hexToBytes,
+} from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+
+import * as btc from "@scure/btc-signer";
+import { TransactionOutput } from "@scure/btc-signer/psbt";
+import { sha256 } from "@scure/btc-signer/utils";
+import { getNetwork, Network } from "./network.js";
+
+// const t = tapTweak(pubKey, h); // t = int_from_bytes(tagged_hash("TapTweak", pubkey + h)
+// const P = u.lift_x(u.bytesToNumberBE(pubKey)); // P = lift_x(int_from_bytes(pubkey))
+// const Q = P.add(Point.fromPrivateKey(t)); // Q = point_add(P, point_mul(G, t))
+export function computeTaprootKeyNoScript(pubkey: Uint8Array): Uint8Array {
+  if (pubkey.length !== 32) {
+    throw new Error("Public key must be 32 bytes");
+  }
+
+  const taggedHash = schnorr.utils.taggedHash("TapTweak", pubkey);
+  const tweak = bytesToNumberBE(taggedHash);
+
+  // Get the original point
+  const P = schnorr.utils.lift_x(schnorr.utils.bytesToNumberBE(pubkey));
+
+  // Add the tweak times the generator point
+  const Q = P.add(secp256k1.ProjectivePoint.fromPrivateKey(tweak));
+
+  return Q.toRawBytes();
+}
+
+export function getP2TRScriptFromPublicKey(
+  pubKey: Uint8Array,
+  network: Network,
+): Uint8Array {
+  if (pubKey.length !== 33) {
+    throw new Error("Public key must be 33 bytes");
+  }
+
+  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
+  const script = btc.p2tr(
+    internalKey.toRawBytes().slice(1, 33),
+    undefined,
+    getNetwork(network),
+  ).script;
+  if (!script) {
+    throw new Error("Failed to get P2TR address");
+  }
+  return script;
+}
+
+export function getP2TRAddressFromPublicKey(
+  pubKey: Uint8Array,
+  network: Network,
+): string {
+  if (pubKey.length !== 33) {
+    throw new Error("Public key must be 33 bytes");
+  }
+
+  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
+  const address = btc.p2tr(
+    internalKey.toRawBytes().slice(1, 33),
+    undefined,
+    getNetwork(network),
+  ).address;
+  if (!address) {
+    throw new Error("Failed to get P2TR address");
+  }
+  return address;
+}
+
+export function getP2TRAddressFromPkScript(
+  pkScript: Uint8Array,
+  network: Network,
+): string {
+  if (pkScript.length !== 34 || pkScript[0] !== 0x51 || pkScript[1] !== 0x20) {
+    throw new Error("Invalid pkscript");
+  }
+
+  const parsedScript = btc.OutScript.decode(pkScript);
+
+  return btc.Address(getNetwork(network)).encode(parsedScript);
+}
+
+export function getTxFromRawTxHex(rawTxHex: string): btc.Transaction {
+  const txBytes = hexToBytes(rawTxHex);
+  const tx = btc.Transaction.fromRaw(txBytes, {
+    allowUnknownOutputs: true,
+  });
+
+  if (!tx) {
+    throw new Error("Failed to parse transaction");
+  }
+  return tx;
+}
+
+export function getTxFromRawTxBytes(rawTxBytes: Uint8Array): btc.Transaction {
+  const tx = btc.Transaction.fromRaw(rawTxBytes, {
+    allowUnknownOutputs: true,
+  });
+  if (!tx) {
+    throw new Error("Failed to parse transaction");
+  }
+  return tx;
+}
+
+export function getSigHashFromTx(
+  tx: btc.Transaction,
+  inputIndex: number,
+  prevOutput: TransactionOutput,
+): Uint8Array {
+  // For Taproot, we use preimageWitnessV1 with SIGHASH_DEFAULT (0x00)
+  const prevScript = prevOutput.script;
+  if (!prevScript) {
+    throw new Error("No script found in prevOutput");
+  }
+
+  const amount = prevOutput.amount;
+  if (!amount) {
+    throw new Error("No amount found in prevOutput");
+  }
+
+  return tx.preimageWitnessV1(
+    inputIndex,
+    new Array(tx.inputsLength).fill(prevScript),
+    btc.SigHash.DEFAULT,
+    new Array(tx.inputsLength).fill(amount),
+  );
+}
+
+export function getTxId(tx: btc.Transaction): string {
+  return bytesToHex(sha256(sha256(tx.unsignedTx)).reverse());
+}
+
+export function getTxIdNoReverse(tx: btc.Transaction): string {
+  return bytesToHex(sha256(sha256(tx.unsignedTx)));
+}

package/src/utils/crypto.ts

@@ -0,0 +1,14 @@
+import crypto from "crypto";
+
+export const getCrypto = (): Crypto => {
+  // Browser environment
+  if (typeof window !== "undefined" && window.crypto) {
+    return window.crypto;
+  }
+  // Node.js environment
+  if (typeof global !== "undefined" && global.crypto) {
+    return global.crypto;
+  }
+  // Node.js environment without global.crypto (older versions)
+  return crypto as Crypto;
+};

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export * from "./adaptor-signature.js";
+export * from "./bitcoin.js";
+export * from "./keys.js";
+export * from "./mempool.js";
+export * from "./network.js";
+export * from "./proof.js";
+export * from "./response-validation.js";
+export * from "./secret-sharing.js";
+export * from "./signing.js";
+export * from "./transaction.js";
+export * from "./wasm-wrapper.js";
+export * from "./wasm.js";