@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

@@ -0,0 +1,284 @@
+/* eslint-env jest */
+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'
+      ].forEach(function (hex) {
+        const bn = new BigNumber(hex, 16)
+        const bl = bn.bitLength()
+
+        for (let i = 0; i < bl; ++i) {
+          expect(bn.testn(i)).toEqual(true)
+        }
+
+        // test off the end
+        expect(bn.testn(bl)).toEqual(false)
+      })
+
+      const xbits =
+        '01111001010111001001000100011101' +
+        '11010011101100011000111001011101' +
+        '10010100111000000001011000111101' +
+        '01011111001111100100011110000010' +
+        '01011010100111010001010011000100' +
+        '01101001011110100001001111100110' +
+        '001110010111'
+
+      const x = new BigNumber(
+        '23478905234580795234378912401239784125643978256123048348957342'
+      )
+      for (let i = 0; i < x.bitLength(); ++i) {
+        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'
+      )
+    })
+  })
+})

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

@@ -0,0 +1,216 @@
+import BigNumber from '../../primitives/BigNumber'
+
+describe('BN.js/Constructor', () => {
+  describe('with Smi input', () => {
+    it('should accept one limb number', () => {
+      expect(new BigNumber(12345).toString(16)).toEqual('3039')
+    })
+
+    it('should accept two-limb number', () => {
+      expect(new BigNumber(0x4123456).toString(16)).toEqual('4123456')
+    })
+
+    it('should accept 52 bits of precision', () => {
+      const num = Math.pow(2, 52)
+      expect(new BigNumber(num, 10).toString(10)).toEqual(num.toString(10))
+    })
+
+    it('should accept max safe integer', () => {
+      const num = Math.pow(2, 53) - 1
+      expect(new BigNumber(num, 10).toString(10)).toEqual(num.toString(10))
+    })
+
+    it('should not accept an unsafe integer', () => {
+      const num = Math.pow(2, 53)
+
+      expect(() => {
+        return new BigNumber(num, 10)
+      }).toThrow(new Error('The number is larger than 2 ^ 53 (unsafe)'))
+    })
+
+    it('should accept two-limb LE number', () => {
+      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'
+      )
+    })
+
+    it('should accept base-hex', () => {
+      expect(new BigNumber('FF', 'hex').toString()).toEqual('255')
+    })
+
+    it('should accept base-16 with spaces', () => {
+      const num = 'a89c e5af8724 c0a23e0e 0ff77500'
+      expect(new BigNumber(num, 16).toString(16)).toEqual(
+        num.replace(/ /g, '')
+      )
+    })
+
+    it('should accept long base-16', () => {
+      const num = '123456789abcdef123456789abcdef123456789abcdef'
+      expect(new BigNumber(num, 16).toString(16)).toEqual(num)
+    })
+
+    it('should accept positive base-10', () => {
+      expect(new BigNumber('10654321').toString()).toEqual('10654321')
+      expect(new BigNumber('29048849665247').toString(16)).toEqual(
+        '1a6b765d8cdf'
+      )
+    })
+
+    it('should accept negative base-10', () => {
+      expect(new BigNumber('-29048849665247').toString(16)).toEqual(
+        '-1a6b765d8cdf'
+      )
+    })
+
+    it('should accept long base-10', () => {
+      const num = '10000000000000000'
+      expect(new BigNumber(num).toString(10)).toEqual(num)
+    })
+
+    it('should accept base-2', () => {
+      const base2 = '11111111111111111111111111111111111111111111111111111'
+      expect(new BigNumber(base2, 2).toString(2)).toEqual(base2)
+    })
+
+    it('should accept base-36', () => {
+      const base36 = 'zzZzzzZzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz'
+      expect(new BigNumber(base36, 36).toString(36)).toEqual(
+        base36.toLowerCase()
+      )
+    })
+
+    it('should not overflow limbs during base-10', () => {
+      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'
+      )
+    })
+
+    it('should accept base-16 LE integer with leading zeros', () => {
+      expect(new BigNumber('0010', 16, 'le').toNumber()).toEqual(4096)
+      expect(new BigNumber('-010', 16, 'le').toNumber()).toEqual(-4096)
+      expect(new BigNumber('010', 16, 'le').toNumber()).toEqual(4096)
+    })
+
+    it('should not accept wrong characters for base', () => {
+      expect(() => {
+        return new BigNumber('01FF')
+      }).toThrow(new Error('Invalid character'))
+    })
+
+    it('should not accept decimal', () => {
+      expect(() => {
+        new BigNumber('10.00', 10) // eslint-disable-line no-new
+      }).toThrow(new Error('Invalid character'))
+
+      expect(() => {
+        new BigNumber('16.00', 16) // eslint-disable-line no-new
+      }).toThrow(/* new Error('Invalid character') */)
+    })
+
+    it('should not accept non-hex characters', () => {
+      [
+        '0000000z',
+        '000000gg',
+        '0000gg00',
+        'fffggfff',
+        '/0000000',
+        '0-000000', // if -, is first, that is OK
+        'ff.fffff',
+        'hexadecimal'
+      ].forEach(function (str) {
+        expect(() => {
+          new BigNumber(str, 16) // eslint-disable-line no-new
+        }).toThrow(/* Invalid character in */)
+      })
+    })
+  })
+
+  describe('with Array input', () => {
+    it('should not fail on empty array', () => {
+      expect(new BigNumber([]).toString(16)).toEqual('0')
+    })
+
+    it('should import/export big endian', () => {
+      expect(new BigNumber([0, 1], 16).toString(16)).toEqual('1')
+      expect(new BigNumber([1, 2, 3]).toString(16)).toEqual('10203')
+      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'
+      )
+      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')
+    })
+
+    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')
+    })
+
+    it('should import big endian with implicit base', () => {
+      expect(new BigNumber([1, 2, 3, 4, 5], 'le').toString(16)).toEqual(
+        '504030201'
+      )
+    })
+  })
+
+  describe('with Buffer input', () => {
+    it('should not fail on empty Buffer', () => {
+      expect(
+        new BigNumber(Buffer.alloc(0).toString('hex') === '' ? '0' : Buffer.alloc(0).toString('hex')).toString(16)
+      ).toEqual('0')
+    })
+
+    it('should import/export big endian', () => {
+      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')
+    })
+  })
+})

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

@@ -0,0 +1,22 @@
+/* eslint-env jest */
+import BigNumber from '../../primitives/BigNumber'
+import ReductionContext from '../../primitives/ReductionContext'
+import { dhGroups } from './BigNumber.fixtures'
+
+describe('BN.js/Slow DH test', () => {
+  Object.keys(dhGroups).forEach(function (name) {
+    it(
+      'should match public key for ' + name + ' group',
+      () => {
+        const group = dhGroups[name]
+        const base = new BigNumber(2)
+        const mont = new ReductionContext(new BigNumber(group.prime, 16))
+        const priv = new BigNumber(group.priv, 16)
+        const multed = base.toRed(mont).redPow(priv).fromRed()
+        const actual = Buffer.from(multed.toArray())
+        expect(actual.toString('hex')).toEqual(group.pub)
+      },
+      3600 * 1000
+    )
+  })
+})