@bsv/sdk 1.3.12 → 1.3.14

package/src/primitives/Curve.ts

@@ -23,13 +23,13 @@ export default class Curve {
   tinv: BigNumber
   zeroA: boolean
   threeA: boolean
-  endo: any // beta, lambda, basis
-  _endoWnafT1: any[]
-  _endoWnafT2: any[]
-  _wnafT1: any[]
-  _wnafT2: any[]
-  _wnafT3: any[]
-  _wnafT4: any[]
+  endo: { beta: BigNumber, lambda: BigNumber, basis: Array<{ a: BigNumber, b: BigNumber }> } | undefined // beta, lambda, basis
+  _endoWnafT1: BigNumber[]
+  _endoWnafT2: BigNumber[]
+  _wnafT1: BigNumber[]
+  _wnafT2: BigNumber[]
+  _wnafT3: BigNumber[]
+  _wnafT4: BigNumber[]
   _bitLength: number
 
   // Represent num in a w-NAF form
@@ -53,7 +53,11 @@ export default class Curve {
       let z
       const mod = k.andln(ws - 1)
       if (k.isOdd()) {
-        if (mod > (ws >> 1) - 1) { z = (ws >> 1) - mod } else { z = mod }
+        if (mod > (ws >> 1) - 1) {
+          z = (ws >> 1) - mod
+        } else {
+          z = mod
+        }
         k.isubn(z)
       } else {
         z = 0
@@ -68,10 +72,7 @@ export default class Curve {
 
   // Represent k1, k2 in a Joint Sparse Form
   getJSF (k1: BigNumber, k2: BigNumber): number[][] {
-    const jsf: any[][] = [
-      [],
-      []
-    ]
+    const jsf: number[][] = [[], []]
 
     k1 = k1.clone()
     k2 = k2.clone()
@@ -81,8 +82,12 @@ export default class Curve {
       // First phase
       let m14 = (k1.andln(3) + d1) & 3
       let m24 = (k2.andln(3) + d2) & 3
-      if (m14 === 3) { m14 = -1 }
-      if (m24 === 3) { m24 = -1 }
+      if (m14 === 3) {
+        m14 = -1
+      }
+      if (m24 === 3) {
+        m24 = -1
+      }
       let u1: number
       if ((m14 & 1) === 0) {
         u1 = 0
@@ -101,13 +106,21 @@ export default class Curve {
         u2 = 0
       } else {
         const m8 = (k2.andln(7) + d2) & 7
-        if ((m8 === 3 || m8 === 5) && m14 === 2) { u2 = -m24 } else { u2 = m24 }
+        if ((m8 === 3 || m8 === 5) && m14 === 2) {
+          u2 = -m24
+        } else {
+          u2 = m24
+        }
       }
       jsf[1].push(u2)
 
       // Second phase
-      if (2 * d1 === u1 + 1) { d1 = 1 - d1 }
-      if (2 * d2 === u2 + 1) { d2 = 1 - d2 }
+      if (2 * d1 === u1 + 1) {
+        d1 = 1 - d1
+      }
+      if (2 * d2 === u2 + 1) {
+        d2 = 1 - d2
+      }
       k1.iushrn(1)
       k2.iushrn(1)
     }
@@ -118,17 +131,14 @@ export default class Curve {
   static cachedProperty (obj, name: string, computer): void {
     const key = '_' + name
     obj.prototype[name] = function cachedProperty () {
-      const r = this[key] !== undefined
-        ? this[key]
-        : this[key] = computer.call(this)
+      const r =
+        this[key] !== undefined ? this[key] : (this[key] = computer.call(this))
       return r
     }
   }
 
   static parseBytes (bytes: string | number[]): number[] {
-    return typeof bytes === 'string'
-      ? toArray(bytes, 'hex')
-      : bytes
+    return typeof bytes === 'string' ? toArray(bytes, 'hex') : bytes
   }
 
   static intFromLE (bytes: number[]): BigNumber {
@@ -933,7 +943,8 @@ export default class Curve {
 
       // Precomputed endomorphism
       beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
-      lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
+      lambda:
+        '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
       basis: [
         {
           a: '3086d221a7d46bcde86c90e49284eb15',
@@ -965,7 +976,7 @@ export default class Curve {
 
     // Curve configuration, optional
     this.n = new BigNumber(conf.n, 16)
-    this.g = Point.fromJSON(conf.g, conf.gRed)
+    this.g = Point.fromJSON(conf.g as [string, string, { doubles?: { step: number, points: Array<[string, string]> }, naf?: { wnd: number, points: Array<[string, string]> } }], conf.gRed)
 
     // Temporary arrays
     this._wnafT1 = new Array(4)
@@ -988,35 +999,70 @@ export default class Curve {
     this._endoWnafT2 = new Array(4)
   }
 
-  _getEndomorphism (conf): {
+  _getEndomorphism (conf):
+  | {
     beta: BigNumber
     lambda: BigNumber
     basis: Array<{ a: BigNumber, b: BigNumber }>
-  } | undefined {
+  }
+  | undefined {
     // No efficient endomorphism
-    if (!this.zeroA || this.p.modrn(3) !== 1) { return }
+    if (!this.zeroA || this.p.modrn(3) !== 1) {
+      return
+    }
 
     // Compute beta and lambda, that lambda * P = (beta * Px; Py)
     let beta: BigNumber
     let lambda: BigNumber
+
     if (conf.beta !== undefined) {
       beta = new BigNumber(conf.beta, 16).toRed(this.red)
     } else {
       const betas = this._getEndoRoots(this.p)
+      if (betas === null) {
+        throw new Error('Failed to get endomorphism roots for beta.')
+      }
       // Choose the smallest beta
       beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1]
       beta = beta.toRed(this.red)
     }
+
     if (conf.lambda !== undefined) {
       lambda = new BigNumber(conf.lambda, 16)
     } else {
-      // Choose the lambda that is matching selected beta
+      // Choose the lambda that matches selected beta
       const lambdas = this._getEndoRoots(this.n)
-      if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
+      if (lambdas === null) {
+        throw new Error('Failed to get endomorphism roots for lambda.')
+      }
+
+      if (this.g == null) {
+        throw new Error('Curve generator point (g) is not defined.')
+      }
+
+      const gMulX = this.g.mul(lambdas[0])?.x
+      const gXRedMulBeta = (this.g.x != null) ? this.g.x.redMul(beta) : undefined
+
+      if ((gMulX != null) && (gXRedMulBeta != null) && gMulX.cmp(gXRedMulBeta) === 0) {
         lambda = lambdas[0]
       } else {
         lambda = lambdas[1]
-        Curve.assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0)
+
+        if (this.g == null) {
+          throw new Error('Curve generator point (g) is not defined.')
+        }
+
+        const gMulX = this.g.mul(lambda)?.x
+        const gXRedMulBeta = (this.g.x != null) ? this.g.x.redMul(beta) : undefined
+
+        if ((gMulX == null) || (gXRedMulBeta == null)) {
+          throw new Error('Lambda computation failed: g.mul(lambda).x or g.x.redMul(beta) is undefined.')
+        }
+
+        Curve.assert(
+          gMulX.cmp(gXRedMulBeta) === 0,
+          'Lambda selection does not match computed beta.'
+        )
       }
     }
 
@@ -1038,7 +1084,7 @@ export default class Curve {
       lambda,
       basis
     }
-  };
+  }
 
   _getEndoRoots (num: BigNumber): [BigNumber, BigNumber] {
     // Find roots of for x^2 + x + 1 in F
@@ -1053,9 +1099,11 @@ export default class Curve {
     const l1 = ntinv.redAdd(s).fromRed()
     const l2 = ntinv.redSub(s).fromRed()
     return [l1, l2]
-  };
+  }
 
-  _getEndoBasis (lambda: BigNumber): [{ a: BigNumber, b: BigNumber }, { a: BigNumber, b: BigNumber }] {
+  _getEndoBasis (
+    lambda: BigNumber
+  ): [{ a: BigNumber, b: BigNumber }, { a: BigNumber, b: BigNumber }] {
     // aprxSqrt >= sqrt(this.n)
     const aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2))
 
@@ -1069,31 +1117,32 @@ export default class Curve {
     let y2 = new BigNumber(1)
 
     // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
-    let a0: BigNumber
-    let b0: BigNumber
+    let a0: BigNumber | undefined
+    let b0: BigNumber | undefined
     // First vector
-    let a1: BigNumber
-    let b1: BigNumber
+    let a1: BigNumber | undefined
+    let b1: BigNumber | undefined
     // Second vector
     let a2: BigNumber
     let b2: BigNumber
 
-    let prevR
+    let prevR: BigNumber = new BigNumber(0)
     let i = 0
-    let r
-    let x
+    let r: BigNumber = new BigNumber(0)
+    let x: BigNumber = new BigNumber(0) // Ensure x is initialized
+
     while (u.cmpn(0) !== 0) {
       const q = v.div(u)
       r = v.sub(q.mul(u))
-      x = x2.sub(q.mul(x1))
+      x = x2.sub(q.mul(x1)) // Now TypeScript knows x is always assigned
       const y = y2.sub(q.mul(y1))
 
-      if (typeof a1 !== 'object' && r.cmp(aprxSqrt) < 0) {
+      if (a1 === undefined && r.cmp(aprxSqrt) < 0) {
         a0 = prevR.neg()
         b0 = x1
         a1 = r.neg()
         b1 = x
-      } else if (typeof a1 === 'object' && ++i === 2) {
+      } else if (a1 !== undefined && ++i === 2) {
         break
       }
       prevR = r
@@ -1105,11 +1154,23 @@ export default class Curve {
       y2 = y1
       y1 = y
     }
+
+    // Ensure a0 and b0 have been assigned
+    if (
+      a0 === undefined ||
+      b0 === undefined ||
+      a1 === undefined ||
+      b1 === undefined
+    ) {
+      throw new Error('Failed to compute Endo Basis values')
+    }
+
     a2 = r.neg()
     b2 = x
 
     const len1 = a1.sqr().add(b1.sqr())
     const len2 = a2.sqr().add(b2.sqr())
+
     if (len2.cmp(len1) >= 0) {
       a2 = a0
       b2 = b0
@@ -1132,6 +1193,9 @@ export default class Curve {
   }
 
   _endoSplit (k: BigNumber): { k1: BigNumber, k2: BigNumber } {
+    if (this.endo == null) {
+      throw new Error('Endomorphism is not defined.')
+    }
     const basis = this.endo.basis
     const v1 = basis[0]
     const v2 = basis[1]
@@ -1151,13 +1215,20 @@ export default class Curve {
   }
 
   validate (point: Point): boolean {
-    if (point.inf) { return true }
+    if (point.inf) {
+      return true
+    }
 
     const x = point.x
     const y = point.y
 
+    // Ensure x and y are not null before proceeding
+    if (x === null || y === null) {
+      throw new Error('Point coordinates cannot be null')
+    }
+
     const ax = this.a.redMul(x)
     const rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b)
     return y.redSqr().redISub(rhs).cmpn(0) === 0
-  };
+  }
 }

package/src/primitives/DRBG.ts

@@ -61,19 +61,17 @@ export default class DRBG {
    * drbg.update('e13af...');
    */
   update (seed?): void {
-    let kmac = this.hmac()
-      .update(this.V)
-      .update([0x00])
-    if (seed !== undefined) { kmac = kmac.update(seed) }
+    let kmac = this.hmac().update(this.V).update([0x00])
+    if (seed !== undefined) {
+      kmac = kmac.update(seed)
+    }
     this.K = kmac.digest()
     this.V = this.hmac().update(this.V).digest()
-    if (seed === undefined) { return }
+    if (seed === undefined) {
+      return
+    }
 
-    this.K = this.hmac()
-      .update(this.V)
-      .update([0x01])
-      .update(seed)
-      .digest()
+    this.K = this.hmac().update(this.V).update([0x01]).update(seed).digest()
     this.V = this.hmac().update(this.V).digest()
   }
 
@@ -89,7 +87,7 @@ export default class DRBG {
    * const randomHex = drbg.generate(256);
    */
   generate (len: number): string {
-    let temp = []
+    let temp: number[] = []
     while (temp.length < len) {
       this.V = this.hmac().update(this.V).digest()
       temp = temp.concat(this.V)

package/src/primitives/ECDSA.ts

@@ -23,10 +23,16 @@ import DRBG from './DRBG.js'
  * let msg = new BigNumber('1234567890abcdef', 16);
  * let truncatedMsg = truncateToN(msg);
  */
-function truncateToN (msg: BigNumber, truncOnly?: boolean, curve = new Curve()): BigNumber {
+function truncateToN (
+  msg: BigNumber,
+  truncOnly?: boolean,
+  curve = new Curve()
+): BigNumber {
   const delta = msg.byteLength() * 8 - curve.n.bitLength()
-  if (delta > 0) { msg.iushrn(delta) }
-  if (!truncOnly && msg.cmp(curve.n) >= 0) {
+  if (delta > 0) {
+    msg.iushrn(delta)
+  }
+  if (truncOnly === null && msg.cmp(curve.n) >= 0) {
     return msg.sub(curve.n)
   } else {
     return msg
@@ -48,7 +54,12 @@ function truncateToN (msg: BigNumber, truncOnly?: boolean, curve = new Curve()):
  * const key = new BigNumber('123456')
  * const signature = sign(msg, key)
  */
-export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false, customK?: BigNumber | Function): Signature => {
+export const sign = (
+  msg: BigNumber,
+  key: BigNumber,
+  forceLowS: boolean = false,
+  customK?: BigNumber | ((iter: number) => BigNumber)
+): Signature => {
   if (typeof BigInt === 'function') {
     // Curve parameters for secp256k1
     const zero = BigInt(0)
@@ -103,7 +114,11 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
     let iter = 0
 
     // Truncate to N function for BigInt
-    function truncateToN (k: bigint, n: bigint, truncOnly: boolean = true): bigint {
+    function truncateToN (
+      k: bigint,
+      n: bigint,
+      truncOnly: boolean = true
+    ): bigint {
       const kBitLength = k.toString(2).length
       const nBitLength = n.toString(2).length
       const delta = kBitLength - nBitLength
@@ -117,21 +132,23 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       }
     }
 
-    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)
       }
     }
 
@@ -192,23 +209,33 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
     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)
@@ -264,9 +291,9 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       }
 
       // 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()
@@ -287,15 +314,22 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
 
     for (let iter = 0; ; iter++) {
       // Compute the k-value
-      let k = typeof customK === 'function'
-        ? customK(iter)
-        : BigNumber.isBN(customK)
-          ? customK
-          : new BigNumber(drbg.generate(bytes), 16)
-      k = truncateToN(k, true)
+      let k =
+        typeof customK === 'function'
+          ? customK(iter)
+          : BigNumber.isBN(customK)
+            ? customK
+            : new BigNumber(drbg.generate(bytes), 16)
+      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('Invalid fixed custom K value (must be more than 1 and less than N-1)')
+          throw new Error(
+            'Invalid fixed custom K value (must be more than 1 and less than N-1)'
+          )
         } else {
           continue
         }
@@ -304,7 +338,9 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       const kp = curve.g.mul(k)
       if (kp.isInfinity()) {
         if (BigNumber.isBN(customK)) {
-          throw new Error('Invalid fixed custom K value (must not create a point at infinity when multiplied by the generator point)')
+          throw new Error(
+            'Invalid fixed custom K value (must not create a point at infinity when multiplied by the generator point)'
+          )
         } else {
           continue
         }
@@ -314,7 +350,9 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       const r = kpX.umod(curve.n)
       if (r.cmpn(0) === 0) {
         if (BigNumber.isBN(customK)) {
-          throw new Error('Invalid fixed custom K value (when multiplied by G, the resulting x coordinate mod N must not be zero)')
+          throw new Error(
+            'Invalid fixed custom K value (when multiplied by G, the resulting x coordinate mod N must not be zero)'
+          )
         } else {
           continue
         }
@@ -324,7 +362,9 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       s = s.umod(curve.n)
       if (s.cmpn(0) === 0) {
         if (BigNumber.isBN(customK)) {
-          throw new Error('Invalid fixed custom K value (when used with the key, it cannot create a zero value for S)')
+          throw new Error(
+            'Invalid fixed custom K value (when used with the key, it cannot create a zero value for S)'
+          )
         } else {
           continue
         }
@@ -337,6 +377,7 @@ export const sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false,
       return new Signature(r, s)
     }
   }
+  throw new Error('Failed to generate a valid signature')
 }
 
 /**
@@ -384,22 +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)
+    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)
 
     // Define constants
     const four = BigInt(4)
@@ -420,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
@@ -464,18 +501,17 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
       const V = modMul(U1, HH, p)
 
       const X3 = modSub(modSub(modMul(r, r, p), HHH, p), modMul(two, V, p), p)
-      const Y3 = modSub(
-        modMul(r, modSub(V, X3, p), p),
-        modMul(S1, HHH, p),
-        p
-      )
+      const Y3 = modSub(modMul(r, modSub(V, X3, p), p), modMul(S1, HHH, p), p)
       const Z3 = modMul(H, modMul(P.Z, Q.Z, p), p)
 
       return { X: X3, Y: Y3, Z: Z3 }
     }
 
     // Scalar Multiplication
-    const scalarMultiply = (k: bigint, P: { x: bigint, y: bigint }): JacobianPoint => {
+    const scalarMultiply = (
+      k: bigint,
+      P: { x: bigint, y: bigint }
+    ): JacobianPoint => {
       const N: JacobianPoint = { X: P.x, Y: P.y, Z: one }
       let Q: JacobianPoint = { X: zero, Y: one, Z: zero } // Point at infinity
 
@@ -526,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
@@ -537,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))
@@ -553,8 +593,12 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
     // Perform primitive values validation
     const r = sig.r
     const s = sig.s
-    if (r.cmpn(1) < 0 || r.cmp(curve.n) >= 0) { return false }
-    if (s.cmpn(1) < 0 || s.cmp(curve.n) >= 0) { return false }
+    if (r.cmpn(1) < 0 || r.cmp(curve.n) >= 0) {
+      return false
+    }
+    if (s.cmpn(1) < 0 || s.cmp(curve.n) >= 0) {
+      return false
+    }
 
     // Validate signature
     const sinv = s.invm(curve.n)
@@ -564,7 +608,9 @@ export const verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
     // NOTE: Greg Maxwell's trick, inspired by:
     // https://git.io/vad3K
     const p = curve.g.jmulAdd(u1, key, u2)
-    if (p.isInfinity()) { return false }
+    if (p.isInfinity()) {
+      return false
+    }
 
     // Compare `p.x` of Jacobian point with `r`,
     // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the