@bsv/sdk 1.8.13 → 1.9.1

package/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
   }
 
   /**

package/src/primitives/Hash.ts

@@ -613,8 +613,12 @@ export class SHA256 {
     this.h = new FastSHA256()
   }
 
-  update (msg: number[] | string, enc?: 'hex' | 'utf8'): this {
-    const data = Uint8Array.from(toArray(msg, enc))
+  update (
+    msg: Uint8Array | number[] | string,
+    enc?: 'hex' | 'utf8'
+  ): this {
+    const data =
+      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
     this.h.update(data)
     return this
   }
@@ -778,8 +782,16 @@ export class SHA256HMAC {
    * @example
    * const myHMAC = new SHA256HMAC('deadbeef');
    */
-  constructor (key: number[] | string) {
-    const k = Uint8Array.from(toArray(key, 'hex'))
+  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)
   }
 
@@ -794,8 +806,10 @@ export class SHA256HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update (msg: number[] | string, enc?: 'hex'): SHA256HMAC {
-    this.h.update(Uint8Array.from(toArray(msg, enc)))
+  update (msg: Uint8Array | number[] | string, enc?: 'hex'): SHA256HMAC {
+    const data =
+      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
+    this.h.update(data)
     return this
   }
 
@@ -902,8 +916,16 @@ export class SHA512HMAC {
    * @example
    * const myHMAC = new SHA512HMAC('deadbeef');
    */
-  constructor (key: number[] | string) {
-    const k = Uint8Array.from(toArray(key, 'hex'))
+  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)
   }
 
@@ -918,8 +940,10 @@ export class SHA512HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update (msg: number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC {
-    this.h.update(Uint8Array.from(toArray(msg, enc)))
+  update (msg: Uint8Array | number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC {
+    const data =
+      msg instanceof Uint8Array ? msg : Uint8Array.from(toArray(msg, enc))
+    this.h.update(data)
     return this
   }
 
@@ -998,7 +1022,7 @@ export const sha1 = (
  * const digest = sha256('Hello, world!');
  */
 export const sha256 = (
-  msg: number[] | string,
+  msg: Uint8Array | number[] | string,
   enc?: 'hex' | 'utf8'
 ): number[] => {
   return new SHA256().update(msg, enc).digest()
@@ -1036,7 +1060,7 @@ export const sha512 = (
  * const doubleHash = hash256('Hello, world!');
  */
 export const hash256 = (
-  msg: number[] | string,
+  msg: Uint8Array | number[] | string,
   enc?: 'hex' | 'utf8'
 ): number[] => {
   const first = new SHA256().update(msg, enc).digest()
@@ -1056,7 +1080,7 @@ export const hash256 = (
  * const hash = hash160('Hello, world!');
  */
 export const hash160 = (
-  msg: number[] | string,
+  msg: Uint8Array | number[] | string,
   enc?: 'hex' | 'utf8'
 ): number[] => {
   const first = new SHA256().update(msg, enc).digest()
@@ -1076,8 +1100,8 @@ export const hash160 = (
  * const digest = sha256hmac('deadbeef', 'ffff001d');
  */
 export const sha256hmac = (
-  key: number[] | string,
-  msg: number[] | string,
+  key: Uint8Array | number[] | string,
+  msg: Uint8Array | number[] | string,
   enc?: 'hex'
 ): number[] => {
   return new SHA256HMAC(key).update(msg, enc).digest()
@@ -1096,8 +1120,8 @@ export const sha256hmac = (
  * const digest = sha512hmac('deadbeef', 'ffff001d');
  */
 export const sha512hmac = (
-  key: number[] | string,
-  msg: number[] | string,
+  key: Uint8Array | number[] | string,
+  msg: Uint8Array | number[] | string,
   enc?: 'hex'
 ): number[] => {
   return new SHA512HMAC(key).update(msg, enc).digest()

package/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!')

package/src/primitives/TransactionSignature.ts

@@ -6,6 +6,30 @@ import Script from '../script/Script.js'
 import TransactionInput from '../transaction/TransactionInput.js'
 import TransactionOutput from '../transaction/TransactionOutput.js'
 
+export interface SignatureHashCache {
+  hashPrevouts?: number[]
+  hashSequence?: number[]
+  hashOutputsAll?: number[]
+  hashOutputsSingle?: Map<number, number[]>
+}
+
+interface TransactionSignatureFormatParams {
+  sourceTXID: string
+  sourceOutputIndex: number
+  sourceSatoshis: number
+  transactionVersion: number
+  otherInputs: TransactionInput[]
+  outputs: TransactionOutput[]
+  inputIndex: number
+  subscript: Script
+  inputSequence: number
+  lockTime: number
+  scope: number
+  cache?: SignatureHashCache
+}
+
+const EMPTY_SCRIPT = new Uint8Array(0)
+
 export default class TransactionSignature extends Signature {
   public static readonly SIGHASH_ALL = 0x00000001
   public static readonly SIGHASH_NONE = 0x00000002
@@ -15,19 +39,23 @@ export default class TransactionSignature extends Signature {
 
   scope: number
 
-  static format (params: {
-    sourceTXID: string
-    sourceOutputIndex: number
-    sourceSatoshis: number
-    transactionVersion: number
-    otherInputs: TransactionInput[]
-    outputs: TransactionOutput[]
-    inputIndex: number
-    subscript: Script
-    inputSequence: number
-    lockTime: number
-    scope: number
-  }): number[] {
+  /**
+   * Formats the SIGHASH preimage for the targeted input, optionally using a cache to skip recomputing shared hash prefixes.
+   * @param params - Context for the signing input plus transaction metadata.
+   * @param params.cache - Optional cache storing previously computed `hashPrevouts`, `hashSequence`, or `hashOutputs*` values; it will be populated if present.
+   */
+  static format (params: TransactionSignatureFormatParams): number[] {
+    return Array.from(this.formatBytes(params))
+  }
+
+  /**
+   * Formats the same SIGHASH preimage bytes as `format`, supporting the optional cache for hash reuse.
+   * @param params - Context for the signing operation.
+   * @param params.cache - Optional `SignatureHashCache` that may already contain hashed prefixes and is populated during formatting.
+   * @returns Bytes for signing.
+   */
+  static formatBytes (params: TransactionSignatureFormatParams): Uint8Array {
+    const cache = params.cache
     const currentInput = {
       sourceTXID: params.sourceTXID,
       sourceOutputIndex: params.sourceOutputIndex,
@@ -51,9 +79,7 @@ export default class TransactionSignature extends Signature {
         writer.writeUInt32LE(input.sourceOutputIndex)
       }
 
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf)
-      return ret
+      return Hash.hash256(writer.toUint8Array())
     }
 
     const getSequenceHash = (): number[] => {
@@ -64,9 +90,7 @@ export default class TransactionSignature extends Signature {
         writer.writeUInt32LE(sequence)
       }
 
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf)
-      return ret
+      return Hash.hash256(writer.toUint8Array())
     }
 
     function getOutputsHash (outputIndex?: number): number[] {
@@ -77,7 +101,7 @@ export default class TransactionSignature extends Signature {
           const satoshis = output.satoshis ?? 0 // Default to 0 if undefined
           writer.writeUInt64LE(satoshis)
 
-          const script = output.lockingScript?.toBinary() ?? []
+          const script = output.lockingScript?.toUint8Array() ?? EMPTY_SCRIPT
           writer.writeVarIntNum(script.length)
           writer.write(script)
         }
@@ -91,14 +115,12 @@ export default class TransactionSignature extends Signature {
         const satoshis = output.satoshis ?? 0 // Default to 0 if undefined
         writer.writeUInt64LE(satoshis)
 
-        const script = output.lockingScript?.toBinary() ?? []
+        const script = output.lockingScript?.toUint8Array() ?? EMPTY_SCRIPT
         writer.writeVarIntNum(script.length)
         writer.write(script)
       }
 
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf)
-      return ret
+      return Hash.hash256(writer.toUint8Array())
     }
 
     let hashPrevouts = new Array(32).fill(0)
@@ -106,7 +128,12 @@ export default class TransactionSignature extends Signature {
     let hashOutputs = new Array(32).fill(0)
 
     if ((params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0) {
-      hashPrevouts = getPrevoutHash()
+      if (cache?.hashPrevouts != null) {
+        hashPrevouts = cache.hashPrevouts
+      } else {
+        hashPrevouts = getPrevoutHash()
+        if (cache != null) cache.hashPrevouts = hashPrevouts
+      }
     }
 
     if (
@@ -114,19 +141,39 @@ export default class TransactionSignature extends Signature {
       (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
       (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
     ) {
-      hashSequence = getSequenceHash()
+      if (cache?.hashSequence != null) {
+        hashSequence = cache.hashSequence
+      } else {
+        hashSequence = getSequenceHash()
+        if (cache != null) cache.hashSequence = hashSequence
+      }
     }
 
     if (
       (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
       (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
     ) {
-      hashOutputs = getOutputsHash()
+      if (cache?.hashOutputsAll != null) {
+        hashOutputs = cache.hashOutputsAll
+      } else {
+        hashOutputs = getOutputsHash()
+        if (cache != null) cache.hashOutputsAll = hashOutputs
+      }
     } else if (
       (params.scope & 31) === TransactionSignature.SIGHASH_SINGLE &&
       params.inputIndex < params.outputs.length
     ) {
-      hashOutputs = getOutputsHash(params.inputIndex)
+      const key = params.inputIndex
+      const cachedSingle = cache?.hashOutputsSingle?.get(key)
+      if (cachedSingle != null) {
+        hashOutputs = cachedSingle
+      } else {
+        hashOutputs = getOutputsHash(key)
+        if (cache != null) {
+          if (cache.hashOutputsSingle == null) cache.hashOutputsSingle = new Map()
+          cache.hashOutputsSingle.set(key, hashOutputs)
+        }
+      }
     }
 
     const writer = new Writer()
@@ -143,7 +190,7 @@ export default class TransactionSignature extends Signature {
     writer.writeUInt32LE(params.sourceOutputIndex)
 
     // scriptCode of the input (serialized as scripts inside CTxOuts)
-    const subscriptBin = params.subscript.toBinary()
+    const subscriptBin = params.subscript.toUint8Array()
     writer.writeVarIntNum(subscriptBin.length)
     writer.write(subscriptBin)
 
@@ -163,8 +210,7 @@ export default class TransactionSignature extends Signature {
     // sighashType
     writer.writeUInt32LE(params.scope >>> 0)
 
-    const buf = writer.toArray()
-    return buf
+    return writer.toUint8Array()
   }
 
   // The format used in a tx

package/src/primitives/utils.ts

@@ -1,6 +1,12 @@
 import BigNumber from './BigNumber.js'
 import { hash256 } from './Hash.js'
 
+const BufferCtor =
+  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
+const CAN_USE_BUFFER =
+  BufferCtor != null && typeof BufferCtor.from === 'function'
+const PURE_HEX_REGEX = /^[0-9a-fA-F]+$/
+
 /**
  * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
  * @param {string} word - The input word.
@@ -19,12 +25,23 @@ export const zero2 = (word: string): string => {
  * @param {number[]} msg - The input array of numbers.
  * @returns {string} - The hexadecimal string representation of the input array.
  */
+const HEX_DIGITS = '0123456789abcdef'
+const HEX_BYTE_STRINGS: string[] = new Array(256)
+for (let i = 0; i < 256; i++) {
+  HEX_BYTE_STRINGS[i] =
+    HEX_DIGITS[(i >> 4) & 0xf] + HEX_DIGITS[i & 0xf]
+}
+
 export const toHex = (msg: number[]): string => {
-  let res = ''
-  for (const num of msg) {
-    res += zero2(num.toString(16))
+  if (CAN_USE_BUFFER) {
+    return BufferCtor.from(msg).toString('hex')
   }
-  return res
+  if (msg.length === 0) return ''
+  const out = new Array(msg.length)
+  for (let i = 0; i < msg.length; i++) {
+    out[i] = HEX_BYTE_STRINGS[msg[i] & 0xff]
+  }
+  return out.join('')
 }
 
 /**
@@ -53,13 +70,37 @@ export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
   }
 }
 
+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'
+}
+
 const hexToArray = (msg: string): number[] => {
-  msg = msg.replace(/[^a-z0-9]+/gi, '')
-  if (msg.length % 2 !== 0) msg = '0' + msg
-  const res: number[] = []
-  for (let i = 0; i < msg.length; i += 2) {
-    res.push(parseInt(msg[i] + msg[i + 1], 16))
+  if (CAN_USE_BUFFER && PURE_HEX_REGEX.test(msg)) {
+    const normalized = msg.length % 2 === 0 ? msg : '0' + msg
+    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
+  }
+  if (size !== res.length) res.length = size
   return res
 }
 
@@ -377,11 +418,13 @@ export const fromBase58Check = (
   return { prefix, data }
 }
 
+type WriterChunk = readonly number[] | Uint8Array
+
 export class Writer {
-  public bufs: number[][]
+  public bufs: WriterChunk[]
   private length: number
 
-  constructor (bufs?: number[][]) {
+  constructor (bufs?: WriterChunk[]) {
     this.bufs = bufs !== undefined ? bufs : []
     this.length = 0
     for (const b of this.bufs) this.length += b.length
@@ -391,19 +434,36 @@ export class Writer {
     return this.length
   }
 
+  toUint8Array (): Uint8Array {
+    const out = new Uint8Array(this.length)
+    let offset = 0
+    for (const buf of this.bufs) {
+      out.set(buf, offset)
+      offset += buf.length
+    }
+    return out
+  }
+
   toArray (): number[] {
     const totalLength = this.length
     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
   }
 
-  write (buf: number[]): this {
+  write (buf: WriterChunk): this {
     this.bufs.push(buf)
     this.length += buf.length
     return this
@@ -414,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
   }
@@ -438,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 {
@@ -452,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 {
@@ -468,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 {
@@ -484,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 {