@buildonspark/spark-sdk 0.0.8 → 0.0.9

package/dist/chunk-F4JW24C4.js

@@ -0,0 +1,78 @@
+import {
+  getP2TRScriptFromPublicKey
+} from "./chunk-NDKNVHGP.js";
+import {
+  spark_bindings_default
+} from "./chunk-COXVABEU.js";
+
+// src/utils/transaction.ts
+import { Transaction } from "@scure/btc-signer";
+var TIME_LOCK_INTERVAL = 100;
+function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
+  const newRefundTx = new Transaction({ allowUnknownOutputs: true });
+  newRefundTx.addInput({
+    ...nodeOutPoint,
+    sequence
+  });
+  const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
+  newRefundTx.addOutput({
+    script: refundPkScript,
+    amount: amountSats
+  });
+  newRefundTx.addOutput(getEphemeralAnchorOutput());
+  return newRefundTx;
+}
+function getNextTransactionSequence(currSequence) {
+  const currentTimelock = (currSequence || 0) & 65535;
+  if (currentTimelock - TIME_LOCK_INTERVAL <= 0) {
+    throw new Error("timelock interval is less or equal to 0");
+  }
+  return 1 << 30 | currentTimelock - TIME_LOCK_INTERVAL;
+}
+function getEphemeralAnchorOutput() {
+  return {
+    script: new Uint8Array([81]),
+    // OP_TRUE
+    amount: 0n
+  };
+}
+
+// src/utils/wasm-wrapper.ts
+async function initWasm() {
+  let wasmModule;
+  try {
+    if (typeof window === "undefined") {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const { fileURLToPath } = await import("url");
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      const wasmPath = path.resolve(
+        __dirname,
+        "../wasm/spark_bindings_bg.wasm"
+      );
+      const wasmBuffer = await fs.readFile(wasmPath);
+      wasmModule = await spark_bindings_default({ module_or_path: wasmBuffer }).catch((e) => {
+        console.error("WASM initialization error:", e);
+        throw e;
+      });
+      return wasmModule;
+    } else {
+      wasmModule = await spark_bindings_default();
+    }
+  } catch (e) {
+    console.error("WASM initialization error:", e);
+    throw e;
+  }
+  if (!wasmModule || typeof wasmModule !== "object") {
+    throw new Error("WASM module not properly initialized");
+  }
+  return wasmModule;
+}
+
+export {
+  createRefundTx,
+  getNextTransactionSequence,
+  getEphemeralAnchorOutput,
+  initWasm
+};

package/dist/chunk-H4A2WXR3.js

@@ -0,0 +1,331 @@
+import {
+  KeyPackage,
+  aggregateFrost,
+  createWasmSigningCommitment,
+  createWasmSigningNonce,
+  generateAdaptorFromSignature,
+  getMasterHDKeyFromSeed,
+  getRandomSigningNonce,
+  getSigningCommitmentFromNonce,
+  signFrost,
+  splitSecretWithProofs,
+  subtractPrivateKeys
+} from "./chunk-HTNOFUHX.js";
+
+// src/signer/signer.ts
+import {
+  bytesToHex,
+  bytesToNumberBE,
+  hexToBytes
+} from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import * as bip39 from "@scure/bip39";
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { sha256 } from "@scure/btc-signer/utils";
+import { Buffer } from "buffer";
+import * as ecies from "eciesjs";
+globalThis.Buffer = Buffer;
+var DefaultSparkSigner = class {
+  identityPrivateKey = null;
+  // <hex, hex>
+  publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
+  commitmentToNonceMap = /* @__PURE__ */ new Map();
+  deriveSigningKey(hash) {
+    if (!this.identityPrivateKey) {
+      throw new Error("Private key is not set");
+    }
+    let amount = 0;
+    for (let i = 0; i < 8; i++) {
+      const view = new DataView(hash.buffer, i * 4, 4);
+      amount += view.getUint32(0, false);
+      amount = amount % 2147483648;
+    }
+    const newPrivateKey = this.identityPrivateKey.deriveChild(
+      Number(amount) + 2147483648
+    ).privateKey;
+    if (!newPrivateKey) {
+      throw new Error("Failed to recover signing key");
+    }
+    return newPrivateKey;
+  }
+  async restoreSigningKeysFromLeafs(leafs) {
+    if (!this.identityPrivateKey) {
+      throw new Error("Private key is not set");
+    }
+    for (const leaf of leafs) {
+      const hash = sha256(leaf.id);
+      const privateKey = this.deriveSigningKey(hash);
+      const publicKey = secp256k1.getPublicKey(privateKey);
+      this.publicKeyToPrivateKeyMap.set(
+        bytesToHex(publicKey),
+        bytesToHex(privateKey)
+      );
+    }
+  }
+  async getSchnorrPublicKey(publicKey) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+    return schnorr.getPublicKey(hexToBytes(privateKey));
+  }
+  async signSchnorr(message, publicKey) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+    return schnorr.sign(message, hexToBytes(privateKey));
+  }
+  async signSchnorrWithIdentityKey(message) {
+    if (!this.identityPrivateKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    const signature = schnorr.sign(message, this.identityPrivateKey.privateKey);
+    return signature;
+  }
+  async getIdentityPublicKey() {
+    if (!this.identityPrivateKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    return secp256k1.getPublicKey(this.identityPrivateKey.privateKey);
+  }
+  async generateMnemonic() {
+    return generateMnemonic(wordlist);
+  }
+  async createSparkWalletFromMnemonic(mnemonic, network) {
+    const seed = await bip39.mnemonicToSeed(mnemonic);
+    return this.createSparkWalletFromSeed(seed, network);
+  }
+  async getTrackedPublicKeys() {
+    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(hexToBytes);
+  }
+  async generatePublicKey(hash) {
+    if (!this.identityPrivateKey) {
+      throw new Error("Private key is not set");
+    }
+    let newPrivateKey = null;
+    if (hash) {
+      newPrivateKey = this.deriveSigningKey(hash);
+    } else {
+      newPrivateKey = secp256k1.utils.randomPrivateKey();
+    }
+    if (!newPrivateKey) {
+      throw new Error("Failed to generate new private key");
+    }
+    const publicKey = secp256k1.getPublicKey(newPrivateKey);
+    const pubKeyHex = bytesToHex(publicKey);
+    const privKeyHex = bytesToHex(newPrivateKey);
+    this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
+    return publicKey;
+  }
+  async removePublicKey(publicKey) {
+    this.publicKeyToPrivateKeyMap.delete(bytesToHex(publicKey));
+  }
+  async subtractPrivateKeysGivenPublicKeys(first, second) {
+    const firstPubKeyHex = bytesToHex(first);
+    const secondPubKeyHex = bytesToHex(second);
+    const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
+    const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
+    if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
+      throw new Error("Private key is not set");
+    }
+    const firstPrivateKey = hexToBytes(firstPrivateKeyHex);
+    const secondPrivateKey = hexToBytes(secondPrivateKeyHex);
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey
+    );
+    const resultPubKey = secp256k1.getPublicKey(resultPrivKey);
+    const resultPrivKeyHex = bytesToHex(resultPrivKey);
+    const resultPubKeyHex = bytesToHex(resultPubKey);
+    this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
+    return resultPubKey;
+  }
+  async splitSecretWithProofs({
+    secret,
+    curveOrder,
+    threshold,
+    numShares,
+    isSecretPubkey = false
+  }) {
+    if (isSecretPubkey) {
+      const pubKeyHex = bytesToHex(secret);
+      const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
+      if (!privateKey) {
+        throw new Error("Private key is not set");
+      }
+      secret = hexToBytes(privateKey);
+    }
+    const secretAsInt = bytesToNumberBE(secret);
+    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
+  }
+  async signFrost({
+    message,
+    privateAsPubKey,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey
+  }) {
+    const privateAsPubKeyHex = bytesToHex(privateAsPubKey);
+    const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
+    if (!signingPrivateKey) {
+      throw new Error("Private key is not set");
+    }
+    const nonce = this.commitmentToNonceMap.get(selfCommitment);
+    if (!nonce) {
+      throw new Error("Nonce is not set");
+    }
+    const keyPackage = new KeyPackage(
+      hexToBytes(signingPrivateKey),
+      publicKey,
+      verifyingKey
+    );
+    return signFrost({
+      msg: message,
+      keyPackage,
+      nonce: createWasmSigningNonce(nonce),
+      selfCommitment: createWasmSigningCommitment(selfCommitment),
+      statechainCommitments,
+      adaptorPubKey
+    });
+  }
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys
+  }) {
+    return aggregateFrost({
+      msg: message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment: createWasmSigningCommitment(selfCommitment),
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey
+    });
+  }
+  async createSparkWalletFromSeed(seed, network) {
+    if (typeof seed === "string") {
+      seed = hexToBytes(seed);
+    }
+    const hdkey = getMasterHDKeyFromSeed(
+      seed,
+      network == 3 /* REGTEST */ ? 0 : 1
+    );
+    if (!hdkey.privateKey) {
+      throw new Error("Could not derive private key from seed");
+    }
+    this.identityPrivateKey = hdkey;
+    return bytesToHex(secp256k1.getPublicKey(hdkey.privateKey, true));
+  }
+  async signMessageWithPublicKey(message, publicKey, compact) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error(
+        `No private key found for public key: ${bytesToHex(publicKey)}`
+      );
+    }
+    const signature = secp256k1.sign(message, hexToBytes(privateKey));
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+    return signature.toDERRawBytes();
+  }
+  async signMessageWithIdentityKey(message, compact) {
+    if (!this.identityPrivateKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    const signature = secp256k1.sign(
+      message,
+      this.identityPrivateKey.privateKey
+    );
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+    return signature.toDERRawBytes();
+  }
+  async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
+    const publicKeyHex = bytesToHex(publicKey);
+    const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+    return ecies.encrypt(receiverPublicKey, hexToBytes(privateKey));
+  }
+  async decryptEcies(ciphertext) {
+    if (!this.identityPrivateKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
+      bytesToHex(this.identityPrivateKey.privateKey)
+    );
+    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
+    const publicKey = secp256k1.getPublicKey(privateKey);
+    const publicKeyHex = bytesToHex(publicKey);
+    const privateKeyHex = bytesToHex(privateKey);
+    this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
+    return publicKey;
+  }
+  async getRandomSigningCommitment() {
+    const nonce = getRandomSigningNonce();
+    const commitment = getSigningCommitmentFromNonce(nonce);
+    this.commitmentToNonceMap.set(commitment, nonce);
+    return commitment;
+  }
+  // Hardcode this for default ssp
+  async getSspIdentityPublicKey(network) {
+    if (network === 0 /* MAINNET */) {
+      return hexToBytes(
+        "02e0b8d42c5d3b5fe4c5beb6ea796ab3bc8aaf28a3d3195407482c67e0b58228a5"
+      );
+    } else {
+      return hexToBytes(
+        "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4"
+      );
+    }
+  }
+  async hashRandomPrivateKey() {
+    return sha256(secp256k1.utils.randomPrivateKey());
+  }
+  async generateAdaptorFromSignature(signature) {
+    const adaptor = generateAdaptorFromSignature(signature);
+    const adaptorPublicKey = secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex(adaptorPublicKey),
+      bytesToHex(adaptor.adaptorPrivateKey)
+    );
+    return {
+      adaptorSignature: signature,
+      adaptorPublicKey
+    };
+  }
+  async getDepositSigningKey() {
+    if (!this.identityPrivateKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    const depositSigningKey = this.identityPrivateKey.derive("M/8797555'/0'/2'");
+    if (!depositSigningKey.privateKey) {
+      throw new Error("Could not derive deposit signing key");
+    }
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex(secp256k1.getPublicKey(depositSigningKey.privateKey)),
+      bytesToHex(depositSigningKey.privateKey)
+    );
+    return secp256k1.getPublicKey(depositSigningKey.privateKey);
+  }
+};
+
+export {
+  DefaultSparkSigner
+};