@buildonspark/spark-sdk 0.1.39 → 0.1.41

package/src/signer/signer.ts

@@ -1,6 +1,7 @@
 import {
   bytesToHex,
   bytesToNumberBE,
+  equalBytes,
   hexToBytes,
 } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
@@ -35,12 +36,17 @@ const getSparkFrostModule = async () => {
   return sparkFrostModule;
 };
 
-import { PARITY } from "@buildonspark/lrc20-sdk";
-import type { Psbt } from "bitcoinjs-lib";
-import { TokenSigner, Receipt } from "@buildonspark/lrc20-sdk";
-import { privateNegate, privateAdd } from "@bitcoinerlab/secp256k1";
+import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
+import {
+  fromPrivateKey,
+  PARITY,
+  Receipt,
+  TokenSigner,
+} from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
-import { fromPrivateKey } from "@buildonspark/lrc20-sdk";
+import { Transaction } from "@scure/btc-signer";
+import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
+import type { Psbt } from "bitcoinjs-lib";
 
 export type SigningNonce = {
   binding: Uint8Array;
@@ -82,31 +88,36 @@ type DerivedHDKey = {
   publicKey: Uint8Array;
 };
 
-interface HDKeyGenerator {
-  deriveHDKeysFromSeed(
+type KeyPair = {
+  privateKey: Uint8Array;
+  publicKey: Uint8Array;
+};
+
+interface SparkKeysGenerator {
+  deriveKeysFromSeed(
     seed: Uint8Array,
     accountNumber: number,
   ): Promise<{
-    masterKey: DerivedHDKey;
-    identityKey: DerivedHDKey;
-    signingKey: DerivedHDKey;
-    depositKey: DerivedHDKey;
-    staticDepositKey: DerivedHDKey;
+    masterPublicKey: Uint8Array;
+    identityKey: KeyPair;
+    signingHDKey: DerivedHDKey;
+    depositKey: KeyPair;
+    staticDepositHDKey: DerivedHDKey;
   }>;
 }
 
 const HARDENED_OFFSET = 0x80000000; // 2^31
 
-class DefaultHDKeyGenerator implements HDKeyGenerator {
-  async deriveHDKeysFromSeed(
+class DefaultSparkKeysGenerator implements SparkKeysGenerator {
+  async deriveKeysFromSeed(
     seed: Uint8Array,
     accountNumber: number,
   ): Promise<{
-    masterKey: DerivedHDKey;
-    identityKey: DerivedHDKey;
-    signingKey: DerivedHDKey;
-    depositKey: DerivedHDKey;
-    staticDepositKey: DerivedHDKey;
+    masterPublicKey: Uint8Array;
+    identityKey: KeyPair;
+    signingHDKey: DerivedHDKey;
+    depositKey: KeyPair;
+    staticDepositHDKey: DerivedHDKey;
   }> {
     const hdkey = HDKey.fromMasterSeed(seed);
 
@@ -141,27 +152,107 @@ class DefaultHDKeyGenerator implements HDKeyGenerator {
     }
 
     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,
+      },
+    };
+  }
+}
+
+class TaprootOutputKeysGenerator implements SparkKeysGenerator {
+  constructor(private readonly useAddressIndex: boolean = false) {}
+
+  async deriveKeysFromSeed(
+    seed: Uint8Array,
+    accountNumber: number,
+  ): Promise<{
+    masterPublicKey: Uint8Array;
+    identityKey: KeyPair;
+    signingHDKey: DerivedHDKey;
+    depositKey: KeyPair;
+    staticDepositHDKey: DerivedHDKey;
+  }> {
+    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);
+
+    // always use the even key
+    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,
@@ -223,6 +314,12 @@ interface SparkSigner extends TokenSigner {
     signature: Uint8Array,
   ): Promise<boolean>;
 
+  signTransactionIndex(
+    tx: Transaction,
+    index: number,
+    publicKey: Uint8Array,
+  ): void;
+
   encryptLeafPrivateKeyEcies(
     receiverPublicKey: Uint8Array,
     publicKey: Uint8Array,
@@ -242,10 +339,10 @@ interface SparkSigner extends TokenSigner {
 }
 
 class DefaultSparkSigner implements SparkSigner {
-  private masterKey: HDKey | null = null;
-  private identityKey: HDKey | null = null;
+  private masterPublicKey: Uint8Array | null = null;
+  private identityKey: KeyPair | null = null;
   private signingKey: HDKey | null = null;
-  private depositKey: HDKey | null = null;
+  private depositKey: KeyPair | null = null;
   private staticDepositKey: HDKey | null = null;
   private staticDepositKeyMap: Map<number, HDKey> = new Map();
 
@@ -255,16 +352,18 @@ class DefaultSparkSigner implements SparkSigner {
   protected commitmentToNonceMap: Map<SigningCommitment, SigningNonce> =
     new Map();
 
-  private readonly hdKeyGenerator: HDKeyGenerator;
+  private readonly keysGenerator: SparkKeysGenerator;
 
-  constructor({ hdKeyGenerator }: { hdKeyGenerator?: HDKeyGenerator } = {}) {
-    this.hdKeyGenerator = hdKeyGenerator ?? new DefaultHDKeyGenerator();
+  constructor({
+    sparkKeysGenerator,
+  }: { sparkKeysGenerator?: SparkKeysGenerator } = {}) {
+    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
   }
 
   private deriveSigningKey(hash: Uint8Array): Uint8Array {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key not initialized", {
-        field: "masterKey",
+        field: "signingKey",
       });
     }
 
@@ -284,9 +383,9 @@ class DefaultSparkSigner implements SparkSigner {
   }
 
   async restoreSigningKeysFromLeafs(leafs: TreeNode[]) {
-    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",
       });
     }
 
@@ -439,9 +538,9 @@ class DefaultSparkSigner implements SparkSigner {
   }
 
   async generatePublicKey(hash?: Uint8Array): Promise<Uint8Array> {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key is not set", {
-        field: "masterKey",
+        field: "signingKey",
       });
     }
 
@@ -607,12 +706,17 @@ class DefaultSparkSigner implements SparkSigner {
       seed = hexToBytes(seed);
     }
 
-    const { masterKey, identityKey, signingKey, depositKey, staticDepositKey } =
-      await this.hdKeyGenerator.deriveHDKeysFromSeed(seed, accountNumber ?? 0);
+    const {
+      masterPublicKey,
+      identityKey,
+      signingHDKey: signingKey,
+      depositKey,
+      staticDepositHDKey: staticDepositKey,
+    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
 
-    this.masterKey = masterKey.hdKey;
-    this.identityKey = identityKey.hdKey;
-    this.depositKey = depositKey.hdKey;
+    this.masterPublicKey = masterPublicKey;
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
 
@@ -733,11 +837,11 @@ class DefaultSparkSigner implements SparkSigner {
   }
 
   async getMasterPublicKey(): Promise<Uint8Array> {
-    if (!this.masterKey?.publicKey) {
+    if (!this.masterPublicKey) {
       throw new Error("Private key is not set");
     }
 
-    return this.masterKey.publicKey;
+    return this.masterPublicKey;
   }
 
   async validateMessageWithIdentityKey(
@@ -790,6 +894,44 @@ class DefaultSparkSigner implements SparkSigner {
     const receiptProof = privateAdd(privateKey, pxhPubkey)!;
     return Buffer.from(receiptProof);
   }
+
+  signTransactionIndex(
+    tx: Transaction,
+    index: number,
+    publicKey: Uint8Array,
+  ): void {
+    let privateKey: Uint8Array | undefined | null;
+
+    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);
+  }
 }
-export { DefaultSparkSigner };
+
+class TaprootSparkSigner extends DefaultSparkSigner {
+  constructor() {
+    super({ sparkKeysGenerator: new TaprootOutputKeysGenerator() });
+  }
+}
+
+export { DefaultSparkSigner, TaprootSparkSigner, TaprootOutputKeysGenerator };
 export type { SparkSigner };