@buildonspark/spark-sdk 0.1.39 → 0.1.41

package/dist/{chunk-RAPBVYJY.js → chunk-UKT6OFLO.js}

@@ -4,12 +4,12 @@ import {
   getSigningCommitmentFromNonce,
   subtractPrivateKeys
 } from "./chunk-7VMYMQLF.js";
-import {
-  splitSecretWithProofs
-} from "./chunk-MGPRLH6Q.js";
 import {
   isReactNative
 } from "./chunk-HKAKEKCE.js";
+import {
+  splitSecretWithProofs
+} from "./chunk-MGPRLH6Q.js";
 import {
   ConfigurationError,
   ValidationError
@@ -22,6 +22,7 @@ import {
 import {
   bytesToHex,
   bytesToNumberBE,
+  equalBytes,
   hexToBytes
 } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
@@ -29,11 +30,14 @@ import { HDKey } from "@scure/bip32";
 import { generateMnemonic, mnemonicToSeed } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import * as ecies from "eciesjs";
-import { PARITY } from "@buildonspark/lrc20-sdk";
-import { Receipt } from "@buildonspark/lrc20-sdk";
-import { privateNegate, privateAdd } from "@bitcoinerlab/secp256k1";
+import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
+import {
+  fromPrivateKey,
+  PARITY,
+  Receipt
+} from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
-import { fromPrivateKey } from "@buildonspark/lrc20-sdk";
+import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -45,8 +49,8 @@ var getSparkFrostModule = async () => {
   return sparkFrostModule;
 };
 var HARDENED_OFFSET = 2147483648;
-var DefaultHDKeyGenerator = class {
-  async deriveHDKeysFromSeed(seed, accountNumber) {
+var DefaultSparkKeysGenerator = class {
+  async deriveKeysFromSeed(seed, accountNumber) {
     const hdkey = HDKey.fromMasterSeed(seed);
     if (!hdkey.privateKey || !hdkey.publicKey) {
       throw new ValidationError("Failed to derive keys from seed", {
@@ -67,27 +71,79 @@ var DefaultHDKeyGenerator = class {
       );
     }
     return {
-      masterKey: {
-        hdKey: hdkey,
-        privateKey: hdkey.privateKey,
-        publicKey: hdkey.publicKey
+      masterPublicKey: hdkey.publicKey,
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey
       },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey
+      }
+    };
+  }
+};
+var TaprootOutputKeysGenerator = class {
+  constructor(useAddressIndex = false) {
+    this.useAddressIndex = useAddressIndex;
+  }
+  async deriveKeysFromSeed(seed, accountNumber) {
+    const hdkey = HDKey.fromMasterSeed(seed);
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed
+      });
+    }
+    const derivationPath = this.useAddressIndex ? `m/86'/0'/0'/0/${accountNumber}` : `m/86'/0'/${accountNumber}'/0/0`;
+    const taprootInternalKey = hdkey.derive(derivationPath);
+    let tweakedPrivateKey = taprootTweakPrivKey(taprootInternalKey.privateKey);
+    let tweakedPublicKey = secp256k1.getPublicKey(tweakedPrivateKey);
+    if (tweakedPublicKey[0] === 3) {
+      tweakedPrivateKey = privateNegate(tweakedPrivateKey);
+      tweakedPublicKey = secp256k1.getPublicKey(tweakedPrivateKey);
+    }
+    const identityKey = {
+      publicKey: tweakedPublicKey,
+      privateKey: tweakedPrivateKey
+    };
+    const signingKey = hdkey.derive(`${derivationPath}/1'`);
+    const depositKey = hdkey.derive(`${derivationPath}/2'`);
+    const staticDepositKey = hdkey.derive(`${derivationPath}/3'`);
+    if (!signingKey.privateKey || !signingKey.publicKey || !depositKey.privateKey || !depositKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys"
+        }
+      );
+    }
+    return {
+      masterPublicKey: hdkey.publicKey,
       identityKey: {
-        hdKey: identityKey,
         privateKey: identityKey.privateKey,
         publicKey: identityKey.publicKey
       },
-      signingKey: {
+      signingHDKey: {
         hdKey: signingKey,
         privateKey: signingKey.privateKey,
         publicKey: signingKey.publicKey
       },
       depositKey: {
-        hdKey: depositKey,
         privateKey: depositKey.privateKey,
         publicKey: depositKey.publicKey
       },
-      staticDepositKey: {
+      staticDepositHDKey: {
         hdKey: staticDepositKey,
         privateKey: staticDepositKey.privateKey,
         publicKey: staticDepositKey.publicKey
@@ -96,7 +152,7 @@ var DefaultHDKeyGenerator = class {
   }
 };
 var DefaultSparkSigner = class {
-  masterKey = null;
+  masterPublicKey = null;
   identityKey = null;
   signingKey = null;
   depositKey = null;
@@ -105,14 +161,16 @@ var DefaultSparkSigner = class {
   // <hex, hex>
   publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
   commitmentToNonceMap = /* @__PURE__ */ new Map();
-  hdKeyGenerator;
-  constructor({ hdKeyGenerator } = {}) {
-    this.hdKeyGenerator = hdKeyGenerator ?? new DefaultHDKeyGenerator();
+  keysGenerator;
+  constructor({
+    sparkKeysGenerator
+  } = {}) {
+    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
   }
   deriveSigningKey(hash) {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key not initialized", {
-        field: "masterKey"
+        field: "signingKey"
       });
     }
     const view = new DataView(hash.buffer);
@@ -126,9 +184,9 @@ var DefaultSparkSigner = class {
     return newPrivateKey;
   }
   async restoreSigningKeysFromLeafs(leafs) {
-    if (!this.masterKey) {
-      throw new ValidationError("Master key is not set", {
-        field: "masterKey"
+    if (!this.signingKey) {
+      throw new ValidationError("Signing key is not set", {
+        field: "signingKey"
       });
     }
     for (const leaf of leafs) {
@@ -248,9 +306,9 @@ var DefaultSparkSigner = class {
     return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(hexToBytes);
   }
   async generatePublicKey(hash) {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key is not set", {
-        field: "masterKey"
+        field: "signingKey"
       });
     }
     let newPrivateKey = null;
@@ -386,10 +444,16 @@ var DefaultSparkSigner = class {
     if (typeof seed === "string") {
       seed = hexToBytes(seed);
     }
-    const { masterKey, identityKey, signingKey, depositKey, staticDepositKey } = await this.hdKeyGenerator.deriveHDKeysFromSeed(seed, accountNumber ?? 0);
-    this.masterKey = masterKey.hdKey;
-    this.identityKey = identityKey.hdKey;
-    this.depositKey = depositKey.hdKey;
+    const {
+      masterPublicKey,
+      identityKey,
+      signingHDKey: signingKey,
+      depositKey,
+      staticDepositHDKey: staticDepositKey
+    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
+    this.masterPublicKey = masterPublicKey;
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
     this.publicKeyToPrivateKeyMap.set(
@@ -478,10 +542,10 @@ var DefaultSparkSigner = class {
     };
   }
   async getMasterPublicKey() {
-    if (!this.masterKey?.publicKey) {
+    if (!this.masterPublicKey) {
       throw new Error("Private key is not set");
     }
-    return this.masterKey.publicKey;
+    return this.masterPublicKey;
   }
   async validateMessageWithIdentityKey(message, signature) {
     if (!this.identityKey?.publicKey) {
@@ -519,8 +583,34 @@ var DefaultSparkSigner = class {
     const receiptProof = privateAdd(privateKey, pxhPubkey);
     return Buffer.from(receiptProof);
   }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if (equalBytes(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if (equalBytes(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = hexToBytes(
+        this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey)) ?? ""
+      );
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: bytesToHex(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
+};
+var TaprootSparkSigner = class extends DefaultSparkSigner {
+  constructor() {
+    super({ sparkKeysGenerator: new TaprootOutputKeysGenerator() });
+  }
 };
 
 export {
-  DefaultSparkSigner
+  TaprootOutputKeysGenerator,
+  DefaultSparkSigner,
+  TaprootSparkSigner
 };