@bsv/sdk 2.0.16 → 2.1.1

package/dist/cjs/src/primitives/BigNumber.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const BufferCtor = typeof globalThis !== 'undefined' ? globalThis.Buffer : undefined;
+const BufferCtor = typeof globalThis === 'undefined' ? undefined : globalThis.Buffer;
 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++) {
@@ -76,7 +76,7 @@ class BigNumber {
         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];
+            const wordVal = newWords[i] ?? 0;
             newMagnitude = (newMagnitude << BigNumber.WORD_SIZE_BIGINT) | BigInt(wordVal & Number(BigNumber.WORD_MASK));
         }
         this._magnitude = newMagnitude;
@@ -137,8 +137,7 @@ class BigNumber {
         this._sign = 0;
         this._nominalWordLength = 1;
         this.red = null;
-        if (number === undefined)
-            number = 0;
+        number ?? (number = 0);
         if (number === null) {
             this._initializeState(0n, 0);
             return;
@@ -163,83 +162,93 @@ class BigNumber {
             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;
+            this._initFromString(number, effectiveBase, effectiveEndian);
+            return;
+        }
+        if (number !== 0) {
+            this.assert(false, 'Unsupported input type for BigNumber constructor');
+        }
+        else {
+            this._initializeState(0n, 0);
+        }
+    }
+    _initFromString(number, effectiveBase, effectiveEndian) {
+        if (effectiveBase === 'hex')
+            effectiveBase = 16;
+        // eslint-disable-next-line no-bitwise -- ToInt32 (ECMA-262); required for integer base validation.
+        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) {
+            this._initFromHexString(numStr, sign, effectiveEndian);
+        }
+        else {
+            this._initFromNonHexString(numStr, effectiveBase, sign, effectiveEndian);
+        }
+    }
+    _initFromHexString(numStr, sign, effectiveEndian) {
+        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 = Number.parseInt(byteHex, 16);
+                if (Number.isNaN(byteVal))
+                    throw new Error('Invalid character in ' + hexStr);
+                bytes.push(byteVal);
             }
-            else if (originalNumberStr.startsWith('+')) {
-                start++;
+            this.initArray(bytes, 'le');
+            this._sign = sign;
+            this.normSign();
+        }
+        else {
+            let tempMagnitude;
+            try {
+                tempMagnitude = BigInt('0x' + numStr);
             }
-            const numStr = originalNumberStr.substring(start);
-            if (numStr.length === 0) {
-                this._initializeState(0n, (sign === 1 && originalNumberStr.startsWith('-')) ? 1 : 0);
-                this.normSign();
-                return;
+            catch (_bigIntParseError) {
+                throw new Error('Invalid character in ' + numStr);
             }
-            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._initializeState(tempMagnitude, sign);
+            this.normSign();
+        }
+    }
+    _initFromNonHexString(numStr, base, sign, effectiveEndian) {
+        try {
+            this._parseBaseString(numStr, base);
+            this._sign = sign;
+            this.normSign();
+            if (effectiveEndian === 'le') {
+                const currentSign = this._sign;
+                this.initArray(this.toArray('be'), 'le');
+                this._sign = currentSign;
                 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);
+        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;
         }
     }
     _bigIntToStringInBase(num, base) {
@@ -294,7 +303,7 @@ class BigNumber {
     _parseBaseWord(str, base) {
         let r = 0;
         for (let i = 0; i < str.length; i++) {
-            const charCode = str.charCodeAt(i);
+            const charCode = str.codePointAt(i);
             let digitVal;
             if (charCode >= 48 && charCode <= 57)
                 digitVal = charCode - 48;
@@ -347,8 +356,8 @@ class BigNumber {
         }
         let magnitude = 0n;
         if (endian === 'be') {
-            for (let i = 0; i < bytes.length; i++)
-                magnitude = (magnitude << 8n) | BigInt(bytes[i] & 0xff);
+            for (const byte of bytes)
+                magnitude = (magnitude << 8n) | BigInt(byte & 0xff);
         }
         else {
             for (let i = bytes.length - 1; i >= 0; i--)
@@ -366,9 +375,10 @@ class BigNumber {
         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) + '>'; }
+    normSign() { if (this._magnitude === 0n) {
+        this._sign = 0;
+    } return this; }
+    inspect() { return (this.red === null ? '<BN: ' : '<BN-R: ') + this.toString(16) + '>'; }
     _getMinimalHex() {
         if (this._magnitude === 0n)
             return '0';
@@ -428,21 +438,7 @@ class BigNumber {
             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;
-            }
+            out = (tempMag > 0n ? this._zeroPaddedChunk(chunkStr, groupSize) : chunkStr) + out;
         }
         if (padding > 0) {
             while (out.length < padding)
@@ -450,6 +446,15 @@ class BigNumber {
         }
         return (this._sign === 1 ? '-' : '') + out;
     }
+    /** Returns a chunk string zero-padded to groupSize (used by toBaseString for interior chunks). */
+    _zeroPaddedChunk(chunkStr, groupSize) {
+        const zerosToPrepend = groupSize - chunkStr.length;
+        if (zerosToPrepend <= 0)
+            return chunkStr;
+        if (zerosToPrepend < BigNumber.zeros.length)
+            return BigNumber.zeros[zerosToPrepend] + chunkStr;
+        return '0'.repeat(zerosToPrepend) + chunkStr;
+    }
     /**
      * Converts the BigNumber instance to a JavaScript number.
      * Please note that JavaScript numbers are only precise up to 53 bits.
@@ -529,8 +534,9 @@ class BigNumber {
      * @method bitLength
      * @returns The bit length of the BigNumber.
      */
-    bitLength() { if (this._magnitude === 0n)
-        return 0; return this._magnitude.toString(2).length; }
+    bitLength() { if (this._magnitude === 0n) {
+        return 0;
+    } return this._magnitude.toString(2).length; }
     /**
      * Converts a BigNumber to an array of bits.
      *
@@ -545,7 +551,7 @@ class BigNumber {
         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;
+            w[bit] = ((mag >> BigInt(bit)) & 1n) === 0n ? 0 : 1;
         }
         return w;
     }
@@ -581,8 +587,9 @@ class BigNumber {
      * @method byteLength
      * @returns The byte length of the BigNumber.
      */
-    byteLength() { if (this._magnitude === 0n)
-        return 0; return Math.ceil(this.bitLength() / 8); }
+    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) {
@@ -622,8 +629,9 @@ class BigNumber {
     }
     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; }
+    ineg() { if (this._magnitude !== 0n) {
+        this._sign = this._sign === 1 ? 0 : 1;
+    } return this; }
     _iuop(num, op, isXor = false) {
         const newMag = op(this._magnitude, num._magnitude);
         let targetNominalLength = this._nominalWordLength;
@@ -642,8 +650,9 @@ class BigNumber {
     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, true); }
-    _uop_new(num, opName) { if (this.length >= num.length)
-        return this.clone()[opName](num); return num.clone()[opName](this); }
+    _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'); }
@@ -799,26 +808,28 @@ class BigNumber {
         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 };
+            return { div: mode === 'mod' ? null : z, mod: mode === 'div' ? null : z };
         }
         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 };
+        const dV = mode !== 'mod' ? tV / nV : null;
+        const mV = this._computeMod(tV, nV, mode, positive);
+        return { div: this._bigNumberFromSigned(dV), mod: this._bigNumberFromSigned(mV) };
+    }
+    _computeMod(tV, nV, mode, positive) {
+        if (mode === 'div')
+            return null;
+        let mV = tV % nV;
+        if (positive === true && mV < 0n)
+            mV += nV < 0n ? -nV : nV;
+        return mV;
+    }
+    _bigNumberFromSigned(v) {
+        if (v === null)
+            return null;
+        const r = new BigNumber(0n);
+        r._setValueFromSigned(v);
+        return r;
     }
     div(num) {
         return this.divmod(num, 'div', false).div;
@@ -933,15 +944,21 @@ class BigNumber {
     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; }
+    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; }
@@ -1062,18 +1079,17 @@ class BigNumber {
             sign = 1;
             beBytes[0] &= 0x7f;
         }
-        let magnitude = 0n;
+        let hexStr;
         if (CAN_USE_BUFFER) {
-            const hex = BufferCtor.from(beBytes).toString('hex');
-            magnitude = hex.length === 0 ? 0n : BigInt('0x' + hex);
+            hexStr = BufferCtor.from(beBytes).toString('hex');
         }
         else {
-            let hex = '';
+            hexStr = '';
             for (const byte of beBytes) {
-                hex += byte < 16 ? '0' + byte.toString(16) : byte.toString(16);
+                hexStr += byte < 16 ? '0' + byte.toString(16) : byte.toString(16);
             }
-            magnitude = hex.length === 0 ? 0n : BigInt('0x' + hex);
         }
+        const magnitude = hexStr.length === 0 ? 0n : BigInt('0x' + hexStr);
         const r = new BigNumber(0n);
         r._initializeState(magnitude, sign);
         return r;
@@ -1095,25 +1111,25 @@ class BigNumber {
         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)];
+            const high = HEX_CHAR_TO_VALUE[hex.codePointAt(i)];
+            const low = HEX_CHAR_TO_VALUE[hex.codePointAt(i + 1)];
             bytes[j++] = ((high & 0xf) << 4) | (low & 0xf);
         }
         let result;
         if (this._sign === 1) {
-            if ((bytes[0] & 0x80) !== 0) {
-                result = [0x80, ...bytes];
-            }
-            else {
+            if ((bytes[0] & 0x80) === 0) {
                 result = bytes.slice();
                 result[0] |= 0x80;
             }
+            else {
+                result = [0x80, ...bytes];
+            }
         }
-        else if ((bytes[0] & 0x80) !== 0) {
-            result = [0x00, ...bytes];
+        else if ((bytes[0] & 0x80) === 0) {
+            result = bytes.slice();
         }
         else {
-            result = bytes.slice();
+            result = [0x00, ...bytes];
         }
         return endian === 'little' ? result.reverse() : result;
     }
@@ -1219,8 +1235,8 @@ class BigNumber {
         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) {
+            if ((num.at(-1) & 0x7f) === 0) {
+                if (num.length <= 1 || (num.at(-2) & 0x80) === 0) {
                     throw new Error('non-minimally encoded script number');
                 }
             }