@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/primitives/utils.ts

@@ -0,0 +1,953 @@
+import BigNumber from './BigNumber.js'
+import { hash256 } from './Hash.js'
+import { assertValidHex } from './hex.js'
+
+const BufferCtor =
+  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
+const CAN_USE_BUFFER =
+  BufferCtor != null && typeof BufferCtor.from === 'function'
+
+/**
+ * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
+ * @param {string} word - The input word.
+ * @returns {string} - The word with a leading '0' if it's an odd character length; otherwise, the original word.
+ */
+export const zero2 = (word: string): string => {
+  if (word.length % 2 === 1) {
+    return '0' + word
+  } else {
+    return word
+  }
+}
+
+/**
+ * Converts an array of numbers to a hexadecimal string representation.
+ * @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 => {
+  if (CAN_USE_BUFFER) {
+    return BufferCtor.from(msg).toString('hex')
+  }
+  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('')
+}
+
+/**
+ * Converts various message formats into an array of numbers.
+ * Supports arrays, hexadecimal strings, base64 strings, and UTF-8 strings.
+ *
+ * @param {any} msg - The input message (array or string).
+ * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
+ * @returns {any[]} - Array representation of the input.
+ */
+export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
+  if (Array.isArray(msg)) return msg.slice()
+  if (msg === undefined) return []
+
+  if (typeof msg !== 'string') {
+    return Array.from(msg, (item: any) => item | 0)
+  }
+
+  switch (enc) {
+    case 'hex':
+      return hexToArray(msg)
+    case 'base64':
+      return base64ToArray(msg)
+    default:
+      return utf8ToArray(msg)
+  }
+}
+
+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[] => {
+  assertValidHex(msg)
+  const normalized = msg.length % 2 === 0 ? msg : '0' + msg
+  if (CAN_USE_BUFFER) {
+    return Array.from(BufferCtor.from(normalized, 'hex'))
+  }
+  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
+  }
+  return out
+}
+
+export function base64ToArray (msg: string): number[] {
+  if (typeof msg !== 'string') {
+    throw new TypeError('msg must be a string')
+  }
+
+  // cleanse string
+  let s = msg.trim().replace(/[\r\n\t\f\v ]+/g, '')
+  s = s.replace(/-/g, '+').replace(/_/g, '/')
+
+  // ensure padding is correct
+  const padIndex = s.indexOf('=')
+  if (padIndex !== -1) {
+    const pad = s.slice(padIndex)
+    if (!/^={1,2}$/.test(pad)) {
+      throw new Error('Invalid base64 padding')
+    }
+    if (s.slice(0, padIndex).includes('=')) {
+      throw new Error('Invalid base64 padding')
+    }
+    s = s.slice(0, padIndex)
+  }
+
+  // if (s.length % 4 === 1)
+  // {
+  //   throw new Error("Invalid base64 length")
+  // }
+
+  const result: number[] = []
+  let bitBuffer = 0
+  let bitCount = 0
+
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i)
+    // using ascii map values rather than indexOf
+    let v = -1
+    if (c >= 65 && c <= 90) {
+      v = c - 65 // A-Z
+    } else if (c >= 97 && c <= 122) {
+      v = c - 97 + 26 // a-z
+    } else if (c >= 48 && c <= 57) {
+      v = c - 48 + 52 // 0-9
+    } else if (c === 43) {
+      v = 62 // +
+    } else if (c === 47) {
+      v = 63 // /
+    } else {
+      throw new Error(`Invalid base64 character at index ${i}`)
+    }
+    bitBuffer = (bitBuffer << 6) | v
+    bitCount += 6
+
+    while (bitCount >= 8) {
+      bitCount -= 8
+      result.push((bitBuffer >> bitCount) & 0xff)
+      bitBuffer &= (1 << bitCount) - 1
+    }
+  }
+  // check for valid padding bits
+  // if (bitCount !== 0 && bitBuffer !== 0) {
+  //   throw new Error("Invalid base64: non-zero padding bits")
+  // }
+
+  return result
+}
+
+/**
+ * Encodes a string into an array of bytes representing its UTF-8 encoding.
+ * Any lone surrogates are replaced with the Unicode replacement character (U+FFFD).
+ *
+ * @param str - The string to encode.
+ * @returns An array of numbers, each representing a byte in the UTF-8 encoded string.
+ */
+function utf8ToArray (str: string): number[] {
+  const result: number[] = []
+
+  for (let i = 0; i < str.length; i++) {
+    const cp = str.codePointAt(i)
+    if (cp === undefined) {
+      // Should never be out of range.
+      throw new Error(`Index out of range: ${i}`)
+    }
+    let codePoint = cp
+
+    if (codePoint > 0xFFFF) {
+      // Valid surrogate pair => skip the next code unit because codePointAt
+      // has already combined them into a single code point.
+      i++
+    } else {
+      // Check if codePoint is a lone (unpaired) high surrogate or low surrogate.
+      if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+        // Replace with the replacement character (U+FFFD).
+        codePoint = 0xFFFD
+      }
+    }
+
+    // Encode according to the UTF-8 standard
+    if (codePoint <= 0x7F) {
+      result.push(codePoint)
+    } else if (codePoint <= 0x7FF) {
+      result.push(
+        0xC0 | (codePoint >> 6),
+        0x80 | (codePoint & 0x3F)
+      )
+    } else if (codePoint <= 0xFFFF) {
+      result.push(
+        0xE0 | (codePoint >> 12),
+        0x80 | ((codePoint >> 6) & 0x3F),
+        0x80 | (codePoint & 0x3F)
+      )
+    } else {
+      result.push(
+        0xF0 | (codePoint >> 18),
+        0x80 | ((codePoint >> 12) & 0x3F),
+        0x80 | ((codePoint >> 6) & 0x3F),
+        0x80 | (codePoint & 0x3F)
+      )
+    }
+  }
+
+  return result
+}
+
+/**
+ * Converts an array of numbers to a UTF-8 encoded string.
+ * @param {number[]} arr - The input array of numbers.
+ * @returns {string} - The UTF-8 encoded string.
+ */
+export const toUTF8 = (arr: number[]): string => {
+  let result = ''
+  const replacementChar = '\uFFFD'
+  for (let i = 0; i < arr.length; i++) {
+    const byte1 = arr[i]
+    if (byte1 <= 0x7f) {
+      result += String.fromCharCode(byte1)
+      continue
+    }
+    const emitReplacement = (): void => {
+      result += replacementChar
+    }
+    if (byte1 >= 0xc0 && byte1 <= 0xdf) {
+      if (i + 1 >= arr.length) {
+        emitReplacement()
+        continue
+      }
+      const byte2 = arr[i + 1]
+      if ((byte2 & 0xc0) !== 0x80) {
+        emitReplacement()
+        i += 1
+        continue
+      }
+      const codePoint = ((byte1 & 0x1f) << 6) | (byte2 & 0x3f)
+      result += String.fromCharCode(codePoint)
+      i += 1
+      continue
+    }
+    if (byte1 >= 0xe0 && byte1 <= 0xef) {
+      if (i + 2 >= arr.length) {
+        emitReplacement()
+        continue
+      }
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      if ((byte2 & 0xc0) !== 0x80 || (byte3 & 0xc0) !== 0x80) {
+        emitReplacement()
+        i += 2
+        continue
+      }
+      const codePoint =
+        ((byte1 & 0x0f) << 12) |
+        ((byte2 & 0x3f) << 6) |
+        (byte3 & 0x3f)
+
+      result += String.fromCharCode(codePoint)
+      i += 2
+      continue
+    }
+    if (byte1 >= 0xf0 && byte1 <= 0xf7) {
+      if (i + 3 >= arr.length) {
+        emitReplacement()
+        continue
+      }
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      const byte4 = arr[i + 3]
+      if (
+        (byte2 & 0xc0) !== 0x80 ||
+        (byte3 & 0xc0) !== 0x80 ||
+        (byte4 & 0xc0) !== 0x80
+      ) {
+        emitReplacement()
+        i += 3
+        continue
+      }
+      const codePoint =
+        ((byte1 & 0x07) << 18) |
+        ((byte2 & 0x3f) << 12) |
+        ((byte3 & 0x3f) << 6) |
+        (byte4 & 0x3f)
+      const offset = codePoint - 0x10000
+      const highSurrogate = 0xd800 + (offset >> 10)
+      const lowSurrogate = 0xdc00 + (offset & 0x3ff)
+      result += String.fromCharCode(highSurrogate, lowSurrogate)
+      i += 3
+      continue
+    }
+    emitReplacement()
+  }
+  return result
+}
+
+/**
+ * Encodes an array of numbers into a specified encoding ('hex' or 'utf8'). If no encoding is provided, returns the original array.
+ * @param {number[]} arr - The input array of numbers.
+ * @param {('hex' | 'utf8')} enc - The desired encoding.
+ * @returns {string | number[]} - The encoded message as a string (for 'hex' and 'utf8') or the original array.
+ */
+export const encode = (
+  arr: number[],
+  enc?: 'hex' | 'utf8'
+): string | number[] => {
+  switch (enc) {
+    case 'hex':
+      return toHex(arr)
+    case 'utf8':
+      return toUTF8(arr)
+    // If no encoding is provided, return the original array
+    default:
+      return arr
+  }
+}
+
+/**
+ * Converts an array of bytes (each between 0 and 255) into a base64 encoded string.
+ *
+ * @param {number[]} byteArray - An array of numbers where each number is a byte (0-255).
+ * @returns {string} The base64 encoded string.
+ *
+ * @example
+ * const bytes = [72, 101, 108, 108, 111]; // Represents the string "Hello"
+ * console.log(toBase64(bytes)); // Outputs: SGVsbG8=
+ */
+export function toBase64 (byteArray: number[]): string {
+  const base64Chars =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  let result = ''
+  let i: number
+
+  for (i = 0; i < byteArray.length; i += 3) {
+    const byte1 = byteArray[i]
+    const byte2 = i + 1 < byteArray.length ? byteArray[i + 1] : 0
+    const byte3 = i + 2 < byteArray.length ? byteArray[i + 2] : 0
+
+    const encoded1 = byte1 >> 2
+    const encoded2 = ((byte1 & 0x03) << 4) | (byte2 >> 4)
+    const encoded3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6)
+    const encoded4 = byte3 & 0x3f
+
+    result += base64Chars.charAt(encoded1) + base64Chars.charAt(encoded2)
+    result += i + 1 < byteArray.length ? base64Chars.charAt(encoded3) : '='
+    result += i + 2 < byteArray.length ? base64Chars.charAt(encoded4) : '='
+  }
+
+  return result
+}
+
+const base58chars =
+  '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+/**
+ * Converts a string from base58 to a binary array
+ * @param str - The string representation
+ * @returns The binary representation
+ */
+export const fromBase58 = (str: string): number[] => {
+  if (str === '' || typeof str !== 'string') {
+    throw new Error(`Expected base58 string but got “${str}”`)
+  }
+  const match: string[] | null = str.match(/[IOl0]/gmu)
+
+  if (match !== null) {
+    throw new Error(`Invalid base58 character “${match.join('')}”`)
+  }
+  const lz = str.match(/^1+/gmu)
+  const psz: number = (lz !== null) ? lz[0].length : 0
+  const size = ((str.length - psz) * (Math.log(58) / Math.log(256)) + 1) >>> 0
+
+  const uint8 = new Uint8Array([
+    ...new Uint8Array(psz),
+    ...(
+      str.match(/./gmu) ?? [] // ✅ Safe Fix: If null, use []
+    )
+      .map((i) => base58chars.indexOf(i))
+      .reduce((acc, i) => {
+        acc = acc.map((j) => {
+          const x = j * 58 + i
+          i = x >> 8
+          return x
+        })
+        return acc
+      }, new Uint8Array(size))
+      .reverse()
+      .filter(
+        (
+          (lastValue) => (value) =>
+            // @ts-expect-error
+            (lastValue = lastValue || value)
+        )(false)
+      )
+  ])
+  return [...uint8]
+}
+
+/**
+ * Converts a binary array into a base58 string
+ * @param bin - The binary array to convert to base58
+ * @returns The base58 string representation
+ */
+export const toBase58 = (bin: number[]): string => {
+  const base58Map = Array(256).fill(-1)
+  for (let i = 0; i < base58chars.length; ++i) {
+    base58Map[base58chars.charCodeAt(i)] = i
+  }
+
+  const result: number[] = []
+
+  for (const byte of bin) {
+    let carry = byte
+    for (let j = 0; j < result.length; ++j) {
+      const x = (base58Map[result[j]] << 8) + carry
+      result[j] = base58chars.charCodeAt(x % 58)
+      carry = (x / 58) | 0
+    }
+    while (carry !== 0) {
+      result.push(base58chars.charCodeAt(carry % 58))
+      carry = (carry / 58) | 0
+    }
+  }
+
+  for (const byte of bin) {
+    if (byte !== 0) break
+    else result.push('1'.charCodeAt(0))
+  }
+
+  result.reverse()
+
+  return String.fromCharCode(...result)
+}
+
+/**
+ * Converts a binary array into a base58check string with a checksum
+ * @param bin - The binary array to convert to base58check
+ * @returns The base58check string representation
+ */
+export const toBase58Check = (bin: number[], prefix: number[] = [0]): string => {
+  let hash = hash256([...prefix, ...bin])
+  hash = [...prefix, ...bin, ...hash.slice(0, 4)]
+  return toBase58(hash)
+}
+
+/**
+ * Converts a base58check string into a binary array after validating the checksum
+ * @param str - The base58check string to convert to binary
+ * @param enc - If hex, the return values will be hex strings, arrays of numbers otherwise
+ * @param prefixLength - The length of the prefix. Optional, defaults to 1.
+ * @returns The binary array representation
+ */
+export const fromBase58Check = (
+  str: string,
+  enc?: 'hex',
+  prefixLength: number = 1
+): { data: number[] | string, prefix: number[] | string } => {
+  const bin = fromBase58(str)
+  let prefix: string | number[] = bin.slice(0, prefixLength)
+  let data: string | number[] = bin.slice(prefixLength, -4)
+  let hash = [...prefix, ...data]
+  hash = hash256(hash)
+  bin.slice(-4).forEach((check, index) => {
+    if (check !== hash[index]) {
+      throw new Error('Invalid checksum')
+    }
+  })
+  if (enc === 'hex') {
+    prefix = toHex(prefix)
+    data = toHex(data)
+  }
+  return { prefix, data }
+}
+
+type WriterChunk = readonly number[] | Uint8Array
+
+export class Writer {
+  public bufs: WriterChunk[]
+  private length: number
+
+  constructor (bufs?: WriterChunk[]) {
+    this.bufs = bufs !== undefined ? bufs : []
+    this.length = 0
+    for (const b of this.bufs) this.length += b.length
+  }
+
+  getLength (): number {
+    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) {
+      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: WriterChunk): this {
+    this.bufs.push(buf)
+    this.length += buf.length
+    return this
+  }
+
+  writeReverse (buf: number[]): this {
+    const buf2: number[] = new Array(buf.length)
+    for (let i = 0; i < buf2.length; i++) {
+      buf2[i] = buf[buf.length - 1 - i]
+    }
+    return this.write(buf2)
+  }
+
+  writeUInt8 (n: number): this {
+    const buf = new Array(1)
+    buf[0] = n & 0xff
+    this.write(buf)
+    return this
+  }
+
+  writeInt8 (n: number): this {
+    const buf = new Array(1)
+    buf[0] = n & 0xff
+    this.write(buf)
+    return this
+  }
+
+  writeUInt16BE (n: number): this {
+    const buf = [
+      (n >> 8) & 0xff, // shift right 8 bits to get the high byte
+      n & 0xff // low byte is just the last 8 bits
+    ]
+    return this.write(buf)
+  }
+
+  writeInt16BE (n: number): this {
+    return this.writeUInt16BE(n & 0xffff) // Mask with 0xFFFF to get the lower 16 bits
+  }
+
+  writeUInt16LE (n: number): this {
+    const buf = [
+      n & 0xff, // low byte is just the last 8 bits
+      (n >> 8) & 0xff // shift right 8 bits to get the high byte
+    ]
+    return this.write(buf)
+  }
+
+  writeInt16LE (n: number): this {
+    return this.writeUInt16LE(n & 0xffff) // Mask with 0xFFFF to get the lower 16 bits
+  }
+
+  writeUInt32BE (n: number): this {
+    const buf = [
+      (n >> 24) & 0xff, // highest byte
+      (n >> 16) & 0xff,
+      (n >> 8) & 0xff,
+      n & 0xff // lowest byte
+    ]
+    return this.write(buf)
+  }
+
+  writeInt32BE (n: number): this {
+    return this.writeUInt32BE(n >>> 0) // Using unsigned right shift to handle negative numbers
+  }
+
+  writeUInt32LE (n: number): this {
+    const buf = [
+      n & 0xff, // lowest byte
+      (n >> 8) & 0xff,
+      (n >> 16) & 0xff,
+      (n >> 24) & 0xff // highest byte
+    ]
+    return this.write(buf)
+  }
+
+  writeInt32LE (n: number): this {
+    return this.writeUInt32LE(n >>> 0) // Using unsigned right shift to handle negative numbers
+  }
+
+  writeUInt64BEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.write(buf)
+    return this
+  }
+
+  writeUInt64LEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeUInt64LE (n: number): this {
+    const buf = new BigNumber(n).toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeVarIntNum (n: number): this {
+    const buf = Writer.varIntNum(n)
+    this.write(buf)
+    return this
+  }
+
+  writeVarIntBn (bn: BigNumber): this {
+    const buf = Writer.varIntBn(bn)
+    this.write(buf)
+    return this
+  }
+
+  static varIntNum (n: number): number[] {
+    let buf: number[]
+    if (n < 0) {
+      return this.varIntBn(new BigNumber(n))
+    }
+    if (n < 253) {
+      buf = [n] // 1 byte
+    } else if (n < 0x10000) {
+      // 253 followed by the number in little-endian format
+      buf = [
+        253, // 0xfd
+        n & 0xff, // low byte
+        (n >> 8) & 0xff // high byte
+      ]
+    } else if (n < 0x100000000) {
+      // 254 followed by the number in little-endian format
+      buf = [
+        254, // 0xfe
+        n & 0xff,
+        (n >> 8) & 0xff,
+        (n >> 16) & 0xff,
+        (n >> 24) & 0xff
+      ]
+    } else {
+      // 255 followed by the number in little-endian format
+      // Since JavaScript bitwise operations work on 32 bits, we need to handle 64-bit numbers in two parts
+      const low = n & 0xffffffff
+      const high = Math.floor(n / 0x100000000) & 0xffffffff
+      buf = [
+        255, // 0xff
+        low & 0xff,
+        (low >> 8) & 0xff,
+        (low >> 16) & 0xff,
+        (low >> 24) & 0xff,
+        high & 0xff,
+        (high >> 8) & 0xff,
+        (high >> 16) & 0xff,
+        (high >> 24) & 0xff
+      ]
+    }
+    return buf
+  }
+
+  static varIntBn (bn: BigNumber): number[] {
+    let buf: number[]
+    if (bn.isNeg()) {
+      bn = bn.add(OverflowUint64) // Adjust for negative numbers
+    }
+    if (bn.ltn(253)) {
+      const n = bn.toNumber()
+      // No need for bitwise operation as the value is within a byte's range
+      buf = [n]
+    } else if (bn.ltn(0x10000)) {
+      const n = bn.toNumber()
+      // Value fits in a uint16
+      buf = [253, n & 0xff, (n >> 8) & 0xff]
+    } else if (bn.lt(new BigNumber(0x100000000))) {
+      const n = bn.toNumber()
+      // Value fits in a uint32
+      buf = [
+        254,
+        n & 0xff,
+        (n >> 8) & 0xff,
+        (n >> 16) & 0xff,
+        (n >> 24) & 0xff
+      ]
+    } else {
+      const bw = new Writer()
+      bw.writeUInt8(255)
+      bw.writeUInt64LEBn(bn)
+      buf = bw.toArray()
+    }
+    return buf
+  }
+}
+
+export class Reader {
+  public bin: number[]
+  public pos: number
+  private readonly length: number
+
+  constructor (bin: number[] = [], pos: number = 0) {
+    this.bin = bin
+    this.pos = pos
+    this.length = bin.length
+  }
+
+  public eof (): boolean {
+    return this.pos >= this.length
+  }
+
+  public read (len = this.length): number[] {
+    const start = this.pos
+    const end = this.pos + len
+    this.pos = end
+    return this.bin.slice(start, end)
+  }
+
+  public readReverse (len = this.length): number[] {
+    const buf2 = new Array(len)
+    for (let i = 0; i < len; i++) {
+      buf2[i] = this.bin[this.pos + len - 1 - i]
+    }
+    this.pos += len
+    return buf2
+  }
+
+  public readUInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    return val
+  }
+
+  public readInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80) !== 0 ? val - 0x100 : val
+  }
+
+  public readUInt16BE (): number {
+    const val = (this.bin[this.pos] << 8) | this.bin[this.pos + 1]
+    this.pos += 2
+    return val
+  }
+
+  public readInt16BE (): number {
+    const val = this.readUInt16BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x8000) !== 0 ? val - 0x10000 : val
+  }
+
+  public readUInt16LE (): number {
+    const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
+    this.pos += 2
+    return val
+  }
+
+  public readInt16LE (): number {
+    const val = this.readUInt16LE()
+    // If the sign bit is set, convert to negative value
+    const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
+    return x
+  }
+
+  public readUInt32BE (): number {
+    const val =
+      this.bin[this.pos] * 0x1000000 + // Shift the first byte by 24 bits
+      ((this.bin[this.pos + 1] << 16) | // Shift the second byte by 16 bits
+        (this.bin[this.pos + 2] << 8) | // Shift the third byte by 8 bits
+        this.bin[this.pos + 3]) // The fourth byte
+    this.pos += 4
+    return val
+  }
+
+  public readInt32BE (): number {
+    const val = this.readUInt32BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt32LE (): number {
+    const val =
+      (this.bin[this.pos] |
+        (this.bin[this.pos + 1] << 8) |
+        (this.bin[this.pos + 2] << 16) |
+        (this.bin[this.pos + 3] << 24)) >>>
+      0
+    this.pos += 4
+    return val
+  }
+
+  public readInt32LE (): number {
+    const val = this.readUInt32LE()
+    // Explicitly check if the sign bit is set and then convert to a negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt64BEBn (): BigNumber {
+    const bin = this.bin.slice(this.pos, this.pos + 8)
+    const bn = new BigNumber(bin)
+    this.pos = this.pos + 8
+    return bn
+  }
+
+  public readUInt64LEBn (): BigNumber {
+    const bin = this.readReverse(8)
+    const bn = new BigNumber(bin)
+    return bn
+  }
+
+  public readInt64LEBn (): BigNumber {
+    const bin = this.readReverse(8)
+    let bn = new BigNumber(bin)
+    if (bn.gte(OverflowInt64)) {
+      bn = bn.sub(OverflowUint64) // Adjust for negative numbers
+    }
+    return bn
+  }
+
+  public readVarIntNum (signed: boolean = true): number {
+    const first = this.readUInt8()
+    let bn: BigNumber
+    switch (first) {
+      case 0xfd:
+        return this.readUInt16LE()
+      case 0xfe:
+        return this.readUInt32LE()
+      case 0xff:
+        bn = signed ? this.readInt64LEBn() : this.readUInt64LEBn()
+        if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
+          return bn.toNumber()
+        } else {
+          throw new Error(
+            'number too large to retain precision - use readVarIntBn'
+          )
+        }
+      default:
+        return first
+    }
+  }
+
+  public readVarInt (): number[] {
+    const first = this.bin[this.pos]
+    switch (first) {
+      case 0xfd:
+        return this.read(1 + 2)
+      case 0xfe:
+        return this.read(1 + 4)
+      case 0xff:
+        return this.read(1 + 8)
+      default:
+        return this.read(1)
+    }
+  }
+
+  public readVarIntBn (): BigNumber {
+    const first = this.readUInt8()
+    switch (first) {
+      case 0xfd:
+        return new BigNumber(this.readUInt16LE())
+      case 0xfe:
+        return new BigNumber(this.readUInt32LE())
+      case 0xff:
+        return this.readUInt64LEBn()
+      default:
+        return new BigNumber(first)
+    }
+  }
+}
+
+export const minimallyEncode = (buf: number[]): number[] => {
+  if (buf.length === 0) {
+    return buf
+  }
+
+  // If the last byte is not 0x00 or 0x80, we are minimally encoded.
+  const last = buf[buf.length - 1]
+  if ((last & 0x7f) !== 0) {
+    return buf
+  }
+
+  // If the script is one byte long, then we have a zero, which encodes as an
+  // empty array.
+  if (buf.length === 1) {
+    return []
+  }
+
+  // If the next byte has it sign bit set, then we are minimaly encoded.
+  if ((buf[buf.length - 2] & 0x80) !== 0) {
+    return buf
+  }
+
+  // We are not minimally encoded, we need to figure out how much to trim.
+  for (let i = buf.length - 1; i > 0; i--) {
+    // We found a non zero byte, time to encode.
+    if (buf[i - 1] !== 0) {
+      if ((buf[i - 1] & 0x80) !== 0) {
+        // We found a byte with it sign bit set so we need one more
+        // byte.
+        buf[i] = last
+        return buf.slice(0, i + 1)
+      } else {
+        // the sign bit is clear, we can use it.
+        buf[i - 1] |= last
+        return buf.slice(0, i)
+      }
+    }
+  }
+
+  // If we found the whole thing is zeros, then we have a zero.
+  return []
+}
+
+const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
+const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))
+
+/**
+ * Verifies that a value is not null or undefined, throwing an error if it is.
+ *
+ * @template T - The type of the value being verified
+ * @param {T | undefined | null} value - The value to verify
+ * @param {string} errorMessage - The error message to throw if the value is null or undefined
+ * @returns {T} - The verified value
+ * @throws {Error} - If the value is null or undefined
+ *
+ * @example
+ * const myValue = verifyNotNull(someValue, 'someValue must be defined')
+ */
+export function verifyNotNull<T> (value: T | undefined | null, errorMessage: string = 'Expected a valid value, but got undefined or null.'): T {
+  if (value == null) throw new Error(errorMessage)
+  return value
+}