@buildonspark/spark-sdk 0.1.40 → 0.1.41

package/dist/{chunk-RFCXPGDM.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
@@ -37,6 +37,7 @@ import {
   Receipt
 } from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
+import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -48,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", {
@@ -70,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
@@ -99,7 +152,7 @@ var DefaultHDKeyGenerator = class {
   }
 };
 var DefaultSparkSigner = class {
-  masterKey = null;
+  masterPublicKey = null;
   identityKey = null;
   signingKey = null;
   depositKey = null;
@@ -108,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);
@@ -129,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) {
@@ -251,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;
@@ -389,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(
@@ -481,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) {
@@ -542,7 +603,14 @@ var DefaultSparkSigner = class {
     tx.signIdx(privateKey, index);
   }
 };
+var TaprootSparkSigner = class extends DefaultSparkSigner {
+  constructor() {
+    super({ sparkKeysGenerator: new TaprootOutputKeysGenerator() });
+  }
+};
 
 export {
-  DefaultSparkSigner
+  TaprootOutputKeysGenerator,
+  DefaultSparkSigner,
+  TaprootSparkSigner
 };