@bsv/sdk 2.1.0 → 2.1.2

package/src/primitives/JacobianPoint.ts

@@ -2,6 +2,8 @@ import BasePoint from './BasePoint.js'
 import BigNumber from './BigNumber.js'
 import Point from './Point.js'
 
+type JacobianCoord = string | BigNumber | null
+
 /**
  * The `JacobianPoint` class extends the `BasePoint` class for handling Jacobian coordinates on an Elliptic Curve.
  * This class defines the properties and the methods needed to work with points in Jacobian coordinates.
@@ -39,9 +41,9 @@ export default class JacobianPoint extends BasePoint {
    * const pointJ2 = new JacobianPoint('3', '4', '1'); // creates point (3, 4, 1)
    */
   constructor (
-    x: string | BigNumber | null,
-    y: string | BigNumber | null,
-    z: string | BigNumber | null
+    x: JacobianCoord,
+    y: JacobianCoord,
+    z: JacobianCoord
   ) {
     super('jacobian')
     if (x === null && y === null && z === null) {
@@ -157,10 +159,10 @@ export default class JacobianPoint extends BasePoint {
     const h = u1.redSub(u2)
     const r = s1.redSub(s2)
     if (h.cmpn(0) === 0) {
-      if (r.cmpn(0) !== 0) {
-        return new JacobianPoint(null, null, null)
-      } else {
+      if (r.cmpn(0) === 0) {
         return this.dbl()
+      } else {
+        return new JacobianPoint(null, null, null)
       }
     }
 
@@ -215,10 +217,10 @@ export default class JacobianPoint extends BasePoint {
     const h = u1.redSub(u2)
     const r = s1.redSub(s2)
     if (h.cmpn(0) === 0) {
-      if (r.cmpn(0) !== 0) {
-        return new JacobianPoint(null, null, null)
-      } else {
+      if (r.cmpn(0) === 0) {
         return this.dbl()
+      } else {
+        return new JacobianPoint(null, null, null)
       }
     }
 
@@ -251,7 +253,7 @@ export default class JacobianPoint extends BasePoint {
     if (this.isInfinity()) {
       return this
     }
-    if (typeof pow === 'undefined') {
+    if (pow === undefined) {
       return this.dbl()
     }
 
@@ -414,7 +416,7 @@ export default class JacobianPoint extends BasePoint {
     }
 
     const xc = x.clone()
-    if (this.curve === null || (this.curve.redN == null)) {
+    if (this.curve?.redN == null) {
       throw new Error('Curve or redN is not initialized.')
     }
 

package/src/primitives/K256.ts

@@ -77,7 +77,7 @@ export default class K256 extends Mersenne {
     let currentInputNewWordCount = 0
 
     for (let i = 10; i < inputNominalLength; i++) {
-      const next = inputWords[i] | 0
+      const next = Math.trunc(inputWords[i])
       if (currentInputNewWordCount < tempInputNewWords.length) { // Boundary check
         tempInputNewWords[currentInputNewWordCount++] = ((next & mask) << 4) | (prev >>> 22)
       }
@@ -123,10 +123,10 @@ export default class K256 extends Mersenne {
 
     let lo = 0
     for (let i = 0; i < newNominalLength; i++) { // Iterate up to new expanded length
-      const w = tempWords[i] | 0
+      const w = Math.trunc(tempWords[i])
       lo += w * 0x3d1 // 0x3d1 = 977
       tempWords[i] = lo & 0x3ffffff // 26-bit mask
-      lo = w * 0x40 + ((lo / 0x4000000) | 0) // 0x40 = 64. 0x4000000 = 2^26
+      lo = w * 0x40 + Math.trunc(lo / 0x4000000) // 0x40 = 64. 0x4000000 = 2^26
     }
 
     num.words = tempWords // Use setter to re-initialize from tempWords

package/src/primitives/Point.ts

@@ -163,20 +163,17 @@ export const scalarMultiplyWNAF = (
 ): JacobianPointBI => {
   const key = `${window}:${P0.x.toString(16)}:${P0.y.toString(16)}`
   let tbl = WNAF_TABLE_CACHE.get(key)
-  let P: JacobianPointBI
   if (tbl === undefined) {
     // Convert affine to Jacobian and pre-compute odd multiples
     const tblSize = 1 << (window - 1) // e.g. w=5 → 16 entries
     tbl = new Array(tblSize)
-    P = { X: P0.x, Y: P0.y, Z: BI_ONE }
+    const P: JacobianPointBI = { X: P0.x, Y: P0.y, Z: BI_ONE }
     tbl[0] = P
     const twoP = jpDouble(P)
     for (let i = 1; i < tblSize; i++) {
       tbl[i] = jpAdd(tbl[i - 1], twoP)
     }
     WNAF_TABLE_CACHE.set(key, tbl)
-  } else {
-    P = tbl[0]
   }
 
   // Build wNAF representation of k
@@ -277,11 +274,11 @@ export default class Point extends BasePoint {
       bytes.length - 1 === 2 * len
     ) {
       if (bytes[0] === 0x06) {
-        if (bytes[bytes.length - 1] % 2 !== 0) {
+        if (bytes.at(-1) % 2 !== 0) {
           throw new Error('Point string value is wrong length')
         }
       } else if (bytes[0] === 0x07) {
-        if (bytes[bytes.length - 1] % 2 !== 1) {
+        if (bytes.at(-1) % 2 !== 1) {
           throw new Error('Point string value is wrong length')
         }
       }
@@ -523,10 +520,10 @@ export default class Point extends BasePoint {
     } else {
       res = [0x04].concat(x, this.getY().toArray('be', len))
     }
-    if (enc !== 'hex') {
-      return res
-    } else {
+    if (enc === 'hex') {
       return toHex(res)
+    } else {
+      return res
     }
   }
 
@@ -573,19 +570,19 @@ export default class Point extends BasePoint {
       typeof this.precomputed === 'object' && this.precomputed !== null
         ? {
             doubles:
-            this.precomputed.doubles != null
-              ? {
+            this.precomputed.doubles == null
+              ? undefined
+              : {
                   step: this.precomputed.doubles.step,
                   points: this.precomputed.doubles.points.slice(1)
-                }
-              : undefined,
+                },
             naf:
-            this.precomputed.naf != null
-              ? {
+            this.precomputed.naf == null
+              ? undefined
+              : {
                   wnd: this.precomputed.naf.wnd,
                   points: this.precomputed.naf.points.slice(1)
                 }
-              : undefined
           }
         : undefined
     ]
@@ -827,8 +824,8 @@ export default class Point extends BasePoint {
     let R1: JacobianPointBI = { X: Px, Y: Py, Z: 1n }
 
     const bits = kBig.toString(2)
-    for (let i = 0; i < bits.length; i++) {
-      const bit = bits[i] === '1' ? 1n : 0n
+    for (const bitChar of bits) {
+      const bit = bitChar === '1' ? 1n : 0n
       ctSwap(bit, R0, R1)
       R1 = jpAdd(R0, R1)
       R0 = jpDouble(R0)
@@ -927,18 +924,18 @@ export default class Point extends BasePoint {
       const pre = this.precomputed
       const negate = (p: Point): Point => p.neg()
       res.precomputed = {
-        naf: pre.naf != null
-          ? {
+        naf: pre.naf == null
+          ? undefined
+          : {
               wnd: pre.naf.wnd,
               points: pre.naf.points.map(negate) as BasePoint[]
-            }
-          : undefined,
-        doubles: pre.doubles != null
-          ? {
+            },
+        doubles: pre.doubles == null
+          ? undefined
+          : {
               step: pre.doubles.step,
               points: pre.doubles.points.map((p) => (p as Point).neg())
-            }
-          : undefined,
+            },
         beta: undefined
       }
     }
@@ -1019,19 +1016,19 @@ export default class Point extends BasePoint {
       beta.precomputed = {
         beta: null,
         naf:
-          pre.naf != null
-            ? {
+          pre.naf == null
+            ? undefined
+            : {
                 wnd: pre.naf.wnd,
                 points: pre.naf.points.map(endoMul)
-              }
-            : undefined,
+              },
         doubles:
-          pre.doubles != null
-            ? {
+          pre.doubles == null
+            ? undefined
+            : {
                 step: pre.doubles.step,
                 points: pre.doubles.points.map(endoMul)
               }
-            : undefined
       }
     }
     return beta
@@ -1142,8 +1139,8 @@ export default class Point extends BasePoint {
       naf[a] = new Array(max)
       naf[b] = new Array(max)
       for (let j = 0; j < max; j++) {
-        const ja = jsf[0][j] | 0
-        const jb = jsf[1][j] | 0
+        const ja = Math.trunc(jsf[0][j])
+        const jb = Math.trunc(jsf[1][j])
 
         naf[a][j] = index[(ja + 1) * 3 + (jb + 1)]
         naf[b][j] = 0
@@ -1187,10 +1184,10 @@ export default class Point extends BasePoint {
 
         if (z.cmpn(0) === 0) { // Check if z is 0
           continue
-        } else if (!z.isNeg()) { // If z is positive
-          p = wnd[j][z.sub(one).div(two).toNumber()]
-        } else { // If z is negative
+        } else if (z.isNeg()) { // If z is negative
           p = wnd[j][z.neg().sub(one).div(two).toNumber()].neg()
+        } else { // If z is positive
+          p = wnd[j][z.sub(one).div(two).toNumber()]
         }
 
         if (p.type === 'affine') {

package/src/primitives/PrivateKey.ts

@@ -399,13 +399,13 @@ export default class PrivateKey extends BigNumber {
     let sharedSecret: Point
     if (typeof retrieveCachedSharedSecret === 'function') {
       const retrieved = retrieveCachedSharedSecret(this, publicKey)
-      if (retrieved !== undefined) {
-        sharedSecret = retrieved
-      } else {
+      if (retrieved === undefined) {
         sharedSecret = this.deriveSharedSecret(publicKey)
         if (typeof cacheSharedSecret === 'function') {
           cacheSharedSecret(this, publicKey, sharedSecret)
         }
+      } else {
+        sharedSecret = retrieved
       }
     } else {
       sharedSecret = this.deriveSharedSecret(publicKey)

package/src/primitives/PublicKey.ts

@@ -215,13 +215,13 @@ export default class PublicKey extends Point {
     let sharedSecret: Point
     if (typeof retrieveCachedSharedSecret === 'function') {
       const retrieved = retrieveCachedSharedSecret(privateKey, this)
-      if (typeof retrieved !== 'undefined') {
-        sharedSecret = retrieved
-      } else {
+      if (retrieved === undefined) {
         sharedSecret = this.deriveSharedSecret(privateKey)
         if (typeof cacheSharedSecret === 'function') {
           cacheSharedSecret(privateKey, this, sharedSecret)
         }
+      } else {
+        sharedSecret = retrieved
       }
     } else {
       sharedSecret = this.deriveSharedSecret(privateKey)

package/src/primitives/Random.ts

@@ -31,7 +31,6 @@ class Rand {
     // Try globalThis.crypto (works in Node.js 18+, modern browsers, and Deno)
     if (typeof globalThis !== 'undefined' && typeof (globalThis as any).crypto?.getRandomValues === 'function') {
       this._rand = (n) => {
-        /* eslint-disable-next-line */
         return this.getRandomValues(globalThis as any, n)
       }
       return
@@ -41,32 +40,30 @@ class Rand {
     if (typeof process !== 'undefined' && process.release?.name === 'node') {
       try {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const crypto = require('crypto')
+        const crypto = require('node:crypto')
         if (typeof crypto.randomBytes === 'function') {
           this._rand = (n) => {
             return Array.from(crypto.randomBytes(n))
           }
           return
         }
-      } catch (e) {
-        // crypto module not available, continue to other checks
+      } catch (_cryptoModuleUnavailable) {
+        // node:crypto not available in this runtime; continue to other crypto API checks
       }
     }
 
     // Try self.crypto (Web Workers and Service Workers)
-    if (typeof self !== 'undefined' && typeof self.crypto?.getRandomValues === 'function') {
+    if (typeof globalThis.self !== 'undefined' && typeof globalThis.self.crypto?.getRandomValues === 'function') {
       this._rand = (n) => {
-        /* eslint-disable-next-line */
-        return this.getRandomValues(self as any, n)
+        return this.getRandomValues(globalThis.self, n)
       }
       return
     }
 
     // Try window.crypto (browsers)
-    if (typeof window !== 'undefined' && typeof (window as any).crypto?.getRandomValues === 'function') {
+    if (typeof globalThis.window !== 'undefined' && typeof (globalThis.window as any).crypto?.getRandomValues === 'function') {
       this._rand = (n) => {
-        /* eslint-disable-next-line */
-        return this.getRandomValues(window as any, n)
+        return this.getRandomValues(globalThis.window, n)
       }
       return
     }
@@ -93,9 +90,9 @@ let ayn: Rand | null = null
  * import Random from '@bsv/sdk/primitives/Random'
  * const bytes = Random(32) // Produces 32 random bytes
  */
-export default (len: number): number[] => {
-  if (ayn == null) {
-    ayn = new Rand()
-  }
+const Random = (len: number): number[] => {
+  ayn ??= new Rand()
   return ayn.generate(len)
 }
+
+export default Random

package/src/primitives/ReaderUint8Array.ts

@@ -25,7 +25,7 @@ export class ReaderUint8Array {
     } else if (Array.isArray(bin)) {
       this.bin = new Uint8Array(bin)
     } else {
-      throw new Error('ReaderUint8Array constructor: bin must be Uint8Array or number[]')
+      throw new TypeError('ReaderUint8Array constructor: bin must be Uint8Array or number[]')
     }
     this.pos = pos
     this.length = this.bin.length
@@ -61,7 +61,7 @@ export class ReaderUint8Array {
     const val = this.bin[this.pos]
     this.pos += 1
     // If the sign bit is set, convert to negative value
-    return (val & 0x80) !== 0 ? val - 0x100 : val
+    return (val & 0x80) === 0 ? val : val - 0x100
   }
 
   public readUInt16BE (): number {
@@ -73,10 +73,10 @@ export class ReaderUint8Array {
   public readInt16BE (): number {
     const val = this.readUInt16BE()
     // If the sign bit is set, convert to negative value
-    return (val & 0x8000) !== 0 ? val - 0x10000 : val
+    return (val & 0x8000) === 0 ? val : val - 0x10000
   }
 
-  public readUInt16LE (): number {
+  public readUInt16LE(): number {
     const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
     this.pos += 2
     return val
@@ -85,7 +85,7 @@ export class ReaderUint8Array {
   public readInt16LE (): number {
     const val = this.readUInt16LE()
     // If the sign bit is set, convert to negative value
-    const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
+    const x = (val & 0x8000) === 0 ? val : val - 0x10000
     return x
   }
 
@@ -102,7 +102,7 @@ export class ReaderUint8Array {
   public readInt32BE (): number {
     const val = this.readUInt32BE()
     // If the sign bit is set, convert to negative value
-    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+    return (val & 0x80000000) === 0 ? val : val - 0x100000000
   }
 
   public readUInt32LE (): number {
@@ -119,7 +119,7 @@ export class ReaderUint8Array {
   public readInt32LE (): number {
     const val = this.readUInt32LE()
     // Explicitly check if the sign bit is set and then convert to a negative value
-    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+    return (val & 0x80000000) === 0 ? val : val - 0x100000000
   }
 
   public readUInt64BEBn (): BigNumber {

package/src/primitives/Schnorr.ts

@@ -2,7 +2,8 @@ import BigNumber from './BigNumber.js'
 import Curve from './Curve.js'
 import Point from './Point.js'
 import { sha256 } from './Hash.js'
-import { PrivateKey, PublicKey } from './index.js'
+import PrivateKey from './PrivateKey.js'
+import PublicKey from './PublicKey.js'
 
 /**
  * Class representing the Schnorr Zero-Knowledge Proof (ZKP) protocol.

package/src/primitives/Secp256r1.ts

@@ -189,7 +189,8 @@ export default class Secp256r1 {
     try {
       this.assertOnCurve(p)
       return true
-    } catch (err) {
+    } catch (_notOnCurve) {
+      // assertOnCurve throws when the point is not on the curve; return false
       return false
     }
   }

package/src/primitives/Signature.ts

@@ -82,17 +82,17 @@ export default class Signature {
     }
     let s = data.slice(p.place, slen + p.place)
     if (r[0] === 0) {
-      if ((r[1] & 0x80) !== 0) {
-        r = r.slice(1)
-      } else {
+      if ((r[1] & 0x80) === 0) {
         throw new Error('Invalid R-value in signature DER')
+      } else {
+        r = r.slice(1)
       }
     }
     if (s[0] === 0) {
-      if ((s[1] & 0x80) !== 0) {
-        s = s.slice(1)
-      } else {
+      if ((s[1] & 0x80) === 0) {
         throw new Error('Invalid S-value in signature DER')
+      } else {
+        s = s.slice(1)
       }
     }
 
@@ -285,7 +285,7 @@ export default class Signature {
   ): number[] | string {
     if (recovery < 0 || recovery > 3) throw new Error('Invalid recovery param')
     if (typeof compressed !== 'boolean') {
-      throw new Error('Invalid compressed param')
+      throw new TypeError('Invalid compressed param')
     }
     let compactByte = 27 + recovery
     if (compressed) {
@@ -332,7 +332,7 @@ export default class Signature {
     const G = curve.g
 
     // 1.1 LEt x = r + jn
-    const x = isSecondKey !== 0 ? r.add(n) : r
+    const x = isSecondKey === 0 ? r : r.add(n)
     const R = Point.fromX(x, isYOdd)
 
     // 1.4 Check that nR is at infinity

package/src/primitives/SymmetricKey.ts

@@ -3,6 +3,124 @@ import { AESGCM, AESGCMDecrypt } from './AESGCM.js'
 import Random from './Random.js'
 import { toArray, encode } from './utils.js'
 
+// ---------------------------------------------------------------------------
+// Native AES-GCM fast-path via node:crypto / react-native-quick-crypto
+//
+// Resolved once at module load using the same pattern as Hash.ts.  When
+// `node:crypto` (or a compatible shim) is available and exposes
+// `createCipheriv` / `createDecipheriv`, encrypt and decrypt will use it
+// instead of the pure-TS implementation.  The pure-TS path remains the
+// unconditional fallback — any error in the native path causes silent
+// re-execution through the pure-TS implementation.
+// ---------------------------------------------------------------------------
+const NODE_CRYPTO_SYM = (() => {
+  const processLike =
+    typeof globalThis === 'undefined' ? undefined : (globalThis as any).process
+  const getBuiltinModule = processLike?.getBuiltinModule
+  if (typeof getBuiltinModule === 'function') {
+    try {
+      const crypto = getBuiltinModule.call(processLike, 'node:crypto')
+      if (crypto != null) return crypto
+    } catch {
+      // continue to CommonJS fallback
+    }
+  }
+  try {
+    if (typeof require === 'function') {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      return require('node:crypto')
+    }
+  } catch {
+    // node:crypto is unavailable in this runtime
+  }
+  return undefined
+})()
+
+/** True when the runtime provides a usable createCipheriv for aes-256-gcm. */
+const NATIVE_AES_GCM_AVAILABLE: boolean = (() => {
+  if (NODE_CRYPTO_SYM == null) return false
+  return (
+    typeof NODE_CRYPTO_SYM.createCipheriv === 'function' &&
+    typeof NODE_CRYPTO_SYM.createDecipheriv === 'function'
+  )
+})()
+
+/**
+ * Encrypt `plaintext` with AES-256-GCM via node:crypto.
+ * Returns `iv (32 bytes) || ciphertext || authTag (16 bytes)` — identical
+ * layout to the pure-TS AESGCM path used by SymmetricKey.encrypt.
+ *
+ * Returns `null` on any failure so the caller can fall back to pure-TS.
+ */
+function nativeEncrypt (
+  plaintext: Uint8Array,
+  iv: Uint8Array,
+  key: Uint8Array
+): Uint8Array | null {
+  try {
+    const cipher = NODE_CRYPTO_SYM.createCipheriv(
+      'aes-256-gcm',
+      Buffer.from(key.buffer, key.byteOffset, key.byteLength),
+      Buffer.from(iv.buffer, iv.byteOffset, iv.byteLength)
+    )
+    const encrypted: Buffer = Buffer.concat([
+      cipher.update(Buffer.from(plaintext.buffer, plaintext.byteOffset, plaintext.byteLength)),
+      cipher.final()
+    ])
+    const authTag: Buffer = cipher.getAuthTag() // always 16 bytes for GCM
+
+    const out = new Uint8Array(iv.length + encrypted.length + authTag.length)
+    let offset = 0
+    out.set(iv, offset); offset += iv.length
+    out.set(encrypted, offset); offset += encrypted.length
+    out.set(authTag, offset)
+    return out
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Decrypt an `iv || ciphertext || authTag` bundle produced by nativeEncrypt
+ * (or by the pure-TS SymmetricKey.encrypt path) using node:crypto.
+ *
+ * Returns the plaintext on success, `null` on authentication failure, or
+ * `undefined` to signal a non-auth error so the caller can fall back.
+ */
+function nativeDecrypt (
+  msgBytes: Uint8Array,
+  ivLength: number,
+  tagLength: number,
+  key: Uint8Array
+): Uint8Array | null | undefined {
+  try {
+    const iv = msgBytes.slice(0, ivLength)
+    const tagStart = msgBytes.length - tagLength
+    const ciphertext = msgBytes.slice(ivLength, tagStart)
+    const messageTag = msgBytes.slice(tagStart)
+
+    const decipher = NODE_CRYPTO_SYM.createDecipheriv(
+      'aes-256-gcm',
+      Buffer.from(key.buffer, key.byteOffset, key.byteLength),
+      Buffer.from(iv.buffer, iv.byteOffset, iv.byteLength)
+    )
+    decipher.setAuthTag(Buffer.from(messageTag.buffer, messageTag.byteOffset, messageTag.byteLength))
+
+    // Decryption authenticates on final(); throws if tag is wrong.
+    const decrypted: Buffer = Buffer.concat([
+      decipher.update(Buffer.from(ciphertext.buffer, ciphertext.byteOffset, ciphertext.byteLength)),
+      decipher.final()
+    ])
+    return new Uint8Array(decrypted.buffer, decrypted.byteOffset, decrypted.byteLength)
+  } catch {
+    // Node throws "Unsupported state or unable to authenticate data" on auth
+    // failure. Treat any error as auth failure so SymmetricKey.decrypt re-throws
+    // its own descriptive message — pure-TS fallback would return null in the
+    // same scenario.
+    return null
+  }
+}
+
 /**
  * `SymmetricKey` is a class that extends the `BigNumber` class and implements symmetric encryption and decryption methods.
  * Symmetric-Key encryption is a form of encryption where the same key is used to encrypt and decrypt the message.
@@ -45,6 +163,16 @@ export default class SymmetricKey extends BigNumber {
     const msgBytes = new Uint8Array(toArray(msg, enc))
     const keyBytes = new Uint8Array(this.toArray('be', 32))
 
+    // Fast path: native AES-256-GCM via node:crypto / react-native-quick-crypto.
+    // Falls back to pure-TS on any failure.
+    if (NATIVE_AES_GCM_AVAILABLE) {
+      const nativeResult = nativeEncrypt(msgBytes, iv, keyBytes)
+      if (nativeResult !== null) {
+        return encode(Array.from(nativeResult), enc)
+      }
+    }
+
+    // Pure-TS fallback.
     const { result, authenticationTag } = AESGCM(
       msgBytes,
       iv,
@@ -90,12 +218,28 @@ export default class SymmetricKey extends BigNumber {
       throw new Error('Ciphertext too short')
     }
 
+    const keyBytes = new Uint8Array(this.toArray('be', 32))
+
+    // Fast path: native AES-256-GCM via node:crypto / react-native-quick-crypto.
+    // Falls back to pure-TS on null/undefined return.
+    if (NATIVE_AES_GCM_AVAILABLE) {
+      const nativeResult = nativeDecrypt(msgBytes, ivLength, tagLength, keyBytes)
+      if (nativeResult !== undefined) {
+        // nativeResult is Uint8Array on success or null on auth/decryption failure.
+        if (nativeResult === null) {
+          throw new Error('Decryption failed!')
+        }
+        return encode(Array.from(nativeResult), enc)
+      }
+      // undefined means unexpected setup error — fall through to pure-TS.
+    }
+
+    // Pure-TS fallback.
     const iv = msgBytes.slice(0, ivLength)
     const tagStart = msgBytes.length - tagLength
     const ciphertext = msgBytes.slice(ivLength, tagStart)
     const messageTag = msgBytes.slice(tagStart)
 
-    const keyBytes = new Uint8Array(this.toArray('be', 32))
     const result = AESGCMDecrypt(
       ciphertext,
       iv,