@bsv/wallet-toolbox 1.7.13 → 1.7.15

package/mobile/node_modules/@bsv/sdk/dist/esm/src/primitives/BigNumber.js

@@ -0,0 +1,1373 @@
+const BufferCtor = typeof globalThis !== 'undefined' ? globalThis.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
+     */
+    static zeros = [
+        '', '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 groupSizes = [
+        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 groupBases = [
+        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 wordSize = 26;
+    static WORD_SIZE_BIGINT = BigInt(BigNumber.wordSize);
+    static WORD_MASK = (1n << BigNumber.WORD_SIZE_BIGINT) - 1n;
+    static MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    static MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+    static MAX_IMULN_ARG = 0x4000000 - 1;
+    static MAX_NUMBER_CONSTRUCTOR_MAG_BIGINT = (1n << 53n) - 1n;
+    _magnitude;
+    _sign;
+    _nominalWordLength;
+    /**
+     * Reduction context of the big number.
+     *
+     * @property red
+     */
+    red;
+    /**
+     * 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
+     */
+    get negative() {
+        return this._sign;
+    }
+    /**
+     * Sets the negative flag. Only 0 (positive) or 1 (negative) are allowed.
+     */
+    set negative(val) {
+        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;
+        }
+    }
+    get _computedWordsArray() {
+        if (this._magnitude === 0n)
+            return [0];
+        const arr = [];
+        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
+     */
+    get words() {
+        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.
+     */
+    set words(newWords) {
+        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
+     */
+    get length() {
+        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) {
+        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, right) { 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, right) { 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 = 0, base = 10, endian = '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 = base;
+        let effectiveEndian = 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;
+                if (effectiveEndian === 'le') {
+                    const bytes = [];
+                    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;
+                    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);
+        }
+    }
+    _bigIntToStringInBase(num, base) {
+        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;
+    }
+    _parseBaseString(numberStr, base) {
+        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();
+    }
+    _parseBaseWord(str, base) {
+        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;
+    }
+    _initializeState(magnitude, sign) {
+        this._magnitude = magnitude;
+        this._sign = (magnitude === 0n) ? 0 : sign;
+        this._finishInitialization();
+    }
+    _finishInitialization() {
+        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));
+        }
+    }
+    assert(val, msg = 'Assertion failed') { if (!val)
+        throw new Error(msg); }
+    initNumber(number, endian = 'be') {
+        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;
+    }
+    initArray(bytes, endian) {
+        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) { dest._magnitude = this._magnitude; dest._sign = this._sign; dest._nominalWordLength = this._nominalWordLength; dest.red = this.red; }
+    static move(dest, src) { dest._magnitude = src._magnitude; dest._sign = src._sign; dest._nominalWordLength = src._nominalWordLength; dest.red = src.red; }
+    clone() { const r = new BigNumber(0n); this.copy(r); return r; }
+    expand(size) {
+        this.assert(size >= 0, 'Expand size must be non-negative');
+        this._nominalWordLength = Math.max(this._nominalWordLength, size, 1);
+        return this;
+    }
+    strip() { this._finishInitialization(); return this.normSign(); }
+    normSign() { if (this._magnitude === 0n)
+        this._sign = 0; return this; }
+    inspect() { return (this.red !== null ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>'; }
+    _getMinimalHex() {
+        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 = 10, padding = 1) {
+        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);
+    }
+    toBaseString(base, padding) {
+        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() {
+        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() {
+        return this._getSignedValue();
+    }
+    /**
+     * Converts the BigNumber instance to a JSON-formatted string.
+     *
+     * @method toJSON
+     * @returns The JSON string representation of the BigNumber instance.
+     */
+    toJSON() {
+        const hex = this._getMinimalHex();
+        return (this.isNeg() ? '-' : '') + hex;
+    }
+    toArrayLikeGeneric(res, isLE) {
+        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 = 'be', length) {
+        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() { 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) {
+        const len = num.bitLength();
+        if (len === 0)
+            return [];
+        const w = new Array(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() { 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() {
+        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() { if (this._magnitude === 0n)
+        return 0; return Math.ceil(this.bitLength() / 8); }
+    _getSignedValue() { return this._sign === 1 ? -this._magnitude : this._magnitude; }
+    _setValueFromSigned(sVal) {
+        if (sVal < 0n) {
+            this._magnitude = -sVal;
+            this._sign = 1;
+        }
+        else {
+            this._magnitude = sVal;
+            this._sign = 0;
+        }
+        this._finishInitialization();
+        this.normSign();
+    }
+    toTwos(width) {
+        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) {
+        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() { return this._sign === 1 && this._magnitude !== 0n; }
+    neg() { return this.clone().ineg(); }
+    ineg() { if (this._magnitude !== 0n)
+        this._sign = this._sign === 1 ? 0 : 1; return this; }
+    _iuop(num, op) {
+        const newMag = op(this._magnitude, num._magnitude);
+        const isXor = op === ((a, b) => 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) { return this._iuop(num, (a, b) => a | b); }
+    iuand(num) { return this._iuop(num, (a, b) => a & b); }
+    iuxor(num) { return this._iuop(num, (a, b) => a ^ b); }
+    _iop(num, op) { this.assert(this._sign === 0 && num._sign === 0); return this._iuop(num, op); }
+    ior(num) { return this._iop(num, (a, b) => a | b); }
+    iand(num) { return this._iop(num, (a, b) => a & b); }
+    ixor(num) { return this._iop(num, (a, b) => a ^ b); }
+    _uop_new(num, opName) { if (this.length >= num.length)
+        return this.clone()[opName](num); return num.clone()[opName](this); }
+    or(num) { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuor'); }
+    uor(num) { return this._uop_new(num, 'iuor'); }
+    and(num) { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuand'); }
+    uand(num) { return this._uop_new(num, 'iuand'); }
+    xor(num) { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuxor'); }
+    uxor(num) { return this._uop_new(num, 'iuxor'); }
+    inotn(width) {
+        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) { return this.clone().inotn(width); }
+    setn(bit, val) { 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) { this._setValueFromSigned(this._getSignedValue() + num._getSignedValue()); return this; }
+    add(num) { const r = new BigNumber(0n); r._setValueFromSigned(this._getSignedValue() + num._getSignedValue()); return r; }
+    isub(num) { this._setValueFromSigned(this._getSignedValue() - num._getSignedValue()); return this; }
+    sub(num) { const r = new BigNumber(0n); r._setValueFromSigned(this._getSignedValue() - num._getSignedValue()); return r; }
+    mul(num) {
+        const r = new BigNumber(0n);
+        r._magnitude = this._magnitude * num._magnitude;
+        r._sign = r._magnitude === 0n ? 0 : (this._sign ^ num._sign);
+        r._nominalWordLength = this.length + num.length;
+        r.red = null;
+        return r.normSign();
+    }
+    imul(num) {
+        this._magnitude *= num._magnitude;
+        this._sign = this._magnitude === 0n ? 0 : (this._sign ^ num._sign);
+        this._nominalWordLength = this.length + num.length;
+        this.red = null;
+        return this.normSign();
+    }
+    imuln(num) { 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) { return this.clone().imuln(num); }
+    sqr() {
+        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._magnitude *= this._magnitude;
+        this._sign = 0;
+        this._nominalWordLength = this.length * 2;
+        this.red = null;
+        return this;
+    }
+    pow(num) {
+        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;
+    }
+    static normalizeNonNegativeBigInt(value, label) {
+        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) {
+        const normalizedBits = BigNumber.normalizeNonNegativeBigInt(bits, 'Shift bits');
+        if (normalizedBits === 0n)
+            return this;
+        this._magnitude <<= normalizedBits;
+        this._finishInitialization();
+        return this.strip();
+    }
+    ishln(bits) {
+        this.assert(this._sign === 0, 'ishln requires positive number');
+        return this.iushln(bits);
+    }
+    iushrn(bits, hint, extended) {
+        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, hint, extended) {
+        this.assert(this._sign === 0, 'ishrn requires positive number');
+        return this.iushrn(bits, hint, extended);
+    }
+    shln(bits) { return this.clone().ishln(bits); }
+    ushln(bits) { return this.clone().iushln(bits); }
+    shrn(bits) { return this.clone().ishrn(bits); }
+    ushrn(bits) { return this.clone().iushrn(bits); }
+    testn(bit) {
+        this.assert(typeof bit === 'number' && bit >= 0);
+        return ((this._magnitude >> BigInt(bit)) & 1n) !== 0n;
+    }
+    imaskn(bits) {
+        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) { return this.clone().imaskn(bits); }
+    iaddn(num) { 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) { return this.iaddn(num); }
+    isubn(num) { 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) { return this.clone().iaddn(num); }
+    subn(num) { return this.clone().isubn(num); }
+    iabs() { this._sign = 0; return this; }
+    abs() { return this.clone().iabs(); }
+    divmod(num, mode, positive) {
+        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 = null;
+        let mV = 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) {
+        return this.divmod(num, 'div', false).div;
+    }
+    mod(num) {
+        return this.divmod(num, 'mod', false).mod;
+    }
+    umod(num) {
+        return this.divmod(num, 'mod', true).mod;
+    }
+    divRound(num) {
+        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) {
+        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) {
+        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) { return this.clone().idivn(num); }
+    egcd(p) {
+        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) {
+        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) {
+        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() { return this._magnitude % 2n === 0n; }
+    isOdd() { return this._magnitude % 2n === 1n; }
+    andln(num) { this.assert(num >= 0); return Number(this._magnitude & BigInt(num)); }
+    bincn(bit) { this.assert(typeof bit === 'number' && bit >= 0); const BVal = 1n << BigInt(bit); this._setValueFromSigned(this._getSignedValue() + BVal); return this; }
+    isZero() { return this._magnitude === 0n; }
+    cmpn(num) { 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) { const tV = this._getSignedValue(); const nV = num._getSignedValue(); if (tV < nV)
+        return -1; if (tV > nV)
+        return 1; return 0; }
+    ucmp(num) { if (this._magnitude < num._magnitude)
+        return -1; if (this._magnitude > num._magnitude)
+        return 1; return 0; }
+    gtn(num) { return this.cmpn(num) === 1; }
+    gt(num) { return this.cmp(num) === 1; }
+    gten(num) { return this.cmpn(num) >= 0; }
+    gte(num) { return this.cmp(num) >= 0; }
+    ltn(num) { return this.cmpn(num) === -1; }
+    lt(num) { return this.cmp(num) === -1; }
+    lten(num) { return this.cmpn(num) <= 0; }
+    lte(num) { return this.cmp(num) <= 0; }
+    eqn(num) { return this.cmpn(num) === 0; }
+    eq(num) { return this.cmp(num) === 0; }
+    toRed(ctx) { 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() { this.assert(this.red, 'fromRed works only with numbers in reduction context'); return this.red.convertFrom(this); }
+    forceRed(ctx) { this.red = ctx; return this; }
+    redAdd(num) { this.assert(this.red, 'redAdd works only with red numbers'); return this.red.add(this, num); }
+    redIAdd(num) { this.assert(this.red, 'redIAdd works only with red numbers'); return this.red.iadd(this, num); }
+    redSub(num) { this.assert(this.red, 'redSub works only with red numbers'); return this.red.sub(this, num); }
+    redISub(num) { this.assert(this.red, 'redISub works only with red numbers'); return this.red.isub(this, num); }
+    redShl(num) { this.assert(this.red, 'redShl works only with red numbers'); return this.red.shl(this, num); }
+    redMul(num) { this.assert(this.red, 'redMul works only with red numbers'); this.red.verify2(this, num); return this.red.mul(this, num); }
+    redIMul(num) { this.assert(this.red, 'redIMul works only with red numbers'); this.red.verify2(this, num); return this.red.imul(this, num); }
+    redSqr() { this.assert(this.red, 'redSqr works only with red numbers'); this.red.verify1(this); return this.red.sqr(this); }
+    redISqr() { this.assert(this.red, 'redISqr works only with red numbers'); this.red.verify1(this); return this.red.isqr(this); }
+    redSqrt() { this.assert(this.red, 'redSqrt works only with red numbers'); this.red.verify1(this); return this.red.sqrt(this); }
+    redInvm() { this.assert(this.red, 'redInvm works only with red numbers'); this.red.verify1(this); return this.red.invm(this); }
+    redNeg() { this.assert(this.red, 'redNeg works only with red numbers'); this.red.verify1(this); return this.red.neg(this); }
+    redPow(num) { 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, endian) {
+        let eE = '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 = 0) {
+        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) { 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) { 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, base) { 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, endian = 'big') {
+        if (bytes.length === 0)
+            return new BigNumber(0n);
+        const beBytes = bytes.slice();
+        if (endian === 'little') {
+            beBytes.reverse();
+        }
+        let sign = 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');
+            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') {
+        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;
+        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, strict = false) {
+        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() {
+        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, requireMinimal = false, maxNumSize) {
+        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() { 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) {
+        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 = 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;
+        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, out) {
+        out._magnitude = this._magnitude * num._magnitude;
+        out._sign = out._magnitude === 0n ? 0 : (this._sign ^ num._sign);
+        out._nominalWordLength = this.length + num.length;
+        out.red = null;
+        out.normSign();
+        return out;
+    }
+}
+//# sourceMappingURL=BigNumber.js.map