@buildonspark/spark-sdk 0.0.9 → 0.0.10

package/dist/chunk-F4JW24C4.js

@@ -1,78 +0,0 @@
-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

@@ -1,331 +0,0 @@
-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
-};