@bsv/sdk 1.3.12 → 1.3.14

package/src/primitives/Polynomial.ts

@@ -20,7 +20,10 @@ export class PointInFiniteField {
 
   static fromString (str: string): PointInFiniteField {
     const [x, y] = str.split('.')
-    return new PointInFiniteField(new BigNumber(fromBase58(x)), new BigNumber(fromBase58(y)))
+    return new PointInFiniteField(
+      new BigNumber(fromBase58(x)),
+      new BigNumber(fromBase58(y))
+    )
   }
 }
 
@@ -45,13 +48,15 @@ export default class Polynomial {
 
   constructor (points: PointInFiniteField[], threshold?: number) {
     this.points = points
-    this.threshold = threshold || points.length
+    this.threshold = threshold ?? points.length // ✅ Handles undefined safely
   }
 
   static fromPrivateKey (key: PrivateKey, threshold: number): Polynomial {
     const P = new Curve().p // arithmetic is mod P
     // The key is the y-intercept of the polynomial where x=0.
-    const points = [new PointInFiniteField(new BigNumber(0), new BigNumber(key.toArray()))]
+    const points = [
+      new PointInFiniteField(new BigNumber(0), new BigNumber(key.toArray()))
+    ]
 
     // The other values are random
     for (let i = 1; i < threshold; i++) {

package/src/primitives/PrivateKey.ts

@@ -6,7 +6,7 @@ import Curve from './Curve.js'
 import { sign, verify } from './ECDSA.js'
 import { sha256, sha256hmac } from './Hash.js'
 import Random from './Random.js'
-import { fromBase58Check, toArray, toBase58, toBase58Check } from './utils.js'
+import { fromBase58Check, toArray, toBase58Check } from './utils.js'
 import Polynomial, { PointInFiniteField } from './Polynomial.js'
 
 /**
@@ -29,7 +29,11 @@ export class KeyShares {
   threshold: number
   integrity: string
 
-  constructor (points: PointInFiniteField[], threshold: number, integrity: string) {
+  constructor (
+    points: PointInFiniteField[],
+    threshold: number,
+    integrity: string
+  ) {
     this.points = points
     this.threshold = threshold
     this.integrity = integrity
@@ -40,13 +44,20 @@ export class KeyShares {
     let integrity = ''
     const points = shares.map((share, idx) => {
       const shareParts = share.split('.')
-      if (shareParts.length !== 4) throw Error('Invalid share format in share ' + idx + '. Expected format: "x.y.t.i" - received ' + share)
+      if (shareParts.length !== 4) {
+        throw new Error(
+          'Invalid share format in share ' +
+          idx.toString() +
+          '. Expected format: "x.y.t.i" - received ' +
+          share
+        )
+      }
       const [x, y, t, i] = shareParts
-      if (!t) throw Error('Threshold not found in share ' + idx)
-      if (!i) throw Error('Integrity not found in share ' + idx)
+      if (t === undefined) throw new Error('Threshold not found in share ' + idx.toString())
+      if (i === undefined) throw new Error('Integrity not found in share ' + idx.toString())
       const tInt = parseInt(t)
-      if (idx !== 0 && threshold !== tInt) throw Error('Threshold mismatch in share ' + idx)
-      if (idx !== 0 && integrity !== i) throw Error('Integrity mismatch in share ' + idx)
+      if (idx !== 0 && threshold !== tInt) { throw new Error('Threshold mismatch in share ' + idx.toString()) }
+      if (idx !== 0 && integrity !== i) { throw new Error('Integrity mismatch in share ' + idx.toString()) }
       threshold = tInt
       integrity = i
       return PointInFiniteField.fromString([x, y].join('.'))
@@ -54,8 +65,10 @@ export class KeyShares {
     return new KeyShares(points, threshold, integrity)
   }
 
-  toBackupFormat () {
-    return this.points.map(share => share.toString() + '.' + this.threshold + '.' + this.integrity)
+  toBackupFormat (): string[] {
+    return this.points.map(
+      (share) => share.toString() + '.' + this.threshold.toString() + '.' + this.integrity
+    )
   }
 }
 
@@ -121,7 +134,7 @@ export default class PrivateKey extends BigNumber {
    * @throws Will throw an error if the string is not a valid WIF.
    **/
   static fromWif (wif: string, prefixLength: number = 1): PrivateKey {
-    const decoded = fromBase58Check(wif, null, prefixLength)
+    const decoded = fromBase58Check(wif, undefined, prefixLength)
     if (decoded.data.length !== 33) {
       throw new Error('Invalid WIF length')
     }
@@ -140,7 +153,7 @@ export default class PrivateKey extends BigNumber {
    *
    * @param endian - The endianness provided. By default is 'big endian'. Ignored if number is BigNumber.
    *
-   * @param modN - Optional. Default 'apply. If 'apply', apply modN to input to guarantee a valid PrivateKey. If 'error', if input is out of field throw Error('Input is out of field'). If 'nocheck', assumes input is in field.
+   * @param modN - Optional. Default 'apply. If 'apply', apply modN to input to guarantee a valid PrivateKey. If 'error', if input is out of field throw new Error('Input is out of field'). If 'nocheck', assumes input is in field.
    *
    * @example
    * import PrivateKey from './PrivateKey';
@@ -204,7 +217,12 @@ export default class PrivateKey extends BigNumber {
    * const privateKey = PrivateKey.fromRandom();
    * const signature = privateKey.sign('Hello, World!');
    */
-  sign (msg: number[] | string, enc?: 'hex' | 'utf8', forceLowS: boolean = true, customK?: Function | BigNumber): Signature {
+  sign (
+    msg: number[] | string,
+    enc?: 'hex' | 'utf8',
+    forceLowS: boolean = true,
+    customK?: ((iter: number) => BigNumber) | BigNumber
+  ): Signature {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return sign(msgHash, this, forceLowS, customK)
   }
@@ -265,7 +283,9 @@ export default class PrivateKey extends BigNumber {
    * const testnetWif = privateKey.toWif([0xef]);
    */
   toWif (prefix: number[] = [0x80]): string {
-    if (!this.isValid()) { throw new Error('Value is out of field') }
+    if (!this.isValid()) {
+      throw new Error('Value is out of field')
+    }
     return toBase58Check([...this.toArray('be', 32), 1], prefix)
   }
 
@@ -362,14 +382,14 @@ export default class PrivateKey extends BigNumber {
    * const shares = key.toKeyShares(2, 5)
    */
   toKeyShares (threshold: number, totalShares: number): KeyShares {
-    if (typeof threshold !== 'number' || typeof totalShares !== 'number') throw new Error('threshold and totalShares must be numbers')
+    if (typeof threshold !== 'number' || typeof totalShares !== 'number') { throw new Error('threshold and totalShares must be numbers') }
     if (threshold < 2) throw new Error('threshold must be at least 2')
     if (totalShares < 2) throw new Error('totalShares must be at least 2')
-    if (threshold > totalShares) throw new Error('threshold should be less than or equal to totalShares')
+    if (threshold > totalShares) { throw new Error('threshold should be less than or equal to totalShares') }
 
     const poly = Polynomial.fromPrivateKey(this, threshold)
 
-    const points = []
+    const points: PointInFiniteField[] = []
     for (let i = 0; i < totalShares; i++) {
       const x = new BigNumber(PrivateKey.fromRandom().toArray())
       const y = poly.valueAt(x)
@@ -427,7 +447,11 @@ export default class PrivateKey extends BigNumber {
   static fromKeyShares (keyShares: KeyShares): PrivateKey {
     const { points, threshold, integrity } = keyShares
     if (threshold < 2) throw new Error('threshold must be at least 2')
-    if (points.length < threshold) throw new Error(`At least ${threshold} shares are required to reconstruct the private key`)
+    if (points.length < threshold) {
+      throw new Error(
+        `At least ${threshold} shares are required to reconstruct the private key`
+      )
+    }
     // check to see if two points have the same x value
     for (let i = 0; i < threshold; i++) {
       for (let j = i + 1; j < threshold; j++) {

package/src/primitives/PublicKey.ts

@@ -87,7 +87,9 @@ export default class PublicKey extends Point {
       // Common gotcha: constructing PublicKey with a DER value when you should use .fromString()
       if (y === null && isRed && typeof x === 'string') {
         if (x.length === 66 || x.length === 130) {
-          throw new Error('You are using the "new PublicKey()" constructor with a DER hex string. You need to use "PublicKey.fromString()" instead.')
+          throw new Error(
+            'You are using the "new PublicKey()" constructor with a DER hex string. You need to use "PublicKey.fromString()" instead.'
+          )
         }
       }
       super(x, y, isRed)
@@ -129,7 +131,11 @@ export default class PublicKey extends Point {
    * const mySignature = new Signature(...)
    * const isVerified = myPubKey.verify(myMessage, mySignature)
    */
-  verify (msg: number[] | string, sig: Signature, enc?: 'hex' | 'utf8'): boolean {
+  verify (
+    msg: number[] | string,
+    sig: Signature,
+    enc?: 'hex' | 'utf8'
+  ): boolean {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return verify(msgHash, sig, this)
   }
@@ -225,7 +231,11 @@ export default class PublicKey extends Point {
    * @example
    * const publicKey = Signature.fromMsgHashAndCompactSignature(msgHash, 'IMOl2mVKfDgsSsHT4uIYBNN4e...', 'base64');
    */
-  static fromMsgHashAndCompactSignature (msgHash: BigNumber, signature: number[] | string, enc?: 'hex' | 'base64'): PublicKey {
+  static fromMsgHashAndCompactSignature (
+    msgHash: BigNumber,
+    signature: number[] | string,
+    enc?: 'hex' | 'base64'
+  ): PublicKey {
     const data = toArray(signature, enc)
     if (data.length !== 65) {
       throw new Error('Invalid Compact Signature')

package/src/primitives/Random.ts

@@ -1,29 +1,35 @@
 class Rand {
-  _rand: Function
+  _rand: (n: number) => number[] // ✅ Explicit function type
+
   constructor () {
-    const noRand = () => {
-      throw new Error('No secure random number generator is available in this environment.')
+    const noRand = (): never => {
+      throw new Error(
+        'No secure random number generator is available in this environment.'
+      )
     }
+
+    this._rand = noRand // Assign the function
+
     if (typeof self === 'object') {
       /* eslint-disable-next-line */
       if (self.crypto?.getRandomValues) {
-        this._rand = n => {
+        this._rand = (n) => {
           const arr = new Uint8Array(n)
           /* eslint-disable-next-line */
-          self.crypto.getRandomValues(arr)
+          self.crypto.getRandomValues(arr);
           return [...arr]
         }
-      } else /* if (typeof window === 'object') */ {
+      } /* if (typeof window === 'object') */ else {
         this._rand = noRand
       }
     } else {
       try {
         /* eslint-disable-next-line */
-        const crypto = require('crypto')
+        const crypto = require("crypto");
         if (typeof crypto.randomBytes === 'function') {
           this._rand = (n: number) => [...crypto.randomBytes(n)]
         }
-      } catch (e) {
+      } catch {
         this._rand = noRand
       }
     }

package/src/primitives/ReductionContext.ts

@@ -89,7 +89,7 @@ export default class ReductionContext {
       'red works only with positives'
     )
     this.assert(
-      (a.red != null) && a.red === b.red,
+      a.red != null && a.red === b.red,
       'red works only with red numbers'
     )
   }

package/src/primitives/Schnorr.ts

@@ -42,14 +42,19 @@ export default class Schnorr {
   }
 
   /**
-     * Generates a proof that demonstrates the link between public key A and shared secret S
-     * @param a Private key corresponding to public key A
-     * @param A Public key
-     * @param B Other party's public key
-     * @param S Shared secret
-     * @returns Proof (R, S', z)
-     */
-  generateProof (aArg: PrivateKey, AArg: PublicKey, BArg: PublicKey, S: Point): { R: Point, SPrime: Point, z: BigNumber } {
+   * Generates a proof that demonstrates the link between public key A and shared secret S
+   * @param a Private key corresponding to public key A
+   * @param A Public key
+   * @param B Other party's public key
+   * @param S Shared secret
+   * @returns Proof (R, S', z)
+   */
+  generateProof (
+    aArg: PrivateKey,
+    AArg: PublicKey,
+    BArg: PublicKey,
+    S: Point
+  ): { R: Point, SPrime: Point, z: BigNumber } {
     const r = PrivateKey.fromRandom()
     const R = r.toPublicKey()
     const SPrime = BArg.mul(r)
@@ -59,14 +64,19 @@ export default class Schnorr {
   }
 
   /**
-     * Verifies the proof of the link between public key A and shared secret S
-     * @param A Public key
-     * @param B Other party's public key
-     * @param S Shared secret
-     * @param proof Proof (R, S', z)
-     * @returns True if the proof is valid, false otherwise
-     */
-  verifyProof (A: Point, B: Point, S: Point, proof: { R: Point, SPrime: Point, z: BigNumber }): boolean {
+   * Verifies the proof of the link between public key A and shared secret S
+   * @param A Public key
+   * @param B Other party's public key
+   * @param S Shared secret
+   * @param proof Proof (R, S', z)
+   * @returns True if the proof is valid, false otherwise
+   */
+  verifyProof (
+    A: Point,
+    B: Point,
+    S: Point,
+    proof: { R: Point, SPrime: Point, z: BigNumber }
+  ): boolean {
     const { R, SPrime, z } = proof
     const e = this.computeChallenge(A, B, S, SPrime, R)
 
@@ -87,8 +97,20 @@ export default class Schnorr {
     return true
   }
 
-  private computeChallenge (A: Point, B: Point, S: Point, SPrime: Point, R: Point): BigNumber {
-    const message = [...A.encode(true), ...B.encode(true), ...S.encode(true), ...SPrime.encode(true), ...R.encode(true)] as number[]
+  private computeChallenge (
+    A: Point,
+    B: Point,
+    S: Point,
+    SPrime: Point,
+    R: Point
+  ): BigNumber {
+    const message = [
+      ...A.encode(true),
+      ...B.encode(true),
+      ...S.encode(true),
+      ...SPrime.encode(true),
+      ...R.encode(true)
+    ] as number[]
     const hash = sha256(message)
     return new BigNumber(hash).umod(this.curve.n)
   }

package/src/primitives/Signature.ts

@@ -64,7 +64,7 @@ export default class Signature {
       throw new Error('Signature DER must start with 0x30')
     }
     const len = getLength(data, p)
-    if ((len + p.place) !== data.length) {
+    if (len + p.place !== data.length) {
       throw new Error('Signature DER invalid')
     }
     if (data[p.place++] !== 0x02) {
@@ -96,10 +96,7 @@ export default class Signature {
       }
     }
 
-    return new Signature(
-      new BigNumber(r),
-      new BigNumber(s)
-    )
+    return new Signature(new BigNumber(r), new BigNumber(s))
   }
 
   /**
@@ -120,7 +117,10 @@ export default class Signature {
    * @example
    * const signature = Signature.fromCompact('1b18c1f5502f8...', 'hex');
    */
-  static fromCompact (data: number[] | string, enc?: 'hex' | 'base64'): Signature {
+  static fromCompact (
+    data: number[] | string,
+    enc?: 'hex' | 'base64'
+  ): Signature {
     data = toArray(data, enc)
     if (data.length !== 65) {
       throw new Error('Invalid Compact Signature')
@@ -189,7 +189,7 @@ export default class Signature {
    * @example
    * const der = signature.toString('base64');
    */
-  toString (enc?: 'hex' | 'base64') {
+  toString (enc?: 'hex' | 'base64'): number[] | string {
     return this.toDER(enc)
   }
 
@@ -219,7 +219,7 @@ export default class Signature {
     const rmPadding = (buf: number[]): number[] => {
       let i = 0
       const len = buf.length - 1
-      while ((buf[i] === 0) && ((buf[i + 1] & 0x80) === 0) && i < len) {
+      while (buf[i] === 0 && (buf[i + 1] & 0x80) === 0 && i < len) {
         i++
       }
       if (i === 0) {
@@ -232,14 +232,18 @@ export default class Signature {
     let s = this.s.toArray()
 
     // Pad values
-    if ((r[0] & 0x80) !== 0) { r = [0].concat(r) }
+    if ((r[0] & 0x80) !== 0) {
+      r = [0].concat(r)
+    }
     // Pad values
-    if ((s[0] & 0x80) !== 0) { s = [0].concat(s) }
+    if ((s[0] & 0x80) !== 0) {
+      s = [0].concat(s)
+    }
 
     r = rmPadding(r)
     s = rmPadding(s)
 
-    while ((s[0] === 0) && (s[1] & 0x80) === 0) {
+    while (s[0] === 0 && (s[1] & 0x80) === 0) {
       s = s.slice(1)
     }
     let arr = [0x02]
@@ -274,9 +278,15 @@ export default class Signature {
    * @example
    * const compact = signature.toCompact(3, true, 'base64');
    */
-  toCompact (recovery: number, compressed: boolean, enc?: 'hex' | 'base64'): number[] | string {
+  toCompact (
+    recovery: number,
+    compressed: boolean,
+    enc?: 'hex' | 'base64'
+  ): number[] | string {
     if (recovery < 0 || recovery > 3) throw new Error('Invalid recovery param')
-    if (typeof compressed !== 'boolean') throw new Error('Invalid compressed param')
+    if (typeof compressed !== 'boolean') {
+      throw new Error('Invalid compressed param')
+    }
     let compactByte = 27 + recovery
     if (compressed) {
       compactByte += 4
@@ -311,7 +321,7 @@ export default class Signature {
     const s = this.s
 
     // A set LSB signifies that the y-coordinate is odd
-    const isYOdd = !!(recovery & 1)
+    const isYOdd = (recovery & 1) !== 0
 
     // The more significant bit specifies whether we should use the
     // first or second candidate key.
@@ -322,7 +332,7 @@ export default class Signature {
     const G = curve.g
 
     // 1.1 LEt x = r + jn
-    const x = isSecondKey ? r.add(n) : r
+    const x = isSecondKey !== 0 ? r.add(n) : r
     const R = Point.fromX(x, isYOdd)
 
     // 1.4 Check that nR is at infinity
@@ -367,7 +377,7 @@ export default class Signature {
       let Qprime
       try {
         Qprime = this.RecoverPublicKey(recovery, msgHash)
-      } catch (e) {
+      } catch {
         continue
       }
       if (pubkey.eq(Qprime)) {

package/src/primitives/SymmetricKey.ts

@@ -27,19 +27,19 @@ export default class SymmetricKey extends BigNumber {
   }
 
   /**
-  * Encrypts a given message using AES-GCM encryption.
-  * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
-  * The OpenSSL format of |IV|encryptedContent|authTag| is used.
-  *
-  * @method encrypt
-  * @param msg - The message to be encrypted. It can be a string or an array of numbers.
-  * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
-  * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
-  *
-  * @example
-  * const key = new SymmetricKey(1234);
-  * const encryptedMessage = key.encrypt('plainText', 'utf8');
-  */
+   * Encrypts a given message using AES-GCM encryption.
+   * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
+   * The OpenSSL format of |IV|encryptedContent|authTag| is used.
+   *
+   * @method encrypt
+   * @param msg - The message to be encrypted. It can be a string or an array of numbers.
+   * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
+   * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
+   *
+   * @example
+   * const key = new SymmetricKey(1234);
+   * const encryptedMessage = key.encrypt('plainText', 'utf8');
+   */
   encrypt (msg: number[] | string, enc?: 'hex'): string | number[] {
     const iv = Random(32)
     msg = toArray(msg, enc)
@@ -69,7 +69,7 @@ export default class SymmetricKey extends BigNumber {
    * @throws {Error} Will throw an error if the decryption fails, likely due to message tampering or incorrect decryption key.
    */
   decrypt (msg: number[] | string, enc?: 'hex' | 'utf8'): string | number[] {
-    msg = toArray(msg, enc) as number[]
+    msg = toArray(msg, enc)
     const iv = msg.slice(0, 32)
     const ciphertextWithTag = msg.slice(32)
     const messageTag = ciphertextWithTag.slice(-16)

package/src/primitives/TransactionSignature.ts

@@ -38,8 +38,12 @@ export default class TransactionSignature extends Signature {
 
     const getPrevoutHash = (): number[] => {
       const writer = new Writer()
+
       for (const input of inputs) {
         if (typeof input.sourceTXID === 'undefined') {
+          if (input.sourceTransaction == null) {
+            throw new Error('Missing sourceTransaction for input')
+          }
           writer.write(input.sourceTransaction.hash() as number[])
         } else {
           writer.writeReverse(toArray(input.sourceTXID, 'hex'))
@@ -56,7 +60,8 @@ export default class TransactionSignature extends Signature {
       const writer = new Writer()
 
       for (const input of inputs) {
-        writer.writeUInt32LE(input.sequence)
+        const sequence = input.sequence ?? 0xffffffff // Default to max sequence number
+        writer.writeUInt32LE(sequence)
       }
 
       const buf = writer.toArray()
@@ -68,17 +73,25 @@ export default class TransactionSignature extends Signature {
       const writer = new Writer()
 
       if (typeof outputIndex === 'undefined') {
-        let script: number[]
         for (const output of params.outputs) {
-          writer.writeUInt64LE(output.satoshis)
-          script = output.lockingScript.toBinary()
+          const satoshis = output.satoshis ?? 0 // Default to 0 if undefined
+          writer.writeUInt64LE(satoshis)
+
+          const script = output.lockingScript?.toBinary() ?? []
           writer.writeVarIntNum(script.length)
           writer.write(script)
         }
       } else {
         const output = params.outputs[outputIndex]
-        writer.writeUInt64LE(output.satoshis)
-        const script = output.lockingScript.toBinary()
+
+        if (output === undefined) { // ✅ Explicitly check for undefined
+          throw new Error(`Output at index ${outputIndex} does not exist`)
+        }
+
+        const satoshis = output.satoshis ?? 0 // Default to 0 if undefined
+        writer.writeUInt64LE(satoshis)
+
+        const script = output.lockingScript?.toBinary() ?? []
         writer.writeVarIntNum(script.length)
         writer.write(script)
       }
@@ -96,15 +109,23 @@ export default class TransactionSignature extends Signature {
       hashPrevouts = getPrevoutHash()
     }
 
-    if ((params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0 &&
+    if (
+      (params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0 &&
       (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
-      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
+      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
+    ) {
       hashSequence = getSequenceHash()
     }
 
-    if ((params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE && (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
+    if (
+      (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
+      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
+    ) {
       hashOutputs = getOutputsHash()
-    } else if ((params.scope & 31) === TransactionSignature.SIGHASH_SINGLE && params.inputIndex < params.outputs.length) {
+    } else if (
+      (params.scope & 31) === TransactionSignature.SIGHASH_SINGLE &&
+      params.inputIndex < params.outputs.length
+    ) {
       hashOutputs = getOutputsHash(params.inputIndex)
     }
 
@@ -167,16 +188,19 @@ export default class TransactionSignature extends Signature {
   }
 
   /**
-     * Compares to bitcoind's IsLowDERSignature
-     * See also Ecdsa signature algorithm which enforces this.
-     * See also Bip 62, "low S values in signatures"
-     */
+   * Compares to bitcoind's IsLowDERSignature
+   * See also Ecdsa signature algorithm which enforces this.
+   * See also Bip 62, "low S values in signatures"
+   */
   public hasLowS (): boolean {
     if (
       this.s.ltn(1) ||
-      this.s.gt(new BigNumber(
-        '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex'
-      ))
+      this.s.gt(
+        new BigNumber(
+          '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0',
+          'hex'
+        )
+      )
     ) {
       return false
     }