@bsv/sdk 1.3.13 → 1.3.14

package/src/primitives/ECDSA.ts

@@ -1,8 +1,8 @@
-import BigNumber from './BigNumber'
-import Signature from './Signature'
-import Curve from './Curve'
-import Point from './Point'
-import DRBG from './DRBG'
+import BigNumber from './BigNumber.js'
+import Signature from './Signature.js'
+import Curve from './Curve.js'
+import Point from './Point.js'
+import DRBG from './DRBG.js'
 
 /**
  * Truncates a BigNumber message to the length of the curve order n, in the context of the Elliptic Curve Digital Signature Algorithm (ECDSA).
@@ -32,7 +32,7 @@ function truncateToN (
   if (delta > 0) {
     msg.iushrn(delta)
   }
-  if (!truncOnly && msg.cmp(curve.n) >= 0) {
+  if (truncOnly === null && msg.cmp(curve.n) >= 0) {
     return msg.sub(curve.n)
   } else {
     return msg
@@ -58,7 +58,7 @@ export const sign = (
   msg: BigNumber,
   key: BigNumber,
   forceLowS: boolean = false,
-  customK?: BigNumber | Function
+  customK?: BigNumber | ((iter: number) => BigNumber)
 ): Signature => {
   if (typeof BigInt === 'function') {
     // Curve parameters for secp256k1
@@ -132,21 +132,23 @@ export const sign = (
       }
     }
 
-    function generateK (): bigint {
+    function generateK (
+      customK?: BigNumber | ((iter: number) => BigNumber)
+    ): bigint {
       if (typeof customK === 'function') {
         // Call customK function to get k as BigNumber
-        const k_bn = customK(iter)
+        const kbn = customK(iter)
         // Convert k_bn (BigNumber) to BigInt
-        const k_str = k_bn.toString(16)
-        return BigInt('0x' + k_str)
-      } else if (BigNumber.isBN(customK)) {
+        const kstr = kbn.toString(16)
+        return BigInt('0x' + kstr)
+      } else if ((customK != null) && BigNumber.isBN(customK)) {
         // Use customK provided, convert to BigInt
-        const k_str = customK.toString(16)
-        return BigInt('0x' + k_str)
+        const kstr = customK.toString(16)
+        return BigInt('0x' + kstr)
       } else {
         // Use DRBG to generate k
-        const k_hex = drbg.generate(bytes) // Generate hex string
-        return BigInt('0x' + k_hex)
+        const khex = drbg.generate(bytes) // Generate hex string
+        return BigInt('0x' + khex)
       }
     }
 
@@ -207,23 +209,33 @@ export const sign = (
     function scalarMul (
       k: bigint,
       P: { x: bigint, y: bigint }
-    ): { x: bigint, y: bigint } | null {
+    ): { x: bigint, y: bigint } {
       let N = P
-      let Q = null // Point at infinity
+      let Q: { x: bigint, y: bigint } | null = null
 
-      while (k > zero) {
-        if (k % two === one) {
-          Q = pointAdd(Q, N)
+      while (k > BigInt(0)) {
+        if (k % BigInt(2) === BigInt(1)) {
+          Q = Q === null ? N : (pointAdd(Q, N) ?? Q)
         }
-        N = pointAdd(N, N)
-        k >>= one
+        N = pointAdd(N, N) ?? N
+        k >>= BigInt(1)
       }
+
+      if (Q === null) {
+        throw new Error('Scalar multiplication resulted in an invalid point.')
+      }
+
       return Q
     }
 
-    while (true) {
-      let k = generateK()
+    let validSignature = false
+    while (!validSignature) {
       iter += 1
+      validSignature = true
+      iter += 1
+
+      // Generate k value
+      let k = generateK(customK)
 
       // Truncate k to n bits
       k = truncateToN(k, n, true)
@@ -279,9 +291,9 @@ export const sign = (
       }
 
       // Return signature as BigNumbers
-      const r_bn = new BigNumber(r.toString(16), 16)
-      const s_bn = new BigNumber(s.toString(16), 16)
-      return new Signature(r_bn, s_bn)
+      const rbn = new BigNumber(r.toString(16), 16)
+      const sbn = new BigNumber(s.toString(16), 16)
+      return new Signature(rbn, sbn)
     }
   } else {
     const curve = new Curve()
@@ -308,7 +320,11 @@ export const sign = (
           : BigNumber.isBN(customK)
             ? customK
             : new BigNumber(drbg.generate(bytes), 16)
-      k = truncateToN(k, true)
+      if (k != null) {
+        k = truncateToN(k, true)
+      } else {
+        throw new Error('k is undefined')
+      }
       if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) {
         if (BigNumber.isBN(customK)) {
           throw new Error(
@@ -361,6 +377,7 @@ export const sign = (
       return new Signature(r, s)
     }
   }
+  throw new Error('Failed to generate a valid signature')
 }
 
 /**
@@ -408,19 +425,18 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
     const mod = (a: bigint, m: bigint): bigint => ((a % m) + m) % m
     const modInv = (a: bigint, m: bigint): bigint => {
       // Extended Euclidean Algorithm for modular inverse
-      let [old_r, r] = [a, m]
-      let [old_s, s] = [BigInt(1), BigInt(0)]
+      let [oldr, r] = [a, m]
+      let [olds, s] = [BigInt(1), BigInt(0)]
       while (r !== zero) {
-        const q = old_r / r;
-        [old_r, r] = [r, old_r - q * r];
-        [old_s, s] = [s, old_s - q * s]
+        const q = oldr / r;
+        [oldr, r] = [r, oldr - q * r];
+        [olds, s] = [s, olds - q * s]
       }
-      if (old_r > one) return zero // No inverse
-      return mod(old_s, m)
+      if (oldr > one) return zero // No inverse
+      return mod(olds, m)
     }
     const modMul = (a: bigint, b: bigint, m: bigint): bigint => mod(a * b, m)
     const modSub = (a: bigint, b: bigint, m: bigint): bigint => mod(a - b, m)
-    const modAdd = (a: bigint, b: bigint, m: bigint): bigint => mod(a + b, m)
 
     // Define constants
     const four = BigInt(4)
@@ -441,13 +457,13 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
         return { X: zero, Y: one, Z: zero } // Point at infinity
       }
 
-      const Y1_sq = modMul(Y1, Y1, p) // Y1^2
-      const S = modMul(four, modMul(X1, Y1_sq, p), p) // S = 4 * X1 * Y1^2
+      const Y1sq = modMul(Y1, Y1, p) // Y1^2
+      const S = modMul(four, modMul(X1, Y1sq, p), p) // S = 4 * X1 * Y1^2
       const M = modMul(three, modMul(X1, X1, p), p) // M = 3 * X1^2
       const X3 = modSub(modMul(M, M, p), modMul(two, S, p), p) // X3 = M^2 - 2 * S
       const Y3 = modSub(
         modMul(M, modSub(S, X3, p), p),
-        modMul(eight, modMul(Y1_sq, Y1_sq, p), p),
+        modMul(eight, modMul(Y1sq, Y1sq, p), p),
         p
       ) // Y3 = M * (S - X3) - 8 * Y1^4
       const Z3 = modMul(two, modMul(Y1, Z1, p), p) // Z3 = 2 * Y1 * Z1
@@ -546,10 +562,10 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
         return false // No inverse exists
       }
       const ZInv2 = modMul(ZInv, ZInv, p)
-      const x1_affine = modMul(R.X, ZInv2, p)
+      const x1affine = modMul(R.X, ZInv2, p)
 
       // Compute v = x1_affine mod n
-      const v = mod(x1_affine, n)
+      const v = mod(x1affine, n)
 
       // Signature is valid if v == r mod n
       return v === r
@@ -557,6 +573,10 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
 
     // Convert inputs to BigInt
     const hash = BigInt('0x' + msg.toString(16))
+    if ((key.x == null) || (key.y == null)) {
+      throw new Error('Invalid public key: missing coordinates.')
+    }
+
     const publicKey = {
       x: BigInt('0x' + key.x.toString(16)),
       y: BigInt('0x' + key.y.toString(16))