@bsv/sdk 1.3.12 → 1.3.14

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

@@ -41,23 +41,18 @@ export default class BigNumber {
      * @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
+        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,
+        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
+        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.
@@ -124,9 +119,10 @@ export default class BigNumber {
         if (num instanceof BigNumber) {
             return true;
         }
-        return num !== null && typeof num === 'object' &&
+        return (num !== null &&
+            typeof num === 'object' &&
             num.constructor.wordSize === BigNumber.wordSize &&
-            Array.isArray(num.words);
+            Array.isArray(num.words));
     }
     /**
      * Returns the bigger value between two BigNumbers
@@ -252,19 +248,12 @@ export default class BigNumber {
             this.length = 1;
         }
         else if (number < 0x10000000000000) {
-            this.words = [
-                number & 0x3ffffff,
-                (number / 0x4000000) & 0x3ffffff
-            ];
+            this.words = [number & 0x3ffffff, (number / 0x4000000) & 0x3ffffff];
             this.length = 2;
         }
         else {
-            this.assert(number <= 0x1FFFFFFFFFFFFF, 'The number is larger than 2 ^ 53 (unsafe)');
-            this.words = [
-                number & 0x3ffffff,
-                (number / 0x4000000) & 0x3ffffff,
-                1
-            ];
+            this.assert(number <= 0x1fffffffffffff, 'The number is larger than 2 ^ 53 (unsafe)');
+            this.words = [number & 0x3ffffff, (number / 0x4000000) & 0x3ffffff, 1];
             this.length = 3;
         }
         if (endian !== 'le')
@@ -666,6 +655,7 @@ export default class BigNumber {
         if (padding === 0 && out === '0') {
             return '';
         }
+        // eslint-disable-next-line no-unmodified-loop-condition
         while (out.length % padding !== 0 && padding !== 0) {
             out = '0' + out;
         }
@@ -720,12 +710,12 @@ export default class BigNumber {
         }
         else if (this.length === 3 && this.words[2] === 0x01) {
             // NOTE: at this stage it is known that the top bit is set
-            ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+            ret += 0x10000000000000 + this.words[1] * 0x4000000;
         }
         else if (this.length > 2) {
             throw new Error('Number can only safely store up to 53 bits');
         }
-        return (this.negative !== 0) ? -ret : ret;
+        return this.negative !== 0 ? -ret : ret;
     }
     /**
      * Converts the BigNumber instance to a JSON-formatted string.
@@ -2505,7 +2495,7 @@ export default class BigNumber {
             carry = word & mask;
         }
         // Push carried bits as a mask
-        if ((maskedWords != null) && carry !== 0) {
+        if (maskedWords != null && carry !== 0) {
             maskedWords.words[maskedWords.length++] = carry;
         }
         if (this.length === 0) {
@@ -2946,7 +2936,7 @@ export default class BigNumber {
             }
             if (mode !== 'div') {
                 mod = res.mod.neg();
-                if (positive && mod.negative !== 0) {
+                if (positive === true && mod.negative !== 0) {
                     mod.iadd(num);
                 }
             }
@@ -2969,7 +2959,7 @@ export default class BigNumber {
             res = this.neg().divmod(num.neg(), mode);
             if (mode !== 'div') {
                 mod = res.mod.neg();
-                if (positive && mod.negative !== 0) {
+                if (positive === true && mod.negative !== 0) {
                     mod.isub(num);
                 }
             }
@@ -3070,9 +3060,7 @@ export default class BigNumber {
         // Fast case - exact division
         if (dm.mod.isZero())
             return dm.div;
-        const mod = dm.div.negative !== 0
-            ? dm.mod.isub(num)
-            : dm.mod;
+        const mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
         const half = num.ushrn(1);
         const r2 = num.andln(1);
         const cmp = mod.cmp(half);
@@ -3739,7 +3727,7 @@ export default class BigNumber {
      */
     fromRed() {
         this.assert(this.red, 'fromRed works only with numbers in reduction context');
-        return (this.red).convertFrom(this);
+        return this.red.convertFrom(this);
     }
     /**
      * Forces the current BigNumber into a reduction context, irrespective of the BigNumber's current state.
@@ -3774,7 +3762,7 @@ export default class BigNumber {
      */
     redAdd(num) {
         this.assert(this.red, 'redAdd works only with red numbers');
-        return (this.red).add(this, num);
+        return this.red.add(this, num);
     }
     /**
      * Performs in-place addition operation of the current BigNumber with the given number in a reduction context.
@@ -3792,7 +3780,7 @@ export default class BigNumber {
      */
     redIAdd(num) {
         this.assert(this.red, 'redIAdd works only with red numbers');
-        return (this.red).iadd(this, num);
+        return this.red.iadd(this, num);
     }
     /**
      * Performs subtraction operation of the current BigNumber with the given number in a reduction context.
@@ -3810,7 +3798,7 @@ export default class BigNumber {
      */
     redSub(num) {
         this.assert(this.red, 'redSub works only with red numbers');
-        return (this.red).sub(this, num);
+        return this.red.sub(this, num);
     }
     /**
      * Performs in-place subtraction operation of the current BigNumber with the given number in a reduction context.
@@ -3828,7 +3816,7 @@ export default class BigNumber {
      */
     redISub(num) {
         this.assert(this.red, 'redISub works only with red numbers');
-        return (this.red).isub(this, num);
+        return this.red.isub(this, num);
     }
     /**
      * Performs the shift left operation on the current BigNumber in the reduction context.
@@ -3846,7 +3834,7 @@ export default class BigNumber {
      */
     redShl(num) {
         this.assert(this.red, 'redShl works only with red numbers');
-        return (this.red).shl(this, num);
+        return this.red.shl(this, num);
     }
     /**
      * Performs multiplication operation of the current BigNumber with the given number in a reduction context.
@@ -3864,8 +3852,8 @@ export default class BigNumber {
      */
     redMul(num) {
         this.assert(this.red, 'redMul works only with red numbers');
-        (this.red).verify2(this, num);
-        return (this.red).mul(this, num);
+        this.red.verify2(this, num);
+        return this.red.mul(this, num);
     }
     /**
      * Performs an in-place multiplication of this BigNumber instance with another BigNumber within a reduction context.
@@ -3882,8 +3870,8 @@ export default class BigNumber {
      */
     redIMul(num) {
         this.assert(this.red, 'redMul works only with red numbers');
-        (this.red).verify2(this, num);
-        return (this.red).imul(this, num);
+        this.red.verify2(this, num);
+        return this.red.imul(this, num);
     }
     /**
      * Square of a "red" (reduced) BigNumber.
@@ -3902,8 +3890,8 @@ export default class BigNumber {
      */
     redSqr() {
         this.assert(this.red, 'redSqr works only with red numbers');
-        (this.red).verify1(this);
-        return (this.red).sqr(this);
+        this.red.verify1(this);
+        return this.red.sqr(this);
     }
     /**
      * In-place square of a "red" (reduced) BigNumber.
@@ -3922,8 +3910,8 @@ export default class BigNumber {
      */
     redISqr() {
         this.assert(this.red, 'redISqr works only with red numbers');
-        (this.red).verify1(this);
-        return (this.red).isqr(this);
+        this.red.verify1(this);
+        return this.red.isqr(this);
     }
     /**
      * Square root of a "red" (reduced) BigNumber.
@@ -3943,8 +3931,8 @@ export default class BigNumber {
      */
     redSqrt() {
         this.assert(this.red, 'redSqrt works only with red numbers');
-        (this.red).verify1(this);
-        return (this.red).sqrt(this);
+        this.red.verify1(this);
+        return this.red.sqrt(this);
     }
     /**
      * Find multiplicative inverse (reciprocal) in respect to reduction context.
@@ -3961,8 +3949,8 @@ export default class BigNumber {
      */
     redInvm() {
         this.assert(this.red, 'redInvm works only with red numbers');
-        (this.red).verify1(this);
-        return (this.red).invm(this);
+        this.red.verify1(this);
+        return this.red.invm(this);
     }
     /**
      * Find negative version of this number in respect to reduction context.
@@ -3979,8 +3967,8 @@ export default class BigNumber {
      */
     redNeg() {
         this.assert(this.red, 'redNeg works only with red numbers');
-        (this.red).verify1(this);
-        return (this.red).neg(this);
+        this.red.verify1(this);
+        return this.red.neg(this);
     }
     /**
      * Raises this number to the power of 'num', in respect to reduction context.
@@ -3998,9 +3986,9 @@ export default class BigNumber {
      * let result = a.redPow(b);  // equivalent to (a^b) mod red
      */
     redPow(num) {
-        this.assert((this.red != null) && (num.red == null), 'redPow(normalNum)');
-        (this.red).verify1(this);
-        return (this.red).pow(this, 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.
@@ -4165,7 +4153,7 @@ export default class BigNumber {
      */
     static fromBits(bits, strict = false) {
         // Convert to signed 32-bit value manually without using Buffer
-        bits = (bits & 0x80000000) ? bits - 0x100000000 : bits;
+        bits = (bits & 0x80000000) !== 0 ? bits - 0x100000000 : bits;
         if (strict && (bits & 0x00800000) !== 0) {
             throw new Error('negative bit set');
         }
@@ -4173,10 +4161,10 @@ export default class BigNumber {
         const nword = bits & 0x007fffff;
         // Manually create the byte array (similar to the original buffer)
         let bytes = [
-            (nword >> 24) & 0xFF,
-            (nword >> 16) & 0xFF,
-            (nword >> 8) & 0xFF,
-            nword & 0xFF
+            (nword >> 24) & 0xff,
+            (nword >> 16) & 0xff,
+            (nword >> 8) & 0xff,
+            nword & 0xff
         ];
         if (nsize <= 3) {
             bytes = bytes.slice(1, 1 + nsize); // remove the most significant byte(s) as necessary
@@ -4218,7 +4206,7 @@ export default class BigNumber {
             byteArray.unshift(0);
         }
         // For the case where byteArray represents '00', the bits should be 0x00000000
-        if (byteArray.every(byte => byte === 0)) {
+        if (byteArray.every((byte) => byte === 0)) {
             return 0x00000000;
         }
         // Remove leading zeros from the byte array for further processing
@@ -4228,7 +4216,7 @@ export default class BigNumber {
         let nsize = byteArray.length;
         // We're interested in the first three bytes for the "nword"
         // or in smaller cases, what's available
-        let nword = byteArray.slice(0, 3).reduce((acc, val) => (acc * 256) + val, 0);
+        let nword = byteArray.slice(0, 3).reduce((acc, val) => acc * 256 + val, 0);
         // Ensure we don't have the sign bit set initially
         if ((nword & 0x800000) !== 0) {
             // If the 24th bit is set, we're going to need one more byte to represent this number
@@ -4266,7 +4254,7 @@ export default class BigNumber {
         if (num.length > maxNumSize) {
             throw new Error('script number overflow');
         }
-        if (requireMinimal && num.length > 0) {
+        if (requireMinimal === true && num.length > 0) {
             // Check that the number is encoded with the minimum possible
             // number of bytes.
             //