@bsv/sdk 2.1.1 → 2.1.2

package/src/primitives/Hash.ts

@@ -349,10 +349,141 @@ function zero8 (word: string): string {
   }
 }
 
+const BufferCtor =
+  typeof globalThis === 'undefined' ? undefined : (globalThis as any).Buffer
+const CAN_USE_BUFFER =
+  BufferCtor != null && typeof BufferCtor.from === 'function'
+const HEX_DIGITS = '0123456789abcdef'
+const HEX_BYTE_STRINGS = new Array<string>(256)
+for (let i = 0; i < HEX_BYTE_STRINGS.length; i++) {
+  HEX_BYTE_STRINGS[i] = HEX_DIGITS[(i >> 4) & 0xf] + HEX_DIGITS[i & 0xf]
+}
+
 function bytesToHex (data: Uint8Array): string {
-  let res = ''
-  for (const b of data) res += (b.toString(16).padStart(2, '0'))
-  return res
+  if (CAN_USE_BUFFER) {
+    return BufferCtor.from(data).toString('hex')
+  }
+  const out = new Array<string>(data.length)
+  for (let i = 0; i < data.length; i++) out[i] = HEX_BYTE_STRINGS[data[i]]
+  return out.join('')
+}
+
+const NODE_CRYPTO = (() => {
+  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
+})()
+
+type HashInput = Uint8Array | number[] | string
+
+function toHashBytes (msg: HashInput, enc?: 'hex' | 'utf8'): Uint8Array {
+  if (msg instanceof Uint8Array) {
+    return msg
+  }
+  if (Array.isArray(msg)) {
+    return new Uint8Array(msg)
+  }
+  return Uint8Array.from(toArray(msg, enc))
+}
+
+function toHashKeyBytes (key: HashInput): Uint8Array {
+  return typeof key === 'string' ? toHashBytes(key, 'hex') : toHashBytes(key)
+}
+
+interface FallbackHashLike {
+  update: (data: Uint8Array) => unknown
+  digest: () => Uint8Array
+}
+
+function updateNativeOrFallback (
+  native: any,
+  fallback: FallbackHashLike | undefined,
+  data: Uint8Array
+): void {
+  if (native != null) {
+    native.update(data)
+  } else if (fallback != null) {
+    fallback.update(data)
+  }
+}
+
+function digestNativeOrFallback (
+  native: any,
+  fallback: FallbackHashLike | undefined
+): number[] {
+  if (native != null) return Array.from(native.digest())
+  if (fallback != null) return Array.from(fallback.digest())
+  return []
+}
+
+function digestHexNativeOrFallback (
+  native: any,
+  fallback: FallbackHashLike | undefined
+): string {
+  if (native != null) return native.digest('hex')
+  if (fallback != null) return bytesToHex(fallback.digest())
+  return ''
+}
+
+function createNodeHash (algorithm: string): any {
+  const createHash = NODE_CRYPTO?.createHash
+  if (typeof createHash !== 'function') return undefined
+  try {
+    return createHash(algorithm)
+  } catch {
+    return undefined
+  }
+}
+
+function createNodeHmac (algorithm: string, keyBytes: Uint8Array): any {
+  const createHmac = NODE_CRYPTO?.createHmac
+  if (typeof createHmac !== 'function') return undefined
+  try {
+    return createHmac(algorithm, keyBytes)
+  } catch {
+    return undefined
+  }
+}
+
+function digestWithNodeHash (
+  algorithm: string,
+  msg: HashInput,
+  enc?: 'hex' | 'utf8'
+): Uint8Array | undefined {
+  const hash = createNodeHash(algorithm)
+  if (hash == null) return undefined
+  hash.update(toHashBytes(msg, enc))
+  return hash.digest()
+}
+
+function digestWithNodeHmac (
+  algorithm: string,
+  key: HashInput,
+  msg: HashInput,
+  enc?: 'hex' | 'utf8'
+): Uint8Array | undefined {
+  const hmac = createNodeHmac(algorithm, toHashKeyBytes(key))
+  if (hmac == null) return undefined
+  hmac.update(toHashBytes(msg, enc))
+  return hmac.digest()
 }
 
 function join32 (msg, start, end, endian): number[] {
@@ -631,27 +762,27 @@ export class RIPEMD160 extends BaseHash {
  * @property k - The round constants used for each round of SHA-256
  */
 export class SHA256 {
-  private readonly h: FastSHA256
+  private readonly h?: FastSHA256
+  private readonly native?: any
+
   constructor () {
-    this.h = new FastSHA256()
+    this.native = createNodeHash('sha256')
+    if (this.native == null) {
+      this.h = new FastSHA256()
+    }
   }
 
-  update (
-    msg: Uint8Array | number[] | string,
-    enc?: 'hex' | 'utf8'
-  ): this {
-    const data =
-      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
-    this.h.update(data)
+  update (msg: HashInput, enc?: 'hex' | 'utf8'): this {
+    updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc))
     return this
   }
 
   digest (): number[] {
-    return Array.from(this.h.digest())
+    return digestNativeOrFallback(this.native, this.h)
   }
 
   digestHex (): string {
-    return bytesToHex(this.h.digest())
+    return digestHexNativeOrFallback(this.native, this.h)
   }
 }
 
@@ -755,23 +886,27 @@ export class SHA1 extends BaseHash {
  * @property k - The round constants used for each round of SHA-512.
  */
 export class SHA512 {
-  private readonly h: FastSHA512
+  private readonly h?: FastSHA512
+  private readonly native?: any
+
   constructor () {
-    this.h = new FastSHA512()
+    this.native = createNodeHash('sha512')
+    if (this.native == null) {
+      this.h = new FastSHA512()
+    }
   }
 
-  update (msg: number[] | string, enc?: 'hex' | 'utf8'): this {
-    const data = Uint8Array.from(toArray(msg, enc))
-    this.h.update(data)
+  update (msg: HashInput, enc?: 'hex' | 'utf8'): this {
+    updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc))
     return this
   }
 
   digest (): number[] {
-    return Array.from(this.h.digest())
+    return digestNativeOrFallback(this.native, this.h)
   }
 
   digestHex (): string {
-    return bytesToHex(this.h.digest())
+    return digestHexNativeOrFallback(this.native, this.h)
   }
 }
 
@@ -788,7 +923,8 @@ export class SHA512 {
  * @property outSize - The output size of the SHA-256 hash function, in bytes. It's set to 32 bytes.
  */
 export class SHA256HMAC {
-  private readonly h: HMAC<FastSHA256>
+  private readonly h?: HMAC<FastSHA256>
+  private readonly native?: any
   blockSize = 64
   outSize = 32
 
@@ -805,17 +941,12 @@ export class SHA256HMAC {
    * @example
    * const myHMAC = new SHA256HMAC('deadbeef');
    */
-  constructor (key: Uint8Array | number[] | string) {
-    const k =
-      key instanceof Uint8Array
-        ? key
-        : Uint8Array.from(
-          toArray(
-            key,
-            typeof key === 'string' ? 'hex' : undefined
-          )
-        )
-    this.h = new HMAC(sha256Fast, k)
+  constructor (key: HashInput) {
+    const k = toHashKeyBytes(key)
+    this.native = createNodeHmac('sha256', k)
+    if (this.native == null) {
+      this.h = new HMAC(sha256Fast, k)
+    }
   }
 
   /**
@@ -829,10 +960,8 @@ export class SHA256HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update (msg: Uint8Array | number[] | string, enc?: 'hex'): this {
-    const data =
-      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
-    this.h.update(data)
+  update (msg: HashInput, enc?: 'hex'): this {
+    updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc))
     return this
   }
 
@@ -846,7 +975,7 @@ export class SHA256HMAC {
    * let hashedMessage = myHMAC.digest();
    */
   digest (): number[] {
-    return Array.from(this.h.digest())
+    return digestNativeOrFallback(this.native, this.h)
   }
 
   /**
@@ -859,7 +988,7 @@ export class SHA256HMAC {
    * let hashedMessage = myHMAC.digestHex();
    */
   digestHex (): string {
-    return bytesToHex(this.h.digest())
+    return digestHexNativeOrFallback(this.native, this.h)
   }
 }
 
@@ -922,7 +1051,8 @@ export class SHA1HMAC {
  * @property outSize - The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
  */
 export class SHA512HMAC {
-  private readonly h: HMAC<FastSHA512>
+  private readonly h?: HMAC<FastSHA512>
+  private readonly native?: any
   blockSize = 128
   outSize = 32
 
@@ -939,17 +1069,12 @@ export class SHA512HMAC {
    * @example
    * const myHMAC = new SHA512HMAC('deadbeef');
    */
-  constructor (key: Uint8Array | number[] | string) {
-    const k =
-      key instanceof Uint8Array
-        ? key
-        : Uint8Array.from(
-          toArray(
-            key,
-            typeof key === 'string' ? 'hex' : undefined
-          )
-        )
-    this.h = new HMAC(sha512Fast, k)
+  constructor (key: HashInput) {
+    const k = toHashKeyBytes(key)
+    this.native = createNodeHmac('sha512', k)
+    if (this.native == null) {
+      this.h = new HMAC(sha512Fast, k)
+    }
   }
 
   /**
@@ -963,10 +1088,8 @@ export class SHA512HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update (msg: Uint8Array | number[] | string, enc?: 'hex' | 'utf8'): this {
-    const data =
-      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
-    this.h.update(data)
+  update (msg: HashInput, enc?: 'hex' | 'utf8'): this {
+    updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc))
     return this
   }
 
@@ -980,7 +1103,7 @@ export class SHA512HMAC {
    * let hashedMessage = myHMAC.digest();
    */
   digest (): number[] {
-    return Array.from(this.h.digest())
+    return digestNativeOrFallback(this.native, this.h)
   }
 
   /**
@@ -993,10 +1116,32 @@ export class SHA512HMAC {
    * let hashedMessage = myHMAC.digestHex();
    */
   digestHex (): string {
-    return bytesToHex(this.h.digest())
+    return digestHexNativeOrFallback(this.native, this.h)
   }
 }
 
+function sha256Bytes (msg: HashInput, enc?: 'hex' | 'utf8'): Uint8Array {
+  const native = digestWithNodeHash('sha256', msg, enc)
+  if (native != null) return native
+  return new FastSHA256().update(toHashBytes(msg, enc)).digest()
+}
+
+function sha512Bytes (
+  msg: HashInput,
+  enc?: 'hex' | 'utf8'
+): Uint8Array {
+  const native = digestWithNodeHash('sha512', msg, enc)
+  if (native != null) return native
+  return new FastSHA512().update(toHashBytes(msg, enc)).digest()
+}
+
+function ripemd160Bytes (
+  msg: HashInput,
+  enc?: 'hex' | 'utf8'
+): Uint8Array | undefined {
+  return digestWithNodeHash('ripemd160', msg, enc)
+}
+
 /**
  * Computes RIPEMD160 hash of a given message.
  * @function ripemd160
@@ -1012,6 +1157,8 @@ export const ripemd160 = (
   msg: number[] | string,
   enc?: 'hex' | 'utf8'
 ): number[] => {
+  const native = ripemd160Bytes(msg, enc)
+  if (native != null) return Array.from(native)
   return new RIPEMD160().update(msg, enc).digest()
 }
 
@@ -1044,11 +1191,8 @@ export const sha1 = (
  * @example
  * const digest = sha256('Hello, world!');
  */
-export const sha256 = (
-  msg: Uint8Array | number[] | string,
-  enc?: 'hex' | 'utf8'
-): number[] => {
-  return new SHA256().update(msg, enc).digest()
+export const sha256 = (msg: HashInput, enc?: 'hex' | 'utf8'): number[] => {
+  return Array.from(sha256Bytes(msg, enc))
 }
 
 /**
@@ -1062,11 +1206,8 @@ export const sha256 = (
  * @example
  * const digest = sha512('Hello, world!');
  */
-export const sha512 = (
-  msg: number[] | string,
-  enc?: 'hex' | 'utf8'
-): number[] => {
-  return new SHA512().update(msg, enc).digest()
+export const sha512 = (msg: HashInput, enc?: 'hex' | 'utf8'): number[] => {
+  return Array.from(sha512Bytes(msg, enc))
 }
 
 /**
@@ -1082,12 +1223,8 @@ export const sha512 = (
  * @example
  * const doubleHash = hash256('Hello, world!');
  */
-export const hash256 = (
-  msg: Uint8Array | number[] | string,
-  enc?: 'hex' | 'utf8'
-): number[] => {
-  const first = new SHA256().update(msg, enc).digest()
-  return new SHA256().update(first).digest()
+export const hash256 = (msg: HashInput, enc?: 'hex' | 'utf8'): number[] => {
+  return Array.from(sha256Bytes(sha256Bytes(msg, enc)))
 }
 
 /**
@@ -1102,11 +1239,10 @@ export const hash256 = (
  * @example
  * const hash = hash160('Hello, world!');
  */
-export const hash160 = (
-  msg: Uint8Array | number[] | string,
-  enc?: 'hex' | 'utf8'
-): number[] => {
-  const first = new SHA256().update(msg, enc).digest()
+export const hash160 = (msg: HashInput, enc?: 'hex' | 'utf8'): number[] => {
+  const first = sha256Bytes(msg, enc)
+  const native = ripemd160Bytes(first)
+  if (native != null) return Array.from(native)
   return new RIPEMD160().update(first).digest()
 }
 
@@ -1123,10 +1259,12 @@ export const hash160 = (
  * const digest = sha256hmac('deadbeef', 'ffff001d');
  */
 export const sha256hmac = (
-  key: Uint8Array | number[] | string,
-  msg: Uint8Array | number[] | string,
+  key: HashInput,
+  msg: HashInput,
   enc?: 'hex'
 ): number[] => {
+  const native = digestWithNodeHmac('sha256', key, msg, enc)
+  if (native != null) return Array.from(native)
   return new SHA256HMAC(key).update(msg, enc).digest()
 }
 
@@ -1143,10 +1281,12 @@ export const sha256hmac = (
  * const digest = sha512hmac('deadbeef', 'ffff001d');
  */
 export const sha512hmac = (
-  key: Uint8Array | number[] | string,
-  msg: Uint8Array | number[] | string,
+  key: HashInput,
+  msg: HashInput,
   enc?: 'hex'
 ): number[] => {
+  const native = digestWithNodeHmac('sha512', key, msg, enc)
+  if (native != null) return Array.from(native)
   return new SHA512HMAC(key).update(msg, enc).digest()
 }
 
@@ -1938,20 +2078,16 @@ export function pbkdf2 (
   if (digest !== 'sha512') {
     throw new Error('Only sha512 is supported in this PBKDF2 implementation')
   }
-  // Attempt to use the native Node.js implementation if available as it is
-  // considerably faster than the pure TypeScript fallback below. If the crypto
-  // module isn't present (for example in a browser build) we'll silently fall
-  // back to the original implementation.
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const nodeCrypto = require('node:crypto')
-    if (typeof nodeCrypto.pbkdf2Sync === 'function') {
-      const p = Buffer.from(password)
-      const s = Buffer.from(salt)
-      return [...nodeCrypto.pbkdf2Sync(p, s, iterations, keylen, digest)]
-    }
-  } catch {
-    // ignore
+  const pbkdf2Sync = NODE_CRYPTO?.pbkdf2Sync
+  if (typeof pbkdf2Sync === 'function') {
+    const out = pbkdf2Sync(
+      toHashBytes(password),
+      toHashBytes(salt),
+      iterations,
+      keylen,
+      digest
+    )
+    return Array.from(out)
   }
   const p = Uint8Array.from(password)
   const s = Uint8Array.from(salt)

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,