@bsv/sdk 1.3.11 → 1.3.13

package/src/primitives/__tests/BigNumber.binary.test.ts

@@ -1,203 +1,284 @@
 /* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-
-describe('BN.js/Binary', function () {
-  describe('.shl()', function () {
-    it('should shl numbers', function () {
-      expect(new BigNumber('69527932928').shln(13).toString(16)).toEqual('2060602000000')
-      expect(new BigNumber('69527932928').shln(45).toString(16)).toEqual('206060200000000000000')
-    })
-
-    it('should ushl numbers', function () {
-      expect(new BigNumber('69527932928').ushln(13).toString(16)).toEqual('2060602000000')
-      expect(new BigNumber('69527932928').ushln(45).toString(16)).toEqual('206060200000000000000')
-    })
-  })
-
-  describe('.shr()', function () {
-    it('should shr numbers', function () {
-      expect(new BigNumber('69527932928').shrn(13).toString(16)).toEqual('818180')
-      expect(new BigNumber('69527932928').shrn(17).toString(16)).toEqual('81818')
-      expect(new BigNumber('69527932928').shrn(256).toString(16)).toEqual('0')
-    })
-
-    it('should ushr numbers', function () {
-      expect(new BigNumber('69527932928').ushrn(13).toString(16)).toEqual('818180')
-      expect(new BigNumber('69527932928').ushrn(17).toString(16)).toEqual('81818')
-      expect(new BigNumber('69527932928').ushrn(256).toString(16)).toEqual('0')
-    })
-  })
-
-  describe('.bincn()', function () {
-    it('should increment bit', function () {
-      expect(new BigNumber(0).bincn(1).toString(16)).toEqual('2')
-      expect(new BigNumber(2).bincn(1).toString(16)).toEqual('4')
-      expect(new BigNumber(2).bincn(1).bincn(1).toString(16)).toEqual(new BigNumber(2).bincn(2).toString(16))
-      expect(new BigNumber(0xffffff).bincn(1).toString(16)).toEqual('1000001')
-      expect(new BigNumber(2).bincn(63).toString(16)).toEqual('8000000000000002')
-    })
-  })
-
-  describe('.imaskn()', function () {
-    it('should mask bits in-place', function () {
-      expect(new BigNumber(0).imaskn(1).toString(16)).toEqual('0')
-      expect(new BigNumber(3).imaskn(1).toString(16)).toEqual('1')
-      expect(new BigNumber('123456789', 16).imaskn(4).toString(16)).toEqual('9')
-      expect(new BigNumber('123456789', 16).imaskn(16).toString(16)).toEqual('6789')
-      expect(new BigNumber('123456789', 16).imaskn(28).toString(16)).toEqual('3456789')
-    })
-
-    it('should not mask when number is bigger than length', function () {
-      expect(new BigNumber(0xe3).imaskn(56).toString(16)).toEqual('e3')
-      expect(new BigNumber(0xe3).imaskn(26).toString(16)).toEqual('e3')
-    })
-  })
-
-  describe('.testn()', function () {
-    it('should support test specific bit', function () {
+import BigNumber from "../../primitives/BigNumber";
+
+describe("BN.js/Binary", function () {
+  describe(".shl()", function () {
+    it("should shl numbers", function () {
+      expect(new BigNumber("69527932928").shln(13).toString(16)).toEqual(
+        "2060602000000"
+      );
+      expect(new BigNumber("69527932928").shln(45).toString(16)).toEqual(
+        "206060200000000000000"
+      );
+    });
+
+    it("should ushl numbers", function () {
+      expect(new BigNumber("69527932928").ushln(13).toString(16)).toEqual(
+        "2060602000000"
+      );
+      expect(new BigNumber("69527932928").ushln(45).toString(16)).toEqual(
+        "206060200000000000000"
+      );
+    });
+  });
+
+  describe(".shr()", function () {
+    it("should shr numbers", function () {
+      expect(new BigNumber("69527932928").shrn(13).toString(16)).toEqual(
+        "818180"
+      );
+      expect(new BigNumber("69527932928").shrn(17).toString(16)).toEqual(
+        "81818"
+      );
+      expect(new BigNumber("69527932928").shrn(256).toString(16)).toEqual("0");
+    });
+
+    it("should ushr numbers", function () {
+      expect(new BigNumber("69527932928").ushrn(13).toString(16)).toEqual(
+        "818180"
+      );
+      expect(new BigNumber("69527932928").ushrn(17).toString(16)).toEqual(
+        "81818"
+      );
+      expect(new BigNumber("69527932928").ushrn(256).toString(16)).toEqual("0");
+    });
+  });
+
+  describe(".bincn()", function () {
+    it("should increment bit", function () {
+      expect(new BigNumber(0).bincn(1).toString(16)).toEqual("2");
+      expect(new BigNumber(2).bincn(1).toString(16)).toEqual("4");
+      expect(new BigNumber(2).bincn(1).bincn(1).toString(16)).toEqual(
+        new BigNumber(2).bincn(2).toString(16)
+      );
+      expect(new BigNumber(0xffffff).bincn(1).toString(16)).toEqual("1000001");
+      expect(new BigNumber(2).bincn(63).toString(16)).toEqual(
+        "8000000000000002"
+      );
+    });
+  });
+
+  describe(".imaskn()", function () {
+    it("should mask bits in-place", function () {
+      expect(new BigNumber(0).imaskn(1).toString(16)).toEqual("0");
+      expect(new BigNumber(3).imaskn(1).toString(16)).toEqual("1");
+      expect(new BigNumber("123456789", 16).imaskn(4).toString(16)).toEqual(
+        "9"
+      );
+      expect(new BigNumber("123456789", 16).imaskn(16).toString(16)).toEqual(
+        "6789"
+      );
+      expect(new BigNumber("123456789", 16).imaskn(28).toString(16)).toEqual(
+        "3456789"
+      );
+    });
+
+    it("should not mask when number is bigger than length", function () {
+      expect(new BigNumber(0xe3).imaskn(56).toString(16)).toEqual("e3");
+      expect(new BigNumber(0xe3).imaskn(26).toString(16)).toEqual("e3");
+    });
+  });
+
+  describe(".testn()", function () {
+    it("should support test specific bit", function () {
       [
-        'ff',
-        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+        "ff",
+        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
       ].forEach(function (hex) {
-        const bn = new BigNumber(hex, 16)
-        const bl = bn.bitLength()
+        const bn = new BigNumber(hex, 16);
+        const bl = bn.bitLength();
 
         for (let i = 0; i < bl; ++i) {
-          expect(bn.testn(i)).toEqual(true)
+          expect(bn.testn(i)).toEqual(true);
         }
 
         // test off the end
-        expect(bn.testn(bl)).toEqual(false)
-      })
+        expect(bn.testn(bl)).toEqual(false);
+      });
 
-      const xbits = '01111001010111001001000100011101' +
-        '11010011101100011000111001011101' +
-        '10010100111000000001011000111101' +
-        '01011111001111100100011110000010' +
-        '01011010100111010001010011000100' +
-        '01101001011110100001001111100110' +
-        '001110010111'
+      const xbits =
+        "01111001010111001001000100011101" +
+        "11010011101100011000111001011101" +
+        "10010100111000000001011000111101" +
+        "01011111001111100100011110000010" +
+        "01011010100111010001010011000100" +
+        "01101001011110100001001111100110" +
+        "001110010111";
 
       const x = new BigNumber(
-        '23478905234580795234378912401239784125643978256123048348957342'
-      )
+        "23478905234580795234378912401239784125643978256123048348957342"
+      );
       for (let i = 0; i < x.bitLength(); ++i) {
-        expect(x.testn(i)).toEqual(xbits.charAt(i) === '1')
+        expect(x.testn(i)).toEqual(xbits.charAt(i) === "1");
       }
-    })
-
-    it('should have short-cuts', function () {
-      const x = new BigNumber('abcd', 16)
-      expect(!x.testn(128)).toEqual(true)
-    })
-  })
-
-  describe('.and()', function () {
-    it('should and numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .and(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('0')
-    })
-
-    it('should and numbers of different limb-length', function () {
-      expect(
-        new BigNumber('abcd0000ffff', 16)
-          .and(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd')
-    })
-  })
-
-  describe('.iand()', function () {
-    it('should iand numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .iand(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('0')
-      expect(new BigNumber('1000000000000000000000000000000000000001', 2)
-        .iand(new BigNumber('1', 2))
-        .toString(2)).toEqual('1')
-      expect(new BigNumber('1', 2)
-        .iand(new BigNumber('1000000000000000000000000000000000000001', 2))
-        .toString(2)).toEqual('1')
-    })
-  })
-
-  describe('.or()', function () {
-    it('should or numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .or(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('1111111111111111111111111111111111111111')
-    })
-
-    it('should or numbers of different limb-length', function () {
-      expect(
-        new BigNumber('abcd00000000', 16)
-          .or(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd0000abcd')
-    })
-  })
-
-  describe('.ior()', function () {
-    it('should ior numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .ior(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('1111111111111111111111111111111111111111')
-      expect(new BigNumber('1000000000000000000000000000000000000000', 2)
-        .ior(new BigNumber('1', 2))
-        .toString(2)).toEqual('1000000000000000000000000000000000000001')
-      expect(new BigNumber('1', 2)
-        .ior(new BigNumber('1000000000000000000000000000000000000000', 2))
-        .toString(2)).toEqual('1000000000000000000000000000000000000001')
-    })
-  })
-
-  describe('.xor()', function () {
-    it('should xor numbers', function () {
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .xor(new BigNumber('1100110011001100110011001100110', 2))
-        .toString(2)).toEqual('10101010101010101010101010101010')
-    })
-  })
-
-  describe('.ixor()', function () {
-    it('should ixor numbers', function () {
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .ixor(new BigNumber('1100110011001100110011001100110', 2))
-        .toString(2)).toEqual('10101010101010101010101010101010')
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .ixor(new BigNumber('1', 2))
-        .toString(2)).toEqual('11001100110011001100110011001101')
-      expect(new BigNumber('1', 2)
-        .ixor(new BigNumber('11001100110011001100110011001100', 2))
-        .toString(2)).toEqual('11001100110011001100110011001101')
-    })
-
-    it('should and numbers of different limb-length', function () {
-      expect(
-        new BigNumber('abcd0000ffff', 16)
-          .ixor(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd00005432')
-    })
-  })
-
-  describe('.setn()', function () {
-    it('should allow single bits to be set', function () {
-      expect(new BigNumber(0).setn(2, true).toString(2)).toEqual('100')
-      expect(new BigNumber(0).setn(27, true).toString(2)).toEqual('1000000000000000000000000000')
-      expect(new BigNumber(0).setn(63, true).toString(16)).toEqual(new BigNumber(1).iushln(63).toString(16))
-      expect(new BigNumber('1000000000000000000000000001', 2).setn(27, false).toString(2)).toEqual('1')
-      expect(new BigNumber('101', 2).setn(2, false).toString(2)).toEqual('1')
-    })
-  })
-
-  describe('.notn()', function () {
-    it('should allow bitwise negation', function () {
-      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual('111000')
-      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual('111000111')
-      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual('111000')
-      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual('111000111')
-      expect(new BigNumber('111000111', 2).notn(32).toString(2)).toEqual('11111111111111111111111000111000')
-      expect(new BigNumber('000111000', 2).notn(32).toString(2)).toEqual('11111111111111111111111111000111')
-      expect(new BigNumber('111000111', 2).notn(68).toString(2)).toEqual('11111111111111111111111111111111' +
-        '111111111111111111111111111000111000')
-      expect(new BigNumber('000111000', 2).notn(68).toString(2)).toEqual('11111111111111111111111111111111' +
-        '111111111111111111111111111111000111')
-    })
-  })
-})
+    });
+
+    it("should have short-cuts", function () {
+      const x = new BigNumber("abcd", 16);
+      expect(!x.testn(128)).toEqual(true);
+    });
+  });
+
+  describe(".and()", function () {
+    it("should and numbers", function () {
+      expect(
+        new BigNumber("1010101010101010101010101010101010101010", 2)
+          .and(new BigNumber("101010101010101010101010101010101010101", 2))
+          .toString(2)
+      ).toEqual("0");
+    });
+
+    it("should and numbers of different limb-length", function () {
+      expect(
+        new BigNumber("abcd0000ffff", 16)
+          .and(new BigNumber("abcd", 16))
+          .toString(16)
+      ).toEqual("abcd");
+    });
+  });
+
+  describe(".iand()", function () {
+    it("should iand numbers", function () {
+      expect(
+        new BigNumber("1010101010101010101010101010101010101010", 2)
+          .iand(new BigNumber("101010101010101010101010101010101010101", 2))
+          .toString(2)
+      ).toEqual("0");
+      expect(
+        new BigNumber("1000000000000000000000000000000000000001", 2)
+          .iand(new BigNumber("1", 2))
+          .toString(2)
+      ).toEqual("1");
+      expect(
+        new BigNumber("1", 2)
+          .iand(new BigNumber("1000000000000000000000000000000000000001", 2))
+          .toString(2)
+      ).toEqual("1");
+    });
+  });
+
+  describe(".or()", function () {
+    it("should or numbers", function () {
+      expect(
+        new BigNumber("1010101010101010101010101010101010101010", 2)
+          .or(new BigNumber("101010101010101010101010101010101010101", 2))
+          .toString(2)
+      ).toEqual("1111111111111111111111111111111111111111");
+    });
+
+    it("should or numbers of different limb-length", function () {
+      expect(
+        new BigNumber("abcd00000000", 16)
+          .or(new BigNumber("abcd", 16))
+          .toString(16)
+      ).toEqual("abcd0000abcd");
+    });
+  });
+
+  describe(".ior()", function () {
+    it("should ior numbers", function () {
+      expect(
+        new BigNumber("1010101010101010101010101010101010101010", 2)
+          .ior(new BigNumber("101010101010101010101010101010101010101", 2))
+          .toString(2)
+      ).toEqual("1111111111111111111111111111111111111111");
+      expect(
+        new BigNumber("1000000000000000000000000000000000000000", 2)
+          .ior(new BigNumber("1", 2))
+          .toString(2)
+      ).toEqual("1000000000000000000000000000000000000001");
+      expect(
+        new BigNumber("1", 2)
+          .ior(new BigNumber("1000000000000000000000000000000000000000", 2))
+          .toString(2)
+      ).toEqual("1000000000000000000000000000000000000001");
+    });
+  });
+
+  describe(".xor()", function () {
+    it("should xor numbers", function () {
+      expect(
+        new BigNumber("11001100110011001100110011001100", 2)
+          .xor(new BigNumber("1100110011001100110011001100110", 2))
+          .toString(2)
+      ).toEqual("10101010101010101010101010101010");
+    });
+  });
+
+  describe(".ixor()", function () {
+    it("should ixor numbers", function () {
+      expect(
+        new BigNumber("11001100110011001100110011001100", 2)
+          .ixor(new BigNumber("1100110011001100110011001100110", 2))
+          .toString(2)
+      ).toEqual("10101010101010101010101010101010");
+      expect(
+        new BigNumber("11001100110011001100110011001100", 2)
+          .ixor(new BigNumber("1", 2))
+          .toString(2)
+      ).toEqual("11001100110011001100110011001101");
+      expect(
+        new BigNumber("1", 2)
+          .ixor(new BigNumber("11001100110011001100110011001100", 2))
+          .toString(2)
+      ).toEqual("11001100110011001100110011001101");
+    });
+
+    it("should and numbers of different limb-length", function () {
+      expect(
+        new BigNumber("abcd0000ffff", 16)
+          .ixor(new BigNumber("abcd", 16))
+          .toString(16)
+      ).toEqual("abcd00005432");
+    });
+  });
+
+  describe(".setn()", function () {
+    it("should allow single bits to be set", function () {
+      expect(new BigNumber(0).setn(2, true).toString(2)).toEqual("100");
+      expect(new BigNumber(0).setn(27, true).toString(2)).toEqual(
+        "1000000000000000000000000000"
+      );
+      expect(new BigNumber(0).setn(63, true).toString(16)).toEqual(
+        new BigNumber(1).iushln(63).toString(16)
+      );
+      expect(
+        new BigNumber("1000000000000000000000000001", 2)
+          .setn(27, false)
+          .toString(2)
+      ).toEqual("1");
+      expect(new BigNumber("101", 2).setn(2, false).toString(2)).toEqual("1");
+    });
+  });
+
+  describe(".notn()", function () {
+    it("should allow bitwise negation", function () {
+      expect(new BigNumber("111000111", 2).notn(9).toString(2)).toEqual(
+        "111000"
+      );
+      expect(new BigNumber("000111000", 2).notn(9).toString(2)).toEqual(
+        "111000111"
+      );
+      expect(new BigNumber("111000111", 2).notn(9).toString(2)).toEqual(
+        "111000"
+      );
+      expect(new BigNumber("000111000", 2).notn(9).toString(2)).toEqual(
+        "111000111"
+      );
+      expect(new BigNumber("111000111", 2).notn(32).toString(2)).toEqual(
+        "11111111111111111111111000111000"
+      );
+      expect(new BigNumber("000111000", 2).notn(32).toString(2)).toEqual(
+        "11111111111111111111111111000111"
+      );
+      expect(new BigNumber("111000111", 2).notn(68).toString(2)).toEqual(
+        "11111111111111111111111111111111" +
+          "111111111111111111111111111000111000"
+      );
+      expect(new BigNumber("000111000", 2).notn(68).toString(2)).toEqual(
+        "11111111111111111111111111111111" +
+          "111111111111111111111111111111000111"
+      );
+    });
+  });
+});

package/src/primitives/__tests/BigNumber.constructor.test.ts

@@ -1,4 +1,4 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('BN.js/Constructor', () => {
   describe('with Smi input', () => {
@@ -29,14 +29,20 @@ describe('BN.js/Constructor', () => {
     })
 
     it('should accept two-limb LE number', () => {
-      expect(new BigNumber(0x4123456, undefined, 'le').toString(16)).toEqual('56341204')
+      expect(new BigNumber(0x4123456, undefined, 'le').toString(16)).toEqual(
+        '56341204'
+      )
     })
   })
 
   describe('with String input', () => {
     it('should accept base-16', () => {
-      expect(new BigNumber('1A6B765D8CDF', 16).toString(16)).toEqual('1a6b765d8cdf')
-      expect(new BigNumber('1A6B765D8CDF', 16).toString()).toEqual('29048849665247')
+      expect(new BigNumber('1A6B765D8CDF', 16).toString(16)).toEqual(
+        '1a6b765d8cdf'
+      )
+      expect(new BigNumber('1A6B765D8CDF', 16).toString()).toEqual(
+        '29048849665247'
+      )
     })
 
     it('should accept base-hex', () => {
@@ -55,11 +61,15 @@ describe('BN.js/Constructor', () => {
 
     it('should accept positive base-10', () => {
       expect(new BigNumber('10654321').toString()).toEqual('10654321')
-      expect(new BigNumber('29048849665247').toString(16)).toEqual('1a6b765d8cdf')
+      expect(new BigNumber('29048849665247').toString(16)).toEqual(
+        '1a6b765d8cdf'
+      )
     })
 
     it('should accept negative base-10', () => {
-      expect(new BigNumber('-29048849665247').toString(16)).toEqual('-1a6b765d8cdf')
+      expect(new BigNumber('-29048849665247').toString(16)).toEqual(
+        '-1a6b765d8cdf'
+      )
     })
 
     it('should accept long base-10', () => {
@@ -74,18 +84,21 @@ describe('BN.js/Constructor', () => {
 
     it('should accept base-36', () => {
       const base36 = 'zzZzzzZzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz'
-      expect(new BigNumber(base36, 36).toString(36)).toEqual(base36.toLowerCase())
+      expect(new BigNumber(base36, 36).toString(36)).toEqual(
+        base36.toLowerCase()
+      )
     })
 
     it('should not overflow limbs during base-10', () => {
-      const num = '65820182292848241686198767302293' +
-        '20890292528855852623664389292032'
+      const num =
+        '65820182292848241686198767302293' + '20890292528855852623664389292032'
       expect(new BigNumber(num).words[0]).toBeLessThan(0x4000000)
     })
 
     it('should accept base-16 LE integer', () => {
-      expect(new BigNumber('1A6B765D8CDF', 16, 'le').toString(16))
-        .toEqual('df8c5d766b1a')
+      expect(new BigNumber('1A6B765D8CDF', 16, 'le').toString(16)).toEqual(
+        'df8c5d766b1a'
+      )
     })
 
     it('should accept base-16 LE integer with leading zeros', () => {
@@ -111,7 +124,7 @@ describe('BN.js/Constructor', () => {
     })
 
     it('should not accept non-hex characters', () => {
-      [
+      ;[
         '0000000z',
         '000000gg',
         '0000gg00',
@@ -139,38 +152,61 @@ describe('BN.js/Constructor', () => {
       expect(new BigNumber([1, 2, 3, 4]).toString(16)).toEqual('1020304')
       expect(new BigNumber([1, 2, 3, 4, 5]).toString(16)).toEqual('102030405')
       expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toString(16)).toEqual(
-        '102030405060708')
+        '102030405060708'
+      )
       expect(new BigNumber([1, 2, 3, 4]).toArray().join(',')).toEqual('1,2,3,4')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray().join(',')).toEqual('1,2,3,4,5,6,7,8')
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray().join(',')
+      ).toEqual('1,2,3,4,5,6,7,8')
     })
 
     it('should import little endian', () => {
       expect(new BigNumber([0, 1], 16, 'le').toString(16)).toEqual('100')
       expect(new BigNumber([1, 2, 3], 16, 'le').toString(16)).toEqual('30201')
-      expect(new BigNumber([1, 2, 3, 4], 16, 'le').toString(16)).toEqual('4030201')
-      expect(new BigNumber([1, 2, 3, 4, 5], 16, 'le').toString(16)).toEqual('504030201')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8], 'le').toString(16)).toEqual('807060504030201')
-      expect(new BigNumber([1, 2, 3, 4]).toArray('le').join(',')).toEqual('4,3,2,1')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray('le').join(',')).toEqual('8,7,6,5,4,3,2,1')
+      expect(new BigNumber([1, 2, 3, 4], 16, 'le').toString(16)).toEqual(
+        '4030201'
+      )
+      expect(new BigNumber([1, 2, 3, 4, 5], 16, 'le').toString(16)).toEqual(
+        '504030201'
+      )
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8], 'le').toString(16)
+      ).toEqual('807060504030201')
+      expect(new BigNumber([1, 2, 3, 4]).toArray('le').join(',')).toEqual(
+        '4,3,2,1'
+      )
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray('le').join(',')
+      ).toEqual('8,7,6,5,4,3,2,1')
     })
 
     it('should import big endian with implicit base', () => {
-      expect(new BigNumber([1, 2, 3, 4, 5], 'le').toString(16)).toEqual('504030201')
+      expect(new BigNumber([1, 2, 3, 4, 5], 'le').toString(16)).toEqual(
+        '504030201'
+      )
     })
   })
 
-  // the Array code is able to handle Buffer
   describe('with Buffer input', () => {
     it('should not fail on empty Buffer', () => {
-      expect(new BigNumber(Buffer.alloc(0)).toString(16)).toEqual('0')
+      expect(
+        new BigNumber(Buffer.alloc(0).toString('hex') || '0').toString(16)
+      ).toEqual('0')
     })
 
     it('should import/export big endian', () => {
-      expect(new BigNumber(Buffer.from('010203', 'hex')).toString(16)).toEqual('10203')
+      expect(
+        new BigNumber(
+          Buffer.from('010203', 'hex').toString('hex'),
+          16
+        ).toString(16)
+      ).toEqual('10203')
     })
 
     it('should import little endian', () => {
-      expect(new BigNumber(Buffer.from('010203', 'hex'), 'le').toString(16)).toEqual('30201')
+      expect(
+        new BigNumber([...Buffer.from('010203', 'hex')], 'le').toString(16)
+      ).toEqual('30201')
     })
   })
 })