@bsv/wallet-toolbox 1.7.15 → 1.7.17

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

@@ -1,1368 +0,0 @@
-// @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
- * numbers.
- *
- * @class BigNumber
- */
-export default class BigNumber {
-  /**
-   * @privateinitializer
-   */
-  public static readonly zeros: string[] = [
-    '', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000',
-    '000000000', '0000000000', '00000000000', '000000000000', '0000000000000',
-    '00000000000000', '000000000000000', '0000000000000000', '00000000000000000',
-    '000000000000000000', '0000000000000000000', '00000000000000000000',
-    '000000000000000000000', '0000000000000000000000', '00000000000000000000000',
-    '000000000000000000000000', '0000000000000000000000000'
-  ]
-
-  /**
-   * @privateinitializer
-   */
-  static readonly groupSizes: number[] = [
-    0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
-  ]
-
-  /**
-   * @privateinitializer
-   */
-  static readonly groupBases: number[] = [
-    0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
-    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
-    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632, 6436343,
-    7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 24300000,
-    28629151, 33554432, 39135393, 45435424, 52521875, 60466176
-  ]
-
-  /**
-   * The word size of big number chunks.
-   *
-   * @property wordSize
-   *
-   * @example
-   * console.log(BigNumber.wordSize);  // output: 26
-   */
-  static readonly wordSize: number = 26
-  private static readonly WORD_SIZE_BIGINT: bigint = BigInt(BigNumber.wordSize)
-  private static readonly WORD_MASK: bigint = (1n << BigNumber.WORD_SIZE_BIGINT) - 1n
-  private static readonly MAX_SAFE_INTEGER_BIGINT: bigint = BigInt(Number.MAX_SAFE_INTEGER)
-  private static readonly MIN_SAFE_INTEGER_BIGINT: bigint = BigInt(Number.MIN_SAFE_INTEGER)
-  private static readonly MAX_IMULN_ARG: number = 0x4000000 - 1
-  private static readonly MAX_NUMBER_CONSTRUCTOR_MAG_BIGINT: bigint = (1n << 53n) - 1n
-
-  private _magnitude: bigint
-  private _sign: 0 | 1
-  private _nominalWordLength: number
-
-  /**
-   * Reduction context of the big number.
-   *
-   * @property red
-   */
-  public red: ReductionContext | null
-
-  /**
-   * Negative flag. Indicates whether the big number is a negative number.
-   * - If 0, the number is positive.
-   * - If 1, the number is negative.
-   *
-   * @property negative
-   */
-  public get negative (): number {
-    return this._sign
-  }
-
-  /**
-   * Sets the negative flag. Only 0 (positive) or 1 (negative) are allowed.
-   */
-  public set negative (val: number) {
-    this.assert(val === 0 || val === 1, 'Negative property must be 0 or 1')
-    const newSign = val === 1 ? 1 : 0
-    if (this._magnitude === 0n) {
-      this._sign = 0
-    } else {
-      this._sign = newSign
-    }
-  }
-
-  private get _computedWordsArray (): number[] {
-    if (this._magnitude === 0n) return [0]
-    const arr: number[] = []
-    let temp = this._magnitude
-    while (temp > 0n) {
-      arr.push(Number(temp & BigNumber.WORD_MASK))
-      temp >>= BigNumber.WORD_SIZE_BIGINT
-    }
-    return arr.length > 0 ? arr : [0]
-  }
-
-  /**
-   * Array of numbers, where each number represents a part of the value of the big number.
-   *
-   * @property words
-   */
-  public get words (): number[] {
-    const computed = this._computedWordsArray
-    if (this._nominalWordLength <= computed.length) {
-      return computed
-    }
-    const paddedWords = new Array(this._nominalWordLength).fill(0)
-    for (let i = 0; i < computed.length; i++) {
-      paddedWords[i] = computed[i]
-    }
-    return paddedWords
-  }
-
-  /**
-   * Sets the words array representing the value of the big number.
-   */
-  public set words (newWords: number[]) {
-    const oldSign = this._sign
-    let newMagnitude = 0n
-    const len = newWords.length > 0 ? newWords.length : 1
-    for (let i = len - 1; i >= 0; i--) {
-      const wordVal = newWords[i] === undefined ? 0 : newWords[i]
-      newMagnitude = (newMagnitude << BigNumber.WORD_SIZE_BIGINT) | BigInt(wordVal & Number(BigNumber.WORD_MASK))
-    }
-    this._magnitude = newMagnitude
-    this._sign = oldSign
-    this._nominalWordLength = len
-    this.normSign()
-  }
-
-  /**
-   * Length of the words array.
-   *
-   * @property length
-   */
-  public get length (): number {
-    return Math.max(1, this._nominalWordLength)
-  }
-
-  /**
-   * Checks whether a value is an instance of BigNumber. Regular JS numbers fail this check.
-   *
-   * @method isBN
-   * @param num - The value to be checked.
-   * @returns - Returns a boolean value determining whether or not the checked num parameter is a BigNumber.
-   */
-  static isBN (num: any): boolean {
-    if (num instanceof BigNumber) return true
-    return (
-      num !== null &&
-      typeof num === 'object' &&
-      num.constructor?.wordSize === BigNumber.wordSize &&
-      Array.isArray(num.words)
-    )
-  }
-
-  /**
-   * Returns the bigger value between two BigNumbers
-   *
-   * @method max
-   * @param left - The first BigNumber to be compared.
-   * @param right - The second BigNumber to be compared.
-   * @returns - Returns the bigger BigNumber between left and right.
-   */
-  static max (left: BigNumber, right: BigNumber): BigNumber { return left.cmp(right) > 0 ? left : right }
-
-  /**
-   * Returns the smaller value between two BigNumbers
-   *
-   * @method min
-   * @param left - The first BigNumber to be compared.
-   * @param right - The second BigNumber to be compared.
-   * @returns - Returns the smaller value between left and right.
-   */
-  static min (left: BigNumber, right: BigNumber): BigNumber { return left.cmp(right) < 0 ? left : right }
-
-  /**
-   * @constructor
-   *
-   * @param number - The number (various types accepted) to construct a BigNumber from. Default is 0.
-   * @param base - The base of number provided. By default is 10.
-   * @param endian - The endianness provided. By default is 'big endian'.
-   */
-  constructor (
-    number: number | string | number[] | bigint | undefined = 0,
-    base: number | 'be' | 'le' | 'hex' = 10,
-    endian: 'be' | 'le' = 'be'
-  ) {
-    this._magnitude = 0n
-    this._sign = 0
-    this._nominalWordLength = 1
-    this.red = null
-
-    if (number === undefined) number = 0
-
-    if (number === null) { this._initializeState(0n, 0); return }
-    if (typeof number === 'bigint') { this._initializeState(number < 0n ? -number : number, number < 0n ? 1 : 0); this.normSign(); return }
-
-    let effectiveBase: number | 'hex' = base
-    let effectiveEndian: 'be' | 'le' = endian
-
-    if (base === 'le' || base === 'be') { effectiveEndian = base; effectiveBase = 10 }
-
-    if (typeof number === 'number') { this.initNumber(number, effectiveEndian); return }
-    if (Array.isArray(number)) { this.initArray(number, effectiveEndian); return }
-
-    if (typeof number === 'string') {
-      if (effectiveBase === 'hex') effectiveBase = 16
-      this.assert(typeof effectiveBase === 'number' && effectiveBase === (effectiveBase | 0) && effectiveBase >= 2 && effectiveBase <= 36, 'Base must be an integer between 2 and 36')
-      const originalNumberStr = number.toString().replace(/\s+/g, '')
-      let start = 0; let sign = 0
-      if (originalNumberStr.startsWith('-')) { start++; sign = 1 } else if (originalNumberStr.startsWith('+')) { start++ }
-
-      const numStr = originalNumberStr.substring(start)
-      if (numStr.length === 0) { this._initializeState(0n, (sign === 1 && originalNumberStr.startsWith('-')) ? 1 : 0); this.normSign(); return }
-
-      if (effectiveBase === 16) {
-        let tempMagnitude: bigint
-        if (effectiveEndian === 'le') {
-          const bytes: number[] = []; let hexStr = numStr
-          if (hexStr.length % 2 !== 0) hexStr = '0' + hexStr
-          for (let i = 0; i < hexStr.length; i += 2) {
-            const byteHex = hexStr.substring(i, i + 2); const byteVal = parseInt(byteHex, 16)
-            if (isNaN(byteVal)) throw new Error('Invalid character in ' + hexStr)
-            bytes.push(byteVal)
-          }
-          this.initArray(bytes, 'le'); this._sign = sign; this.normSign(); return
-        } else {
-          try { tempMagnitude = BigInt('0x' + numStr) } catch (e) { throw new Error('Invalid character in ' + numStr) }
-        }
-        this._initializeState(tempMagnitude, sign); this.normSign()
-      } else {
-        try {
-          this._parseBaseString(numStr, effectiveBase)
-          this._sign = sign; this.normSign()
-          if (effectiveEndian === 'le') {
-            const currentSign = this._sign
-            this.initArray(this.toArray('be'), 'le')
-            this._sign = currentSign; this.normSign()
-          }
-        } catch (err) {
-          const error = err as Error
-          if (
-            error.message.includes('Invalid character in string') ||
-            error.message.includes('Invalid digit for base') ||
-            error.message.startsWith('Invalid character:')
-          ) {
-            throw new Error('Invalid character')
-          }
-          throw error
-        }
-      }
-    } else if (number !== 0) {
-      this.assert(false, 'Unsupported input type for BigNumber constructor')
-    } else {
-      this._initializeState(0n, 0)
-    }
-  }
-
-  private _bigIntToStringInBase (num: bigint, base: number): string {
-    if (num === 0n) return '0'
-    if (base < 2 || base > 36) throw new Error('Base must be between 2 and 36')
-
-    const digits = '0123456789abcdefghijklmnopqrstuvwxyz'
-    let result = ''
-    let currentNum = num > 0n ? num : -num
-    const bigBase = BigInt(base)
-
-    while (currentNum > 0n) {
-      result = digits[Number(currentNum % bigBase)] + result
-      currentNum /= bigBase
-    }
-    return result
-  }
-
-  private _parseBaseString (numberStr: string, base: number): void {
-    if (numberStr.length === 0) { this._magnitude = 0n; this._finishInitialization(); return }
-
-    this._magnitude = 0n
-    const bigBase = BigInt(base)
-
-    let groupSize = BigNumber.groupSizes[base]
-    let groupBaseBigInt = BigInt(BigNumber.groupBases[base])
-
-    if (groupSize === 0 || groupBaseBigInt === 0n) {
-      groupSize = Math.floor(Math.log(0x3ffffff) / Math.log(base))
-      if (groupSize === 0) groupSize = 1
-      groupBaseBigInt = bigBase ** BigInt(groupSize)
-    }
-
-    let currentPos = 0
-    const totalLen = numberStr.length
-
-    let firstChunkLen = totalLen % groupSize
-    if (firstChunkLen === 0 && totalLen > 0) firstChunkLen = groupSize
-
-    if (firstChunkLen > 0) {
-      const chunkStr = numberStr.substring(currentPos, currentPos + firstChunkLen)
-      this._magnitude = BigInt(this._parseBaseWord(chunkStr, base))
-      currentPos += firstChunkLen
-    }
-
-    while (currentPos < totalLen) {
-      const chunkStr = numberStr.substring(currentPos, currentPos + groupSize)
-      const wordVal = BigInt(this._parseBaseWord(chunkStr, base))
-      this._magnitude = this._magnitude * groupBaseBigInt + wordVal
-      currentPos += groupSize
-    }
-
-    this._finishInitialization()
-  }
-
-  private _parseBaseWord (str: string, base: number): number {
-    let r = 0
-    for (let i = 0; i < str.length; i++) {
-      const charCode = str.charCodeAt(i)
-      let digitVal
-      if (charCode >= 48 && charCode <= 57) digitVal = charCode - 48
-      else if (charCode >= 65 && charCode <= 90) digitVal = charCode - 65 + 10
-      else if (charCode >= 97 && charCode <= 122) digitVal = charCode - 97 + 10
-      else throw new Error('Invalid character: ' + str[i])
-
-      if (digitVal >= base) throw new Error('Invalid character')
-      r = r * base + digitVal
-    }
-    return r
-  }
-
-  private _initializeState (magnitude: bigint, sign: 0 | 1): void {
-    this._magnitude = magnitude
-    this._sign = (magnitude === 0n) ? 0 : sign
-    this._finishInitialization()
-  }
-
-  private _finishInitialization (): void {
-    if (this._magnitude === 0n) {
-      this._nominalWordLength = 1
-      this._sign = 0
-    } else {
-      const bitLen = this._magnitude.toString(2).length
-      this._nominalWordLength = Math.max(1, Math.ceil(bitLen / BigNumber.wordSize))
-    }
-  }
-
-  private assert (val: unknown, msg: string = 'Assertion failed'): void { if (!(val as boolean)) throw new Error(msg) }
-
-  private initNumber (number: number, endian: 'be' | 'le' = 'be'): this {
-    this.assert(BigInt(Math.abs(number)) <= BigNumber.MAX_NUMBER_CONSTRUCTOR_MAG_BIGINT, 'The number is larger than 2 ^ 53 (unsafe)')
-    this.assert(number % 1 === 0, 'Number must be an integer for BigNumber conversion')
-    this._initializeState(BigInt(Math.abs(number)), number < 0 ? 1 : 0)
-    if (endian === 'le') {
-      const currentSign = this._sign
-      const beBytes = this.toArray('be')
-      this.initArray(beBytes, 'le')
-      this._sign = currentSign
-      this.normSign()
-    }
-    return this
-  }
-
-  private initArray (bytes: number[], endian: 'be' | 'le'): this {
-    if (bytes.length === 0) { this._initializeState(0n, 0); return this }
-    let magnitude = 0n
-    if (endian === 'be') {
-      for (let i = 0; i < bytes.length; i++) magnitude = (magnitude << 8n) | BigInt(bytes[i] & 0xff)
-    } else {
-      for (let i = bytes.length - 1; i >= 0; i--) magnitude = (magnitude << 8n) | BigInt(bytes[i] & 0xff)
-    }
-    this._initializeState(magnitude, 0)
-    return this
-  }
-
-  copy (dest: BigNumber): void { dest._magnitude = this._magnitude; dest._sign = this._sign; dest._nominalWordLength = this._nominalWordLength; dest.red = this.red }
-  static move (dest: BigNumber, src: BigNumber): void { dest._magnitude = src._magnitude; dest._sign = src._sign; dest._nominalWordLength = src._nominalWordLength; dest.red = src.red }
-  clone (): BigNumber { const r = new BigNumber(0n); this.copy(r); return r }
-
-  expand (size: number): this {
-    this.assert(size >= 0, 'Expand size must be non-negative')
-    this._nominalWordLength = Math.max(this._nominalWordLength, size, 1)
-    return this
-  }
-
-  strip (): this { this._finishInitialization(); return this.normSign() }
-  normSign (): this { if (this._magnitude === 0n) this._sign = 0; return this }
-  inspect (): string { return (this.red !== null ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>' }
-
-  private _getMinimalHex (): string {
-    if (this._magnitude === 0n) return '0'
-    return this._magnitude.toString(16)
-  }
-
-  /**
-   * Converts the BigNumber instance to a string representation.
-   *
-   * @method toString
-   * @param base - The base for representing number. Default is 10. Other accepted values are 16 and 'hex'.
-   * @param padding - Represents the minimum number of digits to represent the BigNumber as a string. Default is 1.
-   * @returns The string representation of the BigNumber instance
-   */
-  toString (base: number | 'hex' = 10, padding: number = 1): string {
-    if (base === 16 || base === 'hex') {
-      // For toString('hex', N), N is the 'multiple-of-N characters' rule from bn.js tests
-      // For toString(16, P) where P=1 (default) or P=0, it means minimal hex.
-      let hexStr = this._getMinimalHex() // e.g., "f", "123", "0"
-
-      if (padding > 1) { // N-multiple rule for characters
-        // Ensure hexStr is even length if not "0" to represent full bytes before applying multiple rule
-        if (hexStr !== '0' && hexStr.length % 2 !== 0) {
-          hexStr = '0' + hexStr
-        }
-        while (hexStr.length % padding !== 0) {
-          hexStr = '0' + hexStr
-        }
-      }
-      // If padding is 0 or 1, hexStr (minimal) is used as is.
-      // "0" is always "0" unless toHex("") specific case.
-      // Single digit hex like "f" is not "0f" by default from toString(16).
-      return (this.isNeg() ? '-' : '') + hexStr
-    }
-
-    if (typeof base !== 'number' || base < 2 || base > 36 || base % 1 !== 0) throw new Error('Base should be an integer between 2 and 36')
-    return this.toBaseString(base, padding)
-  }
-
-  private toBaseString (base: number, padding: number): string {
-    if (this._magnitude === 0n) {
-      let out = '0'
-      if (padding > 1) { while (out.length < padding) out = '0' + out }
-      return out
-    }
-
-    let groupSize = BigNumber.groupSizes[base]
-    let groupBaseBigInt = BigInt(BigNumber.groupBases[base])
-    if (groupSize === 0 || groupBaseBigInt === 0n) {
-      groupSize = Math.floor(Math.log(Number.MAX_SAFE_INTEGER) / Math.log(base))
-      if (groupSize === 0) groupSize = 1
-      groupBaseBigInt = BigInt(base) ** BigInt(groupSize)
-    }
-
-    let out = ''
-    let tempMag = this._magnitude
-
-    while (tempMag > 0n) {
-      const remainder = tempMag % groupBaseBigInt
-      tempMag /= groupBaseBigInt
-
-      const chunkStr = this._bigIntToStringInBase(remainder, base)
-
-      if (tempMag > 0n) {
-        const zerosToPrepend = groupSize - chunkStr.length
-        if (zerosToPrepend > 0 && zerosToPrepend < BigNumber.zeros.length) {
-          out = BigNumber.zeros[zerosToPrepend] + chunkStr + out
-        } else if (zerosToPrepend > 0) {
-          out = '0'.repeat(zerosToPrepend) + chunkStr + out
-        } else {
-          out = chunkStr + out
-        }
-      } else {
-        out = chunkStr + out
-      }
-    }
-
-    if (padding > 0) { while (out.length < padding) out = '0' + out }
-    return (this._sign === 1 ? '-' : '') + out
-  }
-
-  /**
-   * Converts the BigNumber instance to a JavaScript number.
-   * Please note that JavaScript numbers are only precise up to 53 bits.
-   *
-   * @method toNumber
-   * @throws If the BigNumber instance cannot be safely stored in a JavaScript number
-   * @returns The JavaScript number representation of the BigNumber instance.
-   */
-  toNumber (): number {
-    const val = this._getSignedValue()
-    if (val > BigNumber.MAX_SAFE_INTEGER_BIGINT || val < BigNumber.MIN_SAFE_INTEGER_BIGINT) throw new Error('Number can only safely store up to 53 bits')
-    return Number(val)
-  }
-
-  /**
-   * Returns the signed BigInt representation of this BigNumber without any safety checks.
-   *
-   * @method toBigInt
-   * @returns bigint value for this BigNumber.
-   */
-  toBigInt (): bigint {
-    return this._getSignedValue()
-  }
-
-  /**
-   * Converts the BigNumber instance to a JSON-formatted string.
-   *
-   * @method toJSON
-   * @returns The JSON string representation of the BigNumber instance.
-   */
-  toJSON (): string {
-    const hex = this._getMinimalHex()
-    return (this.isNeg() ? '-' : '') + hex
-  }
-
-  private toArrayLikeGeneric (res: number[], isLE: boolean): void {
-    let tempMag = this._magnitude
-    let position = isLE ? 0 : res.length - 1
-    const increment = isLE ? 1 : -1
-
-    for (let k = 0; k < res.length; ++k) {
-      if (tempMag === 0n && position >= 0 && position < res.length) {
-        res[position] = 0
-      } else if (position >= 0 && position < res.length) {
-        res[position] = Number(tempMag & 0xffn)
-      } else {
-        break
-      }
-      tempMag >>= 8n
-      position += increment
-    }
-  }
-
-  /**
-   * Converts the BigNumber instance to an array of bytes.
-   *
-   * @method toArray
-   * @param endian - Endianness of the output array, defaults to 'be'.
-   * @param length - Optional length of the output array.
-   * @returns Array of bytes representing the BigNumber.
-   */
-  toArray (endian: 'le' | 'be' = 'be', length?: number): number[] {
-    this.strip()
-    const actualByteLength = this.byteLength()
-    const reqLength = length ?? Math.max(1, actualByteLength)
-
-    this.assert(actualByteLength <= reqLength, 'byte array longer than desired length')
-    this.assert(reqLength > 0, 'Requested array length <= 0')
-
-    const res = new Array(reqLength).fill(0)
-    if (this._magnitude === 0n && reqLength > 0) return res
-    if (this._magnitude === 0n && reqLength === 0) return []
-
-    this.toArrayLikeGeneric(res, endian === 'le')
-    return res
-  }
-
-  /**
-   * Calculates the number of bits required to represent the BigNumber.
-   *
-   * @method bitLength
-   * @returns The bit length of the BigNumber.
-   */
-  bitLength (): number { if (this._magnitude === 0n) return 0; return this._magnitude.toString(2).length }
-  /**
-   * Converts a BigNumber to an array of bits.
-   *
-   * @method toBitArray
-   * @param num - The BigNumber to convert.
-   * @returns An array of bits.
-   */
-  static toBitArray (num: BigNumber): Array<0 | 1> {
-    const len = num.bitLength()
-    if (len === 0) return []
-    const w = new Array<0 | 1>(len)
-    const mag = num._magnitude
-    for (let bit = 0; bit < len; bit++) {
-      w[bit] = ((mag >> BigInt(bit)) & 1n) !== 0n ? 1 : 0
-    }
-    return w
-  }
-
-  /**
-   * Instance version of {@link toBitArray}.
-   */
-  toBitArray (): Array<0 | 1> { return BigNumber.toBitArray(this) }
-
-  /**
-   * Returns the number of trailing zero bits in the big number.
-   *
-   * @method zeroBits
-   * @returns Returns the number of trailing zero bits
-   * in the binary representation of the big number.
-   *
-   * @example
-   * const bn = new BigNumber('8'); // binary: 1000
-   * const zeroBits = bn.zeroBits(); // 3
-   */
-  zeroBits (): number {
-    if (this._magnitude === 0n) return 0
-    let c = 0
-    let t = this._magnitude
-    while ((t & 1n) === 0n && t !== 0n) {
-      c++
-      t >>= 1n
-    }
-    return c
-  }
-
-  /**
-   * Calculates the number of bytes required to represent the BigNumber.
-   *
-   * @method byteLength
-   * @returns The byte length of the BigNumber.
-   */
-  byteLength (): number { if (this._magnitude === 0n) return 0; return Math.ceil(this.bitLength() / 8) }
-
-  private _getSignedValue (): bigint { return this._sign === 1 ? -this._magnitude : this._magnitude }
-
-  private _setValueFromSigned (sVal: bigint): void {
-    if (sVal < 0n) {
-      this._magnitude = -sVal
-      this._sign = 1
-    } else {
-      this._magnitude = sVal
-      this._sign = 0
-    }
-    this._finishInitialization()
-    this.normSign()
-  }
-
-  toTwos (width: number): BigNumber {
-    this.assert(width >= 0)
-    const Bw = BigInt(width)
-    let v = this._getSignedValue()
-    if (this._sign === 1 && this._magnitude !== 0n) v = (1n << Bw) + v
-    const m = (1n << Bw) - 1n; v &= m
-    const r = new BigNumber(0n)
-    r._initializeState(v, 0)
-    return r
-  }
-
-  fromTwos (width: number): BigNumber {
-    this.assert(width >= 0)
-    const Bw = BigInt(width)
-    const m = this._magnitude
-    if (width > 0 && ((m >> (Bw - 1n)) & 1n) !== 0n && this._sign === 0) {
-      const sVal = m - (1n << Bw)
-      const r = new BigNumber(0n)
-      r._setValueFromSigned(sVal)
-      return r
-    }
-    return this.clone()
-  }
-
-  isNeg (): boolean { return this._sign === 1 && this._magnitude !== 0n }
-  neg (): BigNumber { return this.clone().ineg() }
-  ineg (): this { if (this._magnitude !== 0n) this._sign = this._sign === 1 ? 0 : 1; return this }
-
-  private _iuop (num: BigNumber, op: (a: bigint, b: bigint) => bigint): this {
-    const newMag = op(this._magnitude, num._magnitude)
-    const isXor = op === ((a: bigint, b: bigint) => a ^ b)
-    let targetNominalLength = this._nominalWordLength
-    if (isXor) targetNominalLength = Math.max(this.length, num.length)
-
-    this._magnitude = newMag
-    this._finishInitialization()
-    if (isXor) this._nominalWordLength = Math.max(this._nominalWordLength, targetNominalLength)
-    return this.strip()
-  }
-
-  iuor (num: BigNumber): this { return this._iuop(num, (a, b) => a | b) }
-  iuand (num: BigNumber): this { return this._iuop(num, (a, b) => a & b) }
-  iuxor (num: BigNumber): this { return this._iuop(num, (a, b) => a ^ b) }
-  private _iop (num: BigNumber, op: (a: bigint, b: bigint) => bigint): this { this.assert(this._sign === 0 && num._sign === 0); return this._iuop(num, op) }
-  ior (num: BigNumber): this { return this._iop(num, (a, b) => a | b) }
-  iand (num: BigNumber): this { return this._iop(num, (a, b) => a & b) }
-  ixor (num: BigNumber): this { return this._iop(num, (a, b) => a ^ b) }
-  private _uop_new (num: BigNumber, opName: 'iuor' | 'iuand' | 'iuxor'): BigNumber { if (this.length >= num.length) return this.clone()[opName](num); return num.clone()[opName](this) }
-  or (num: BigNumber): BigNumber { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuor') }
-  uor (num: BigNumber): BigNumber { return this._uop_new(num, 'iuor') }
-  and (num: BigNumber): BigNumber { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuand') }
-  uand (num: BigNumber): BigNumber { return this._uop_new(num, 'iuand') }
-  xor (num: BigNumber): BigNumber { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuxor') }
-  uxor (num: BigNumber): BigNumber { return this._uop_new(num, 'iuxor') }
-
-  inotn (width: number): this {
-    this.assert(typeof width === 'number' && width >= 0)
-    const Bw = BigInt(width)
-    const m = (1n << Bw) - 1n
-    this._magnitude = (~this._magnitude) & m
-    const wfw = width === 0 ? 1 : Math.ceil(width / BigNumber.wordSize)
-    this._nominalWordLength = Math.max(1, wfw)
-    this.strip()
-    this._nominalWordLength = Math.max(this._nominalWordLength, Math.max(1, wfw))
-    return this
-  }
-
-  notn (width: number): BigNumber { return this.clone().inotn(width) }
-  setn (bit: number, val: any): this { this.assert(typeof bit === 'number' && bit >= 0); const Bb = BigInt(bit); if (val === 1 || val === true) this._magnitude |= (1n << Bb); else this._magnitude &= ~(1n << Bb); const wnb = Math.floor(bit / BigNumber.wordSize) + 1; this._nominalWordLength = Math.max(this._nominalWordLength, wnb); this._finishInitialization(); return this.strip() }
-
-  iadd (num: BigNumber): this { this._setValueFromSigned(this._getSignedValue() + num._getSignedValue()); return this }
-  add (num: BigNumber): BigNumber { const r = new BigNumber(0n); r._setValueFromSigned(this._getSignedValue() + num._getSignedValue()); return r }
-  isub (num: BigNumber): this { this._setValueFromSigned(this._getSignedValue() - num._getSignedValue()); return this }
-  sub (num: BigNumber): BigNumber { const r = new BigNumber(0n); r._setValueFromSigned(this._getSignedValue() - num._getSignedValue()); return r }
-  mul (num: BigNumber): BigNumber {
-    const r = new BigNumber(0n)
-    r._magnitude = this._magnitude * num._magnitude
-    r._sign = r._magnitude === 0n ? 0 : ((this._sign ^ num._sign) as 0 | 1)
-    r._nominalWordLength = this.length + num.length
-    r.red = null
-    return r.normSign()
-  }
-
-  imul (num: BigNumber): this {
-    this._magnitude *= num._magnitude
-    this._sign = this._magnitude === 0n ? 0 : ((this._sign ^ num._sign) as 0 | 1)
-    this._nominalWordLength = this.length + num.length
-    this.red = null
-    return this.normSign()
-  }
-
-  imuln (num: number): this { this.assert(typeof num === 'number', 'Assertion failed'); this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, 'Assertion failed'); this._setValueFromSigned(this._getSignedValue() * BigInt(num)); return this }
-  muln (num: number): BigNumber { return this.clone().imuln(num) }
-  sqr (): BigNumber {
-    const r = new BigNumber(0n)
-    r._magnitude = this._magnitude * this._magnitude
-    r._sign = 0
-    r._nominalWordLength = this.length * 2
-    r.red = null
-    return r
-  }
-
-  isqr (): this {
-    this._magnitude *= this._magnitude
-    this._sign = 0
-    this._nominalWordLength = this.length * 2
-    this.red = null
-    return this
-  }
-
-  pow (num: BigNumber): BigNumber {
-    this.assert(num._sign === 0, 'Exponent for pow must be non-negative')
-    if (num.isZero()) return new BigNumber(1n)
-
-    const res = new BigNumber(1n)
-    const currentBase = this.clone()
-    const exp = num.clone()
-
-    const baseIsNegative = currentBase.isNeg()
-    const expIsOdd = exp.isOdd()
-    if (baseIsNegative) currentBase.ineg()
-
-    while (!exp.isZero()) {
-      if (exp.isOdd()) {
-        res.imul(currentBase)
-      }
-      currentBase.isqr()
-      exp.iushrn(1)
-    }
-
-    if (baseIsNegative && expIsOdd) {
-      res.ineg()
-    }
-    return res
-  }
-
-  private static normalizeNonNegativeBigInt (value: number | bigint, label: string): bigint {
-    if (typeof value === 'number') {
-      if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer`)
-      return BigInt(value)
-    }
-    if (value < 0n) throw new Error(`${label} must be a non-negative integer`)
-    return value
-  }
-
-  iushln (bits: number | bigint): this {
-    const normalizedBits = BigNumber.normalizeNonNegativeBigInt(bits, 'Shift bits')
-    if (normalizedBits === 0n) return this
-    this._magnitude <<= normalizedBits
-    this._finishInitialization()
-    return this.strip()
-  }
-
-  ishln (bits: number | bigint): this {
-    this.assert(this._sign === 0, 'ishln requires positive number')
-    return this.iushln(bits)
-  }
-
-  iushrn (bits: number | bigint, hint?: number, extended?: BigNumber): this {
-    const normalizedBits = BigNumber.normalizeNonNegativeBigInt(bits, 'Shift bits')
-    if (normalizedBits === 0n) {
-      if (extended != null) extended._initializeState(0n, 0)
-      return this
-    }
-    if (extended != null) {
-      const m = (1n << normalizedBits) - 1n
-      const sOut = this._magnitude & m
-      extended._initializeState(sOut, 0)
-    }
-    this._magnitude >>= normalizedBits
-    this._finishInitialization()
-    return this.strip()
-  }
-
-  ishrn (bits: number | bigint, hint?: number, extended?: BigNumber): this {
-    this.assert(this._sign === 0, 'ishrn requires positive number')
-    return this.iushrn(bits, hint, extended)
-  }
-
-  shln (bits: number | bigint): BigNumber { return this.clone().ishln(bits) }
-  ushln (bits: number | bigint): BigNumber { return this.clone().iushln(bits) }
-  shrn (bits: number | bigint): BigNumber { return this.clone().ishrn(bits) }
-  ushrn (bits: number | bigint): BigNumber { return this.clone().iushrn(bits) }
-
-  testn (bit: number): boolean {
-    this.assert(typeof bit === 'number' && bit >= 0)
-    return ((this._magnitude >> BigInt(bit)) & 1n) !== 0n
-  }
-
-  imaskn (bits: number): this {
-    this.assert(typeof bits === 'number' && bits >= 0)
-    this.assert(this._sign === 0, 'imaskn works only with positive numbers')
-    const Bb = BigInt(bits)
-    const m = Bb === 0n ? 0n : (1n << Bb) - 1n
-    this._magnitude &= m
-    const wfm = bits === 0 ? 1 : Math.max(1, Math.ceil(bits / BigNumber.wordSize))
-    this._nominalWordLength = wfm
-    this._finishInitialization()
-    this._nominalWordLength = Math.max(this._nominalWordLength, wfm)
-    return this.strip()
-  }
-
-  maskn (bits: number): BigNumber { return this.clone().imaskn(bits) }
-  iaddn (num: number): this { this.assert(typeof num === 'number'); this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, 'num is too large'); this._setValueFromSigned(this._getSignedValue() + BigInt(num)); return this }
-  _iaddn (num: number): this { return this.iaddn(num) }
-  isubn (num: number): this { this.assert(typeof num === 'number'); this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, 'Assertion failed'); this._setValueFromSigned(this._getSignedValue() - BigInt(num)); return this }
-  addn (num: number): BigNumber { return this.clone().iaddn(num) } subn (num: number): BigNumber { return this.clone().isubn(num) }
-  iabs (): this { this._sign = 0; return this } abs (): BigNumber { return this.clone().iabs() }
-
-  divmod (num: BigNumber, mode?: 'div' | 'mod', positive?: boolean): any {
-    this.assert(!num.isZero(), 'Division by zero')
-    if (this.isZero()) {
-      const z = new BigNumber(0n)
-      return { div: mode !== 'mod' ? z : null, mod: mode !== 'div' ? z : null }
-    }
-    const tV = this._getSignedValue()
-    const nV = num._getSignedValue()
-    let dV: bigint | null = null
-    let mV: bigint | null = null
-    if (mode !== 'mod') dV = tV / nV
-    if (mode !== 'div') {
-      mV = tV % nV
-      if (positive === true && mV < 0n) mV += nV < 0n ? -nV : nV
-    }
-    const rd = dV !== null ? new BigNumber(0n) : null
-    if (rd !== null && dV !== null) rd._setValueFromSigned(dV)
-    const rm = mV !== null ? new BigNumber(0n) : null
-    if (rm !== null && mV !== null) rm._setValueFromSigned(mV)
-    return { div: rd, mod: rm }
-  }
-
-  div (num: BigNumber): BigNumber {
-    return this.divmod(num, 'div', false).div as BigNumber
-  }
-
-  mod (num: BigNumber): BigNumber {
-    return this.divmod(num, 'mod', false).mod as BigNumber
-  }
-
-  umod (num: BigNumber): BigNumber {
-    return this.divmod(num, 'mod', true).mod as BigNumber
-  }
-
-  divRound (num: BigNumber): BigNumber {
-    this.assert(!num.isZero())
-    const tV = this._getSignedValue()
-    const nV = num._getSignedValue()
-
-    let d = tV / nV
-    const m = tV % nV
-
-    if (m === 0n) {
-      const r = new BigNumber(0n); r._setValueFromSigned(d); return r
-    }
-
-    const absM = m < 0n ? -m : m
-    const absNV = nV < 0n ? -nV : nV
-
-    if (absM * 2n >= absNV) {
-      if ((tV > 0n && nV > 0n) || (tV < 0n && nV < 0n)) {
-        d += 1n
-      } else {
-        d -= 1n
-      }
-    }
-    const r = new BigNumber(0n); r._setValueFromSigned(d); return r
-  }
-
-  modrn (numArg: number): number {
-    this.assert(numArg !== 0, 'Division by zero in modrn')
-    const absDivisor = BigInt(Math.abs(numArg))
-    if (absDivisor === 0n) throw new Error('Division by zero in modrn')
-
-    const remainderMag = this._magnitude % absDivisor
-    return numArg < 0 ? Number(-remainderMag) : Number(remainderMag)
-  }
-
-  idivn (num: number): this {
-    this.assert(num !== 0)
-    this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, 'num is too large')
-    this._setValueFromSigned(this._getSignedValue() / BigInt(num))
-    return this
-  }
-
-  divn (num: number): BigNumber { return this.clone().idivn(num) }
-
-  egcd (p: BigNumber): { a: BigNumber, b: BigNumber, gcd: BigNumber } {
-    this.assert(p._sign === 0, 'p must not be negative')
-    this.assert(!p.isZero(), 'p must not be zero')
-    let uV = this._getSignedValue()
-    let vV = p._magnitude; let a = 1n; let pa = 0n
-    let b = 0n
-    let pb = 1n
-    while (vV !== 0n) {
-      const q = uV / vV
-      let t = vV
-      vV = uV % vV
-      uV = t
-      t = pa
-      pa = a - q * pa
-      a = t
-      t = pb
-      pb = b - q * pb
-      b = t
-    }
-    const ra = new BigNumber(0n)
-    ra._setValueFromSigned(a)
-    const rb = new BigNumber(0n)
-    rb._setValueFromSigned(b)
-    const rg = new BigNumber(0n)
-    rg._initializeState(uV < 0n ? -uV : uV, 0)
-    return { a: ra, b: rb, gcd: rg }
-  }
-
-  gcd (num: BigNumber): BigNumber {
-    let u = this._magnitude
-    let v = num._magnitude
-    if (u === 0n) {
-      const r = new BigNumber(0n)
-      r._setValueFromSigned(v)
-      return r.iabs()
-    }
-    if (v === 0n) {
-      const r = new BigNumber(0n)
-      r._setValueFromSigned(u)
-      return r.iabs()
-    }
-    while (v !== 0n) {
-      const t = u % v
-      u = v
-      v = t
-    }
-    const res = new BigNumber(0n)
-    res._initializeState(u, 0)
-    return res
-  }
-
-  invm (num: BigNumber): BigNumber {
-    this.assert(!num.isZero() && num._sign === 0, 'Modulus for invm must be positive and non-zero')
-    const eg = this.egcd(num)
-    if (!eg.gcd.eqn(1)) {
-      throw new Error('Inverse does not exist (numbers are not coprime).')
-    }
-    return eg.a.umod(num)
-  }
-
-  isEven (): boolean { return this._magnitude % 2n === 0n } isOdd (): boolean { return this._magnitude % 2n === 1n }
-  andln (num: number): number { this.assert(num >= 0); return Number(this._magnitude & BigInt(num)) }
-  bincn (bit: number): this { this.assert(typeof bit === 'number' && bit >= 0); const BVal = 1n << BigInt(bit); this._setValueFromSigned(this._getSignedValue() + BVal); return this }
-  isZero (): boolean { return this._magnitude === 0n }
-  cmpn (num: number): 1 | 0 | -1 { this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, 'Number is too big'); const tV = this._getSignedValue(); const nV = BigInt(num); if (tV < nV) return -1; if (tV > nV) return 1; return 0 }
-  cmp (num: BigNumber): 1 | 0 | -1 { const tV = this._getSignedValue(); const nV = num._getSignedValue(); if (tV < nV) return -1; if (tV > nV) return 1; return 0 }
-  ucmp (num: BigNumber): 1 | 0 | -1 { if (this._magnitude < num._magnitude) return -1; if (this._magnitude > num._magnitude) return 1; return 0 }
-  gtn (num: number): boolean { return this.cmpn(num) === 1 } gt (num: BigNumber): boolean { return this.cmp(num) === 1 } gten (num: number): boolean { return this.cmpn(num) >= 0 } gte (num: BigNumber): boolean { return this.cmp(num) >= 0 }
-  ltn (num: number): boolean { return this.cmpn(num) === -1 } lt (num: BigNumber): boolean { return this.cmp(num) === -1 } lten (num: number): boolean { return this.cmpn(num) <= 0 } lte (num: BigNumber): boolean { return this.cmp(num) <= 0 }
-  eqn (num: number): boolean { return this.cmpn(num) === 0 } eq (num: BigNumber): boolean { return this.cmp(num) === 0 }
-
-  toRed (ctx: ReductionContext): BigNumber { this.assert(this.red == null, 'Already a number in reduction context'); this.assert(this._sign === 0, 'toRed works only with positives'); return ctx.convertTo(this).forceRed(ctx) }
-  fromRed (): BigNumber { this.assert(this.red, 'fromRed works only with numbers in reduction context'); return this.red.convertFrom(this) }
-  forceRed (ctx: ReductionContext): this { this.red = ctx; return this }
-  redAdd (num: BigNumber): BigNumber { this.assert(this.red, 'redAdd works only with red numbers'); return this.red.add(this, num) }
-  redIAdd (num: BigNumber): BigNumber { this.assert(this.red, 'redIAdd works only with red numbers'); return this.red.iadd(this, num) }
-  redSub (num: BigNumber): BigNumber { this.assert(this.red, 'redSub works only with red numbers'); return this.red.sub(this, num) }
-  redISub (num: BigNumber): BigNumber { this.assert(this.red, 'redISub works only with red numbers'); return this.red.isub(this, num) }
-  redShl (num: number): BigNumber { this.assert(this.red, 'redShl works only with red numbers'); return this.red.shl(this, num) }
-  redMul (num: BigNumber): BigNumber { this.assert(this.red, 'redMul works only with red numbers'); this.red.verify2(this, num); return this.red.mul(this, num) }
-  redIMul (num: BigNumber): BigNumber { this.assert(this.red, 'redIMul works only with red numbers'); this.red.verify2(this, num); return this.red.imul(this, num) }
-  redSqr (): BigNumber { this.assert(this.red, 'redSqr works only with red numbers'); this.red.verify1(this); return this.red.sqr(this) }
-  redISqr (): BigNumber { this.assert(this.red, 'redISqr works only with red numbers'); this.red.verify1(this); return this.red.isqr(this) }
-  redSqrt (): BigNumber { this.assert(this.red, 'redSqrt works only with red numbers'); this.red.verify1(this); return this.red.sqrt(this) }
-  redInvm (): BigNumber { this.assert(this.red, 'redInvm works only with red numbers'); this.red.verify1(this); return this.red.invm(this) }
-  redNeg (): BigNumber { this.assert(this.red, 'redNeg works only with red numbers'); this.red.verify1(this); return this.red.neg(this) }
-  redPow (num: BigNumber): BigNumber { this.assert(this.red != null && num.red == null, 'redPow(normalNum)'); this.red.verify1(this); return this.red.pow(this, num) }
-
-  /**
-   * Creates a BigNumber from a hexadecimal string.
-   *
-   * @static
-   * @method fromHex
-   * @param hex - The hexadecimal string to create a BigNumber from.
-   * @param endian - Optional endianness for parsing the hex string.
-   * @returns Returns a BigNumber created from the hexadecimal input string.
-   *
-   * @example
-   * const exampleHex = 'a1b2c3';
-   * const bigNumber = BigNumber.fromHex(exampleHex);
-   */
-  static fromHex (hex: string, endian?: 'le' | 'be' | 'little' | 'big'): BigNumber {
-    let eE: 'le' | 'be' = 'be'
-    if (endian === 'little' || endian === 'le') eE = 'le'
-    return new BigNumber(hex, 16, eE)
-  }
-
-  /**
-   * Converts this BigNumber to a hexadecimal string.
-   *
-   * @method toHex
-   * @param length - The minimum length of the hex string
-   * @returns Returns a string representing the hexadecimal value of this BigNumber.
-   *
-   * @example
-   * const bigNumber = new BigNumber(255)
-   * const hex = bigNumber.toHex()
-   */
-  toHex (byteLength: number = 0): string {
-    if (this.isZero() && byteLength === 0) return ''
-
-    let hexStr = this._getMinimalHex() // Raw hex: "0", "f", "10", "123"
-
-    // Ensure even length for non-zero values (byte alignment)
-    if (hexStr !== '0' && hexStr.length % 2 !== 0) {
-      hexStr = '0' + hexStr
-    }
-
-    // Pad to minimum character length (byteLength * 2)
-    const minChars = byteLength * 2
-    while (hexStr.length < minChars) {
-      hexStr = '0' + hexStr
-    }
-    return (this.isNeg() ? '-' : '') + hexStr
-  }
-
-  /**
-   * Creates a BigNumber from a JSON-serialized string.
-   *
-   * @static
-   * @method fromJSON
-   * @param str - The JSON-serialized string to create a BigNumber from.
-   * @returns Returns a BigNumber created from the JSON input string.
-   */
-  static fromJSON (str: string): BigNumber { return new BigNumber(str, 16) }
-
-  /**
-   * Creates a BigNumber from a number.
-   *
-   * @static
-   * @method fromNumber
-   * @param n - The number to create a BigNumber from.
-   * @returns Returns a BigNumber equivalent to the input number.
-   */
-  static fromNumber (n: number): BigNumber { return new BigNumber(n) }
-
-  /**
-   * Creates a BigNumber from a string, considering an optional base.
-   *
-   * @static
-   * @method fromString
-   * @param str - The string to create a BigNumber from.
-   * @param base - The base used for conversion. If not provided, base 10 is assumed.
-   * @returns Returns a BigNumber equivalent to the string after conversion from the specified base.
-   */
-  static fromString (str: string, base?: number | 'hex'): BigNumber { return new BigNumber(str, base) }
-
-  /**
-   * Creates a BigNumber from a signed magnitude number.
-   *
-   * @static
-   * @method fromSm
-   * @param bytes - The signed magnitude number to convert to a BigNumber.
-   * @param endian - Defines endianess. If not provided, big endian is assumed.
-   * @returns Returns a BigNumber equivalent to the signed magnitude number interpreted with specified endianess.
-   */
-  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
-    if (beBytes.length > 0 && (beBytes[0] & 0x80) !== 0) {
-      sign = 1
-      beBytes[0] &= 0x7f
-    }
-
-    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 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 r = new BigNumber(0n)
-    r._initializeState(magnitude, sign)
-    return r
-  }
-
-  /**
-   * Converts this BigNumber to a signed magnitude number.
-   *
-   * @method toSm
-   * @param endian - Defines endianess. If not provided, big endian is assumed.
-   * @returns Returns an array equivalent to this BigNumber interpreted as a signed magnitude with specified endianess.
-   */
-  toSm (endian: 'big' | 'little' = 'big'): number[] {
-    if (this._magnitude === 0n) {
-      return this._sign === 1 ? [0x80] : []
-    }
-
-    let hex = this._getMinimalHex()
-    if (hex.length % 2 !== 0) hex = '0' + hex
-
-    const byteLen = hex.length / 2
-    const bytes = new Array(byteLen)
-    for (let i = 0, j = 0; i < hex.length; i += 2) {
-      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) {
-        result = [0x80, ...bytes]
-      } else {
-        result = bytes.slice()
-        result[0] |= 0x80
-      }
-    } else if ((bytes[0] & 0x80) !== 0) {
-      result = [0x00, ...bytes]
-    } else {
-      result = bytes.slice()
-    }
-
-    return endian === 'little' ? result.reverse() : result
-  }
-
-  /**
-   * Creates a BigNumber from a number representing the "bits" value in a block header.
-   *
-   * @static
-   * @method fromBits
-   * @param bits - The number representing the bits value in a block header.
-   * @param strict - If true, an error is thrown if the number has negative bit set.
-   * @returns Returns a BigNumber equivalent to the "bits" value in a block header.
-   * @throws Will throw an error if `strict` is `true` and the number has negative bit set.
-   */
-  static fromBits (bits: number, strict: boolean = false): BigNumber {
-    const nSize = bits >>> 24
-    const nWordCompact = bits & 0x007fffff
-    const isNegativeFromBit = (bits & 0x00800000) !== 0
-
-    if (strict && isNegativeFromBit) {
-      throw new Error('negative bit set')
-    }
-
-    if (nSize === 0 && nWordCompact === 0) {
-      if (isNegativeFromBit && strict) throw new Error('negative bit set for zero value')
-      return new BigNumber(0n)
-    }
-
-    const bn = new BigNumber(nWordCompact)
-
-    // This logic comes from original bn.js `fromCompact`
-    if (nSize <= 3) {
-      bn.iushrn((3 - nSize) * 8)
-    } else {
-      bn.iushln((nSize - 3) * 8)
-    }
-
-    if (isNegativeFromBit) {
-      bn.ineg()
-    }
-    return bn
-  }
-
-  /**
-   * Converts this BigNumber to a number representing the "bits" value in a block header.
-   *
-   * @method toBits
-   * @returns Returns a number equivalent to the "bits" value in a block header.
-   */
-  toBits (): number {
-    this.strip()
-    if (this.isZero() && !this.isNeg()) return 0
-
-    const isActualNegative = this.isNeg()
-    const bnAbs = this.abs() // Work with absolute value for magnitude
-
-    // Get byte array of absolute value
-    let mB = bnAbs.toArray('be') // Minimal byte array
-
-    // Remove leading zeros from byte array, if any (toArray('be') might already do this if no length specified)
-    let firstNonZeroIdx = 0
-    while (firstNonZeroIdx < mB.length - 1 && mB[firstNonZeroIdx] === 0) { // Keep last byte if it's [0]
-      firstNonZeroIdx++
-    }
-    mB = mB.slice(firstNonZeroIdx)
-
-    let nSize = mB.length
-    if (nSize === 0 && !bnAbs.isZero()) { // Should not happen if bnAbs is truly non-zero and toArray is correct
-      mB = [0] // Should not be needed if toArray works for small numbers
-      nSize = 1
-    }
-    if (bnAbs.isZero()) { // if original was, e.g., -0, bnAbs is 0.
-      nSize = 0 // Size for 0 is 0, unless it's negative 0 to be encoded
-      mB = []
-    }
-
-    let nWordNum
-    if (nSize === 0) {
-      nWordNum = 0
-    } else if (nSize <= 3) {
-      nWordNum = 0
-      for (let i = 0; i < nSize; i++) {
-        nWordNum = (nWordNum << 8) | mB[i]
-      }
-    } else { // nSize > 3
-      nWordNum = (mB[0] << 16) | (mB[1] << 8) | mB[2]
-    }
-
-    if ((nWordNum & 0x00800000) !== 0 && nSize <= 0xff) { // MSB of 3-byte mantissa is set
-      nWordNum >>>= 8 // Shift mantissa over by one byte
-      nSize++ // Increase size component by one
-    }
-
-    let b = (nSize << 24) | nWordNum
-    if (isActualNegative) b |= 0x00800000
-    return b >>> 0
-  }
-
-  /**
-   * Creates a BigNumber from the format used in Bitcoin scripts.
-   *
-   * @static
-   * @method fromScriptNum
-   * @param num - The number in the format used in Bitcoin scripts.
-   * @param requireMinimal - If true, non-minimally encoded values will throw an error.
-   * @param maxNumSize - The maximum allowed size for the number.
-   * @returns Returns a BigNumber equivalent to the number used in a Bitcoin script.
-   */
-  static fromScriptNum (
-    num: number[],
-    requireMinimal: boolean = false,
-    maxNumSize?: number
-  ): BigNumber {
-    if (maxNumSize !== undefined && num.length > maxNumSize) throw new Error('script number overflow')
-    if (num.length === 0) return new BigNumber(0n)
-    if (requireMinimal) {
-      if ((num[num.length - 1] & 0x7f) === 0) {
-        if (num.length <= 1 || (num[num.length - 2] & 0x80) === 0) {
-          throw new Error('non-minimally encoded script number')
-        }
-      }
-    }
-    return BigNumber.fromSm(num, 'little')
-  }
-
-  /**
-   * Converts this BigNumber to a number in the format used in Bitcoin scripts.
-   *
-   * @method toScriptNum
-   * @returns Returns the equivalent to this BigNumber as a Bitcoin script number.
-   */
-  toScriptNum (): number[] { return this.toSm('little') }
-
-  /**
-   * Compute the multiplicative inverse of the current BigNumber in the modulus field specified by `p`.
-   * The multiplicative inverse is a number which when multiplied with the current BigNumber gives '1' in the modulus field.
-   *
-   * @method _invmp
-   * @param p - The `BigNumber` specifying the modulus field.
-   * @returns The multiplicative inverse `BigNumber` in the modulus field specified by `p`.
-   */
-  _invmp (p: BigNumber): BigNumber {
-    this.assert(p._sign === 0, 'p must not be negative for _invmp')
-    this.assert(!p.isZero(), 'p must not be zero for _invmp')
-
-    const aBN: BigNumber = this.umod(p)
-
-    let aVal = aBN._magnitude
-    let bVal = p._magnitude
-    let x1Val = 1n
-    let x2Val = 0n
-    const modulus = p._magnitude
-
-    while (aVal > 1n && bVal > 1n) {
-      let i = 0; while (((aVal >> BigInt(i)) & 1n) === 0n) i++
-      if (i > 0) {
-        aVal >>= BigInt(i)
-        for (let k = 0; k < i; ++k) { if ((x1Val & 1n) !== 0n) x1Val += modulus; x1Val >>= 1n }
-      }
-
-      let j = 0; while (((bVal >> BigInt(j)) & 1n) === 0n) j++
-      if (j > 0) {
-        bVal >>= BigInt(j)
-        for (let k = 0; k < j; ++k) { if ((x2Val & 1n) !== 0n) x2Val += modulus; x2Val >>= 1n }
-      }
-
-      if (aVal >= bVal) { aVal -= bVal; x1Val -= x2Val } else { bVal -= aVal; x2Val -= x1Val }
-    }
-
-    let resultVal: bigint
-    if (aVal === 1n) resultVal = x1Val
-    else if (bVal === 1n) resultVal = x2Val
-    else if (aVal === 0n && bVal === 1n) resultVal = x2Val
-    else if (bVal === 0n && aVal === 1n) resultVal = x1Val
-    else throw new Error('_invmp: GCD is not 1, inverse does not exist. aVal=' + aVal + ', bVal=' + bVal)
-
-    resultVal %= modulus
-    if (resultVal < 0n) resultVal += modulus
-
-    const resultBN = new BigNumber(0n)
-    resultBN._initializeState(resultVal, 0)
-    return resultBN
-  }
-
-  /**
-   * Performs multiplication between the BigNumber instance and a given BigNumber.
-   * It chooses the multiplication method based on the lengths of the numbers to optimize execution time.
-   *
-   * @method mulTo
-   * @param num - The BigNumber multiply with.
-   * @param out - The BigNumber where to store the result.
-   * @returns The BigNumber resulting from the multiplication operation.
-   */
-  mulTo (num: BigNumber, out: BigNumber): BigNumber {
-    out._magnitude = this._magnitude * num._magnitude
-    out._sign = out._magnitude === 0n ? 0 : ((this._sign ^ num._sign) as 0 | 1)
-    out._nominalWordLength = this.length + num.length
-    out.red = null
-    out.normSign()
-    return out
-  }
-}