Fixing bugs

Author: Stephen-Thomson

src/primitives/Hash.ts

@@ -1,6 +1,8 @@
 
 // @ts-nocheck
 /* eslint-disable @typescript-eslint/naming-convention */
+import { assertValidHex, normalizeHex } from './hex.js'
+
 const assert = (
   expression: unknown,
   message: string = 'Hash assertion failed'
@@ -168,42 +170,48 @@ abstract class BaseHash {
    * @returns Returns an array denoting the padding.
    */
   private _pad (): number[] {
-    const len = this.pendingTotal
+    //
+    let len = this.pendingTotal
     const bytes = this._delta8
     const k = bytes - ((len + this.padLength) % bytes)
     const res = new Array(k + this.padLength)
     res[0] = 0x80
-    let i: number
+    let i
     for (i = 1; i < k; i++) {
       res[i] = 0
     }
 
     // Append length
-    const lengthBytes = this.padLength
-    const maxBits = 1n << BigInt(lengthBytes * 8)
-    let totalBits = BigInt(len) * 8n
-
-    if (totalBits >= maxBits) {
-      throw new Error('Message too long for this hash function')
-    }
-
+    len <<= 3
+    let t
     if (this.endian === 'big') {
-      const lenArray = new Array<number>(lengthBytes)
-
-      for (let b = lengthBytes - 1; b >= 0; b--) {
-        lenArray[b] = Number(totalBits & 0xffn)
-        totalBits >>= 8n
+      for (t = 8; t < this.padLength; t++) {
+        res[i++] = 0
       }
 
-      for (let b = 0; b < lengthBytes; b++) {
-        res[i++] = lenArray[b]
-      }
+      res[i++] = 0
+      res[i++] = 0
+      res[i++] = 0
+      res[i++] = 0
+      res[i++] = (len >>> 24) & 0xff
+      res[i++] = (len >>> 16) & 0xff
+      res[i++] = (len >>> 8) & 0xff
+      res[i++] = len & 0xff
     } else {
-      for (let b = 0; b < lengthBytes; b++) {
-        res[i++] = Number(totalBits & 0xffn)
-        totalBits >>= 8n
+      res[i++] = len & 0xff
+      res[i++] = (len >>> 8) & 0xff
+      res[i++] = (len >>> 16) & 0xff
+      res[i++] = (len >>> 24) & 0xff
+      res[i++] = 0
+      res[i++] = 0
+      res[i++] = 0
+      res[i++] = 0
+
+      for (t = 8; t < this.padLength; t++) {
+        res[i++] = 0
       }
     }
+
     return res
   }
 }
@@ -262,10 +270,8 @@ export function toArray (
         }
       }
     } else {
-      msg = msg.replace(/[^a-z0-9]+/gi, '')
-      if (msg.length % 2 !== 0) {
-        msg = '0' + msg
-      }
+      assertValidHex(msg)
+      msg = normalizeHex(msg)
       for (let i = 0; i < msg.length; i += 2) {
         res.push(parseInt(msg[i] + msg[i + 1], 16))
       }

src/primitives/__tests/hex.test.ts

@@ -0,0 +1,51 @@
+/* eslint-env jest */
+
+import { assertValidHex, normalizeHex } from '../../primitives/hex'
+
+describe('hex utils', () => {
+  describe('assertValidHex', () => {
+    it('should not throw on valid hex strings', () => {
+      expect(() => assertValidHex('00')).not.toThrow()
+      expect(() => assertValidHex('abcdef')).not.toThrow()
+      expect(() => assertValidHex('ABCDEF')).not.toThrow()
+      expect(() => assertValidHex('1234567890')).not.toThrow()
+    })
+
+    it('should throw on non-hex characters', () => {
+      expect(() => assertValidHex('zz')).toThrow('Invalid hex string')
+      expect(() => assertValidHex('0x1234')).toThrow('Invalid hex string')
+      expect(() => assertValidHex('12 34')).toThrow('Invalid hex string')
+      expect(() => assertValidHex('g1')).toThrow('Invalid hex string')
+    })
+
+    it('should throw on empty string', () => {
+      expect(() => assertValidHex('')).toThrow('Invalid hex string')
+    })
+
+    it('should throw on undefined or null', () => {
+      expect(() => assertValidHex(undefined as any)).toThrow()
+      expect(() => assertValidHex(null as any)).toThrow()
+    })
+  })
+
+  describe('normalizeHex', () => {
+    it('should return lowercase hex', () => {
+      expect(normalizeHex('ABCD')).toBe('abcd')
+    })
+
+    it('should prepend 0 to odd-length hex strings', () => {
+      expect(normalizeHex('abc')).toBe('0abc')
+      expect(normalizeHex('f')).toBe('0f')
+    })
+
+    it('should leave even-length hex strings untouched (except lowercase)', () => {
+      expect(normalizeHex('AABB')).toBe('aabb')
+      expect(normalizeHex('001122')).toBe('001122')
+    })
+
+    it('should throw on invalid hex', () => {
+      expect(() => normalizeHex('xyz')).toThrow('Invalid hex string')
+      expect(() => normalizeHex('12 34')).toThrow('Invalid hex string')
+    })
+  })
+})

src/primitives/hex.ts

@@ -1,23 +1,33 @@
 // src/primitives/hex.ts
 
-const PURE_HEX_REGEX = /^[0-9a-fA-F]+$/
+// Accepts empty string because empty byte arrays are valid in Bitcoin.
+const PURE_HEX_REGEX = /^[0-9a-fA-F]*$/;
 
-export function assertValidHex (msg: string): void {
-  if (typeof msg !== 'string' || msg.length === 0 || !PURE_HEX_REGEX.test(msg)) {
-    throw new Error('Invalid hex string')
+export function assertValidHex(msg: string): void {
+  if (typeof msg !== 'string') {
+    throw new Error('Invalid hex string');
+  }
+
+  // Allow empty strings (valid empty byte arrays)
+  if (msg.length === 0) return;
+
+  if (!PURE_HEX_REGEX.test(msg)) {
+    throw new Error('Invalid hex string');
   }
 }
 
-export function normalizeHex (msg: string): string {
-  assertValidHex(msg)
+export function normalizeHex(msg: string): string {
+  assertValidHex(msg);
+
+  // If empty, return empty — never force to "00"
+  if (msg.length === 0) return '';
 
-  // Lowercase first
-  let normalized = msg.toLowerCase()
+  let normalized = msg.toLowerCase();
 
-  // Prepend "0" if odd-length
-  if (normalized.length % 2 === 1) {
-    normalized = '0' + normalized
+  // Pad odd-length hex
+  if (normalized.length % 2 !== 0) {
+    normalized = '0' + normalized;
   }
 
-  return normalized
+  return normalized;
 }

src/primitives/utils.ts

@@ -1,5 +1,6 @@
 import BigNumber from './BigNumber.js'
 import { hash256 } from './Hash.js'
+import { assertValidHex, normalizeHex } from './hex.js'
 
 const BufferCtor =
   typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
@@ -80,28 +81,19 @@ for (let i = 0; i < 6; i++) {
 }
 
 const hexToArray = (msg: string): number[] => {
-  if (CAN_USE_BUFFER && PURE_HEX_REGEX.test(msg)) {
-    const normalized = msg.length % 2 === 0 ? msg : '0' + msg
+  assertValidHex(msg)
+  const normalized = msg.length % 2 === 0 ? msg : '0' + msg
+  if (CAN_USE_BUFFER) {
     return Array.from(BufferCtor.from(normalized, 'hex'))
   }
-  const res: number[] = new Array(Math.ceil(msg.length / 2))
-  let nibble = -1
-  let size = 0
-  for (let i = 0; i < msg.length; i++) {
-    const value = HEX_CHAR_TO_VALUE[msg.charCodeAt(i)]
-    if (value === -1) continue
-    if (nibble === -1) {
-      nibble = value
-    } else {
-      res[size++] = (nibble << 4) | value
-      nibble = -1
-    }
-  }
-  if (nibble !== -1) {
-    res[size++] = nibble
+  const out = new Array(normalized.length / 2)
+  let o = 0
+  for (let i = 0; i < normalized.length; i += 2) {
+    const hi = HEX_CHAR_TO_VALUE[normalized.charCodeAt(i)]
+    const lo = HEX_CHAR_TO_VALUE[normalized.charCodeAt(i + 1)]
+    out[o++] = (hi << 4) | lo
   }
-  if (size !== res.length) res.length = size
-  return res
+  return out
 }
 
 export function base64ToArray (msg: string): number[] {
@@ -237,6 +229,7 @@ export const toUTF8 = (arr: number[]): string => {
 
   for (let i = 0; i < arr.length; i++) {
     const byte = arr[i]
+
     // this byte is part of a multi-byte sequence, skip it
     // added to avoid modifying i within the loop which is considered unsafe.
     if (skip > 0) {
@@ -247,41 +240,26 @@ export const toUTF8 = (arr: number[]): string => {
     // 1-byte sequence (0xxxxxxx)
     if (byte <= 0x7f) {
       result += String.fromCharCode(byte)
-      continue
-    }
-
-    // 2-byte sequence (110xxxxx 10xxxxxx)
-    if (byte >= 0xc0 && byte <= 0xdf) {
-      const avail = arr.length - (i + 1)
-      const byte2 = avail >= 1 ? arr[i + 1] : 0
-      skip = Math.min(1, avail)
-
+    } else if (byte >= 0xc0 && byte <= 0xdf) {
+      // 2-byte sequence (110xxxxx 10xxxxxx)
+      const byte2 = arr[i + 1]
+      skip = 1
       const codePoint = ((byte & 0x1f) << 6) | (byte2 & 0x3f)
       result += String.fromCharCode(codePoint)
-      continue
-    }
-
-    // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
-    if (byte >= 0xe0 && byte <= 0xef) {
-      const avail = arr.length - (i + 1)
-      const byte2 = avail >= 1 ? arr[i + 1] : 0
-      const byte3 = avail >= 2 ? arr[i + 2] : 0
-      skip = Math.min(2, avail)
-
+    } else if (byte >= 0xe0 && byte <= 0xef) {
+      // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      skip = 2
       const codePoint =
         ((byte & 0x0f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
       result += String.fromCharCode(codePoint)
-      continue
-    }
-
-    // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
-    if (byte >= 0xf0 && byte <= 0xf7) {
-      const avail = arr.length - (i + 1)
-      const byte2 = avail >= 1 ? arr[i + 1] : 0
-      const byte3 = avail >= 2 ? arr[i + 2] : 0
-      const byte4 = avail >= 3 ? arr[i + 3] : 0
-      skip = Math.min(3, avail)
-
+    } else if (byte >= 0xf0 && byte <= 0xf7) {
+      // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      const byte4 = arr[i + 3]
+      skip = 3
       const codePoint =
         ((byte & 0x07) << 18) |
         ((byte2 & 0x3f) << 12) |
@@ -292,7 +270,6 @@ export const toUTF8 = (arr: number[]): string => {
       const surrogate1 = 0xd800 + ((codePoint - 0x10000) >> 10)
       const surrogate2 = 0xdc00 + ((codePoint - 0x10000) & 0x3ff)
       result += String.fromCharCode(surrogate1, surrogate2)
-      continue
     }
   }