Faster BN conversions

Author: ty-everett

src/primitives/BigNumber.ts

@@ -1,6 +1,19 @@
 // @ts-nocheck
 import ReductionContext from './ReductionContext.js'
 
+const BufferCtor =
+  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
+const CAN_USE_BUFFER =
+  BufferCtor != null && typeof BufferCtor.from === 'function'
+const HEX_CHAR_TO_VALUE = new Int8Array(256).fill(-1)
+for (let i = 0; i < 10; i++) {
+  HEX_CHAR_TO_VALUE[48 + i] = i // '0'-'9'
+}
+for (let i = 0; i < 6; i++) {
+  HEX_CHAR_TO_VALUE[65 + i] = 10 + i // 'A'-'F'
+  HEX_CHAR_TO_VALUE[97 + i] = 10 + i // 'a'-'f'
+}
+
 /**
  * JavaScript numbers are only precise up to 53 bits. Since Bitcoin relies on
  * 256-bit cryptography, this BigNumber class enables operations on larger
@@ -1059,31 +1072,30 @@ export default class BigNumber {
   static fromSm (bytes: number[], endian: 'big' | 'little' = 'big'): BigNumber {
     if (bytes.length === 0) return new BigNumber(0n)
 
+    const beBytes = bytes.slice()
+    if (endian === 'little') {
+      beBytes.reverse()
+    }
     let sign: 0 | 1 = 0
-    let hex = ''
+    if (beBytes.length > 0 && (beBytes[0] & 0x80) !== 0) {
+      sign = 1
+      beBytes[0] &= 0x7f
+    }
 
-    if (endian === 'little') {
-      const last = bytes.length - 1
-      let firstByte = bytes[last]
-      if ((firstByte & 0x80) !== 0) { sign = 1; firstByte &= 0x7f }
-      hex += (firstByte < 16 ? '0' : '') + firstByte.toString(16)
-      for (let i = last - 1; i >= 0; i--) {
-        const b = bytes[i]
-        hex += (b < 16 ? '0' : '') + b.toString(16)
-      }
+    let magnitude = 0n
+    if (CAN_USE_BUFFER) {
+      const hex = BufferCtor.from(beBytes).toString('hex') as string
+      magnitude = hex.length === 0 ? 0n : BigInt('0x' + hex)
     } else {
-      let firstByte = bytes[0]
-      if ((firstByte & 0x80) !== 0) { sign = 1; firstByte &= 0x7f }
-      hex += (firstByte < 16 ? '0' : '') + firstByte.toString(16)
-      for (let i = 1; i < bytes.length; i++) {
-        const b = bytes[i]
-        hex += (b < 16 ? '0' : '') + b.toString(16)
+      let hex = ''
+      for (const byte of beBytes) {
+        hex += byte < 16 ? '0' + byte.toString(16) : byte.toString(16)
       }
+      magnitude = hex.length === 0 ? 0n : BigInt('0x' + hex)
     }
 
-    const mag = hex === '' ? 0n : BigInt('0x' + hex)
     const r = new BigNumber(0n)
-    r._initializeState(mag, sign)
+    r._initializeState(magnitude, sign)
     return r
   }
 
@@ -1105,17 +1117,26 @@ export default class BigNumber {
     const byteLen = hex.length / 2
     const bytes = new Array(byteLen)
     for (let i = 0, j = 0; i < hex.length; i += 2) {
-      bytes[j++] = parseInt(hex.slice(i, i + 2), 16)
+      const high = HEX_CHAR_TO_VALUE[hex.charCodeAt(i)]
+      const low = HEX_CHAR_TO_VALUE[hex.charCodeAt(i + 1)]
+      bytes[j++] = ((high & 0xf) << 4) | (low & 0xf)
     }
 
+    let result: number[]
     if (this._sign === 1) {
-      if ((bytes[0] & 0x80) !== 0) bytes.unshift(0x80)
-      else bytes[0] |= 0x80
+      if ((bytes[0] & 0x80) !== 0) {
+        result = [0x80, ...bytes]
+      } else {
+        result = bytes.slice()
+        result[0] |= 0x80
+      }
     } else if ((bytes[0] & 0x80) !== 0) {
-      bytes.unshift(0x00)
+      result = [0x00, ...bytes]
+    } else {
+      result = bytes.slice()
     }
 
-    return endian === 'little' ? bytes.reverse() : bytes
+    return endian === 'little' ? result.reverse() : result
   }
 
   /**

src/primitives/SymmetricKey.ts

@@ -43,13 +43,22 @@ export default class SymmetricKey extends BigNumber {
   encrypt (msg: number[] | string, enc?: 'hex'): string | number[] {
     const iv = Random(32)
     msg = toArray(msg, enc)
+    const keyBytes = this.toArray('be', 32)
     const { result, authenticationTag } = AESGCM(
       msg,
       [],
       iv,
-      this.toArray('be', 32)
+      keyBytes
     )
-    return encode([...iv, ...result, ...authenticationTag], enc)
+    const totalLength = iv.length + result.length + authenticationTag.length
+    const combined = new Array(totalLength)
+    let offset = 0
+    for (const chunk of [iv, result, authenticationTag]) {
+      for (let i = 0; i < chunk.length; i++) {
+        combined[offset++] = chunk[i]
+      }
+    }
+    return encode(combined, enc)
   }
 
   /**
@@ -71,15 +80,15 @@ export default class SymmetricKey extends BigNumber {
   decrypt (msg: number[] | string, enc?: 'hex' | 'utf8'): string | number[] {
     msg = toArray(msg, enc)
     const iv = msg.slice(0, 32)
-    const ciphertextWithTag = msg.slice(32)
-    const messageTag = ciphertextWithTag.slice(-16)
-    const ciphertext = ciphertextWithTag.slice(0, -16)
+    const tagStart = msg.length - 16
+    const ciphertext = msg.slice(32, tagStart)
+    const messageTag = msg.slice(tagStart)
     const result = AESGCMDecrypt(
       ciphertext,
       [],
       iv,
       messageTag,
-      this.toArray()
+      this.toArray('be', 32)
     )
     if (result === null) {
       throw new Error('Decryption failed!')

src/primitives/utils.ts

@@ -449,8 +449,15 @@ export class Writer {
     const ret = new Array(totalLength)
     let offset = 0
     for (const buf of this.bufs) {
-      for (const value of buf) {
-        ret[offset++] = value
+      if (buf instanceof Uint8Array) {
+        for (let i = 0; i < buf.length; i++) {
+          ret[offset++] = buf[i]
+        }
+      } else {
+        const arr = buf as number[]
+        for (let i = 0; i < arr.length; i++) {
+          ret[offset++] = arr[i]
+        }
       }
     }
     return ret
@@ -467,14 +474,12 @@ export class Writer {
     for (let i = 0; i < buf2.length; i++) {
       buf2[i] = buf[buf.length - 1 - i]
     }
-    this.bufs.push(buf2)
-    this.length += buf2.length
-    return this
+    return this.write(buf2)
   }
 
   writeUInt8 (n: number): this {
     const buf = new Array(1)
-    buf[0] = n
+    buf[0] = n & 0xff
     this.write(buf)
     return this
   }
@@ -491,9 +496,7 @@ export class Writer {
       (n >> 8) & 0xff, // shift right 8 bits to get the high byte
       n & 0xff // low byte is just the last 8 bits
     ]
-    this.bufs.push(buf)
-    this.length += 2
-    return this
+    return this.write(buf)
   }
 
   writeInt16BE (n: number): this {
@@ -505,9 +508,7 @@ export class Writer {
       n & 0xff, // low byte is just the last 8 bits
       (n >> 8) & 0xff // shift right 8 bits to get the high byte
     ]
-    this.bufs.push(buf)
-    this.length += 2
-    return this
+    return this.write(buf)
   }
 
   writeInt16LE (n: number): this {
@@ -521,9 +522,7 @@ export class Writer {
       (n >> 8) & 0xff,
       n & 0xff // lowest byte
     ]
-    this.bufs.push(buf)
-    this.length += 4
-    return this
+    return this.write(buf)
   }
 
   writeInt32BE (n: number): this {
@@ -537,9 +536,7 @@ export class Writer {
       (n >> 16) & 0xff,
       (n >> 24) & 0xff // highest byte
     ]
-    this.bufs.push(buf)
-    this.length += 4
-    return this
+    return this.write(buf)
   }
 
   writeInt32LE (n: number): this {

src/transaction/Transaction.ts

@@ -1047,14 +1047,9 @@ export default class Transaction {
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
   toAtomicBEEF (allowPartial?: boolean): number[] {
-    const writer = new Writer()
-    // Write the Atomic BEEF prefix
-    writer.writeUInt32LE(0x01010101)
-    // Write the subject TXID (big-endian)
-    writer.write(this.hash())
-    // Append the BEEF data
+    const prefix = [1, 1, 1, 1]
+    const txHash = this.hash() as number[]
     const beefData = this.toBEEF(allowPartial)
-    writer.write(beefData)
-    return writer.toArray()
+    return prefix.concat(txHash, beefData)
   }
 }