@bsv/sdk 2.1.1 → 2.1.3

package/dist/esm/src/primitives/Hash.js

@@ -308,11 +308,115 @@ function zero8(word) {
         return word;
     }
 }
+const BufferCtor = typeof globalThis === 'undefined' ? undefined : globalThis.Buffer;
+const CAN_USE_BUFFER = BufferCtor != null && typeof BufferCtor.from === 'function';
+const HEX_DIGITS = '0123456789abcdef';
+const HEX_BYTE_STRINGS = new Array(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) {
-    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(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.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;
+})();
+function toHashBytes(msg, enc) {
+    if (msg instanceof Uint8Array) {
+        return msg;
+    }
+    if (Array.isArray(msg)) {
+        return new Uint8Array(msg);
+    }
+    return Uint8Array.from(toArray(msg, enc));
+}
+function toHashKeyBytes(key) {
+    return typeof key === 'string' ? toHashBytes(key, 'hex') : toHashBytes(key);
+}
+function updateNativeOrFallback(native, fallback, data) {
+    if (native != null) {
+        native.update(data);
+    }
+    else if (fallback != null) {
+        fallback.update(data);
+    }
+}
+function digestNativeOrFallback(native, fallback) {
+    if (native != null)
+        return Array.from(native.digest());
+    if (fallback != null)
+        return Array.from(fallback.digest());
+    return [];
+}
+function digestHexNativeOrFallback(native, fallback) {
+    if (native != null)
+        return native.digest('hex');
+    if (fallback != null)
+        return bytesToHex(fallback.digest());
+    return '';
+}
+function createNodeHash(algorithm) {
+    const createHash = NODE_CRYPTO?.createHash;
+    if (typeof createHash !== 'function')
+        return undefined;
+    try {
+        return createHash(algorithm);
+    }
+    catch {
+        return undefined;
+    }
+}
+function createNodeHmac(algorithm, keyBytes) {
+    const createHmac = NODE_CRYPTO?.createHmac;
+    if (typeof createHmac !== 'function')
+        return undefined;
+    try {
+        return createHmac(algorithm, keyBytes);
+    }
+    catch {
+        return undefined;
+    }
+}
+function digestWithNodeHash(algorithm, msg, enc) {
+    const hash = createNodeHash(algorithm);
+    if (hash == null)
+        return undefined;
+    hash.update(toHashBytes(msg, enc));
+    return hash.digest();
+}
+function digestWithNodeHmac(algorithm, key, msg, enc) {
+    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) {
     const len = end - start;
@@ -561,19 +665,22 @@ export class RIPEMD160 extends BaseHash {
  */
 export class SHA256 {
     h;
+    native;
     constructor() {
-        this.h = new FastSHA256();
+        this.native = createNodeHash('sha256');
+        if (this.native == null) {
+            this.h = new FastSHA256();
+        }
     }
     update(msg, enc) {
-        const data = msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc));
-        this.h.update(data);
+        updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc));
         return this;
     }
     digest() {
-        return Array.from(this.h.digest());
+        return digestNativeOrFallback(this.native, this.h);
     }
     digestHex() {
-        return bytesToHex(this.h.digest());
+        return digestHexNativeOrFallback(this.native, this.h);
     }
 }
 /**
@@ -666,19 +773,22 @@ export class SHA1 extends BaseHash {
  */
 export class SHA512 {
     h;
+    native;
     constructor() {
-        this.h = new FastSHA512();
+        this.native = createNodeHash('sha512');
+        if (this.native == null) {
+            this.h = new FastSHA512();
+        }
     }
     update(msg, enc) {
-        const data = Uint8Array.from(toArray(msg, enc));
-        this.h.update(data);
+        updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc));
         return this;
     }
     digest() {
-        return Array.from(this.h.digest());
+        return digestNativeOrFallback(this.native, this.h);
     }
     digestHex() {
-        return bytesToHex(this.h.digest());
+        return digestHexNativeOrFallback(this.native, this.h);
     }
 }
 /**
@@ -695,6 +805,7 @@ export class SHA512 {
  */
 export class SHA256HMAC {
     h;
+    native;
     blockSize = 64;
     outSize = 32;
     /**
@@ -711,10 +822,11 @@ export class SHA256HMAC {
      * const myHMAC = new SHA256HMAC('deadbeef');
      */
     constructor(key) {
-        const k = key instanceof Uint8Array
-            ? key
-            : Uint8Array.from(toArray(key, typeof key === 'string' ? 'hex' : undefined));
-        this.h = new HMAC(sha256Fast, k);
+        const k = toHashKeyBytes(key);
+        this.native = createNodeHmac('sha256', k);
+        if (this.native == null) {
+            this.h = new HMAC(sha256Fast, k);
+        }
     }
     /**
      * Updates the `SHA256HMAC` object with part of the message to be hashed.
@@ -728,8 +840,7 @@ export class SHA256HMAC {
      * myHMAC.update('deadbeef', 'hex');
      */
     update(msg, enc) {
-        const data = msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc));
-        this.h.update(data);
+        updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc));
         return this;
     }
     /**
@@ -742,7 +853,7 @@ export class SHA256HMAC {
      * let hashedMessage = myHMAC.digest();
      */
     digest() {
-        return Array.from(this.h.digest());
+        return digestNativeOrFallback(this.native, this.h);
     }
     /**
      * Finalizes the HMAC computation and returns the resultant hash as a hex string.
@@ -754,7 +865,7 @@ export class SHA256HMAC {
      * let hashedMessage = myHMAC.digestHex();
      */
     digestHex() {
-        return bytesToHex(this.h.digest());
+        return digestHexNativeOrFallback(this.native, this.h);
     }
 }
 export class SHA1HMAC {
@@ -809,6 +920,7 @@ export class SHA1HMAC {
  */
 export class SHA512HMAC {
     h;
+    native;
     blockSize = 128;
     outSize = 32;
     /**
@@ -825,10 +937,11 @@ export class SHA512HMAC {
      * const myHMAC = new SHA512HMAC('deadbeef');
      */
     constructor(key) {
-        const k = key instanceof Uint8Array
-            ? key
-            : Uint8Array.from(toArray(key, typeof key === 'string' ? 'hex' : undefined));
-        this.h = new HMAC(sha512Fast, k);
+        const k = toHashKeyBytes(key);
+        this.native = createNodeHmac('sha512', k);
+        if (this.native == null) {
+            this.h = new HMAC(sha512Fast, k);
+        }
     }
     /**
      * Updates the `SHA512HMAC` object with part of the message to be hashed.
@@ -842,8 +955,7 @@ export class SHA512HMAC {
      * myHMAC.update('deadbeef', 'hex');
      */
     update(msg, enc) {
-        const data = msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc));
-        this.h.update(data);
+        updateNativeOrFallback(this.native, this.h, toHashBytes(msg, enc));
         return this;
     }
     /**
@@ -856,7 +968,7 @@ export class SHA512HMAC {
      * let hashedMessage = myHMAC.digest();
      */
     digest() {
-        return Array.from(this.h.digest());
+        return digestNativeOrFallback(this.native, this.h);
     }
     /**
      * Finalizes the HMAC computation and returns the resultant hash as a hex string.
@@ -868,9 +980,24 @@ export class SHA512HMAC {
      * let hashedMessage = myHMAC.digestHex();
      */
     digestHex() {
-        return bytesToHex(this.h.digest());
+        return digestHexNativeOrFallback(this.native, this.h);
     }
 }
+function sha256Bytes(msg, enc) {
+    const native = digestWithNodeHash('sha256', msg, enc);
+    if (native != null)
+        return native;
+    return new FastSHA256().update(toHashBytes(msg, enc)).digest();
+}
+function sha512Bytes(msg, enc) {
+    const native = digestWithNodeHash('sha512', msg, enc);
+    if (native != null)
+        return native;
+    return new FastSHA512().update(toHashBytes(msg, enc)).digest();
+}
+function ripemd160Bytes(msg, enc) {
+    return digestWithNodeHash('ripemd160', msg, enc);
+}
 /**
  * Computes RIPEMD160 hash of a given message.
  * @function ripemd160
@@ -883,6 +1010,9 @@ export class SHA512HMAC {
  * const digest = ripemd160('Hello, world!');
  */
 export const ripemd160 = (msg, enc) => {
+    const native = ripemd160Bytes(msg, enc);
+    if (native != null)
+        return Array.from(native);
     return new RIPEMD160().update(msg, enc).digest();
 };
 /**
@@ -911,7 +1041,7 @@ export const sha1 = (msg, enc) => {
  * const digest = sha256('Hello, world!');
  */
 export const sha256 = (msg, enc) => {
-    return new SHA256().update(msg, enc).digest();
+    return Array.from(sha256Bytes(msg, enc));
 };
 /**
  * Computes SHA512 hash of a given message.
@@ -925,7 +1055,7 @@ export const sha256 = (msg, enc) => {
  * const digest = sha512('Hello, world!');
  */
 export const sha512 = (msg, enc) => {
-    return new SHA512().update(msg, enc).digest();
+    return Array.from(sha512Bytes(msg, enc));
 };
 /**
  * Performs a 'double hash' using SHA256. This means the data is hashed twice
@@ -941,8 +1071,7 @@ export const sha512 = (msg, enc) => {
  * const doubleHash = hash256('Hello, world!');
  */
 export const hash256 = (msg, enc) => {
-    const first = new SHA256().update(msg, enc).digest();
-    return new SHA256().update(first).digest();
+    return Array.from(sha256Bytes(sha256Bytes(msg, enc)));
 };
 /**
  * Computes SHA256 hash of a given message and then computes a RIPEMD160 hash of the result.
@@ -957,7 +1086,10 @@ export const hash256 = (msg, enc) => {
  * const hash = hash160('Hello, world!');
  */
 export const hash160 = (msg, enc) => {
-    const first = new SHA256().update(msg, enc).digest();
+    const first = sha256Bytes(msg, enc);
+    const native = ripemd160Bytes(first);
+    if (native != null)
+        return Array.from(native);
     return new RIPEMD160().update(first).digest();
 };
 /**
@@ -973,6 +1105,9 @@ export const hash160 = (msg, enc) => {
  * const digest = sha256hmac('deadbeef', 'ffff001d');
  */
 export const sha256hmac = (key, msg, enc) => {
+    const native = digestWithNodeHmac('sha256', key, msg, enc);
+    if (native != null)
+        return Array.from(native);
     return new SHA256HMAC(key).update(msg, enc).digest();
 };
 /**
@@ -988,6 +1123,9 @@ export const sha256hmac = (key, msg, enc) => {
  * const digest = sha512hmac('deadbeef', 'ffff001d');
  */
 export const sha512hmac = (key, msg, enc) => {
+    const native = digestWithNodeHmac('sha512', key, msg, enc);
+    if (native != null)
+        return Array.from(native);
     return new SHA512HMAC(key).update(msg, enc).digest();
 };
 // BEGIN fast-pbkdf2 helpers
@@ -1694,21 +1832,10 @@ export function pbkdf2(password, salt, iterations, keylen, digest = 'sha512') {
     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);