@bsv/sdk 1.0.0 → 1.0.1

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

@@ -1,157 +0,0 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import { toArray, encode } from '../../../dist/cjs/src/primitives/utils'
-
-describe('BigNumber/Serializers', () => {
-  describe('#fromJSON', () => {
-    it('should make Bn from a string', () => {
-      expect(BigNumber.fromJSON('5').toString()).toEqual('5')
-    })
-  })
-
-  describe('#toJSON', () => {
-    it('should make string from a Bn', () => {
-      expect(new BigNumber(5).toJSON()).toEqual('5')
-      expect(BigNumber.fromJSON('5').toJSON()).toEqual('5')
-    })
-  })
-
-  describe('#fromString', () => {
-    it('should make Bn from a string', () => {
-      expect(BigNumber.fromString('5').toString()).toEqual('5')
-    })
-  })
-
-  describe('#toString', () => {
-    it('should make a string', () => {
-      expect(new BigNumber(5).toString()).toEqual('5')
-    })
-  })
-
-  describe('#fromHex', () => {
-    it('should create bn from known hex', () => {
-      const bn = BigNumber.fromHex('0100', 'little')
-      expect(bn.toString()).toEqual('1')
-    })
-  })
-
-  describe('#toHex', () => {
-    it('should create a hex string of 4 byte buffer', () => {
-      const bn = new BigNumber(1)
-      expect(bn.toHex(4)).toEqual('00000001')
-    })
-  })
-
-  describe('#toBits', () => {
-    it('should convert these known Bns to bits', () => {
-      expect(BigNumber.fromHex('00').toBits()).toEqual(0x00000000)
-      expect(BigNumber.fromHex('01').toBits()).toEqual(0x01000001)
-      expect(BigNumber.fromHex('0101').toBits()).toEqual(0x02000101)
-      expect(BigNumber.fromHex('010101').toBits()).toEqual(0x03010101)
-      expect(BigNumber.fromHex('01010101').toBits()).toEqual(0x04010101)
-      expect(BigNumber.fromHex('0101010101').toBits()).toEqual(0x05010101)
-      expect(BigNumber.fromHex('010101010101').toBits()).toEqual(0x06010101)
-      expect(BigNumber.fromNumber(-1).toBits()).toEqual(0x01800001)
-    })
-  })
-
-  describe('#fromBits', () => {
-    it('should convert these known bits to Bns', () => {
-      expect(BigNumber.fromBits(0x01003456).toHex()).toEqual('')
-      expect(BigNumber.fromBits(0x02003456).toHex()).toEqual('34')
-      expect(BigNumber.fromBits(0x03003456).toHex()).toEqual('3456')
-      expect(BigNumber.fromBits(0x04003456).toHex()).toEqual('345600')
-      expect(BigNumber.fromBits(0x05003456).toHex()).toEqual('34560000')
-      expect(BigNumber.fromBits(0x05f03456).ltn(0)).toEqual(true) // sign bit set
-      expect(() => BigNumber.fromBits(0x05f03456, true)).toThrow('negative bit set')
-      expect(BigNumber.fromBits(0x04923456).ltn(0)).toEqual(true)
-    })
-  })
-
-  describe('#toSm', () => {
-    it('should convert to Sm', () => {
-      let num: number[]
-      num = new BigNumber().toSm()
-      expect(encode(num, 'hex')).toEqual('')
-      num = new BigNumber(5).toSm()
-      expect(encode(num, 'hex')).toEqual('05')
-      num = new BigNumber(-5).toSm()
-      expect(encode(num, 'hex')).toEqual('85')
-      num = new BigNumber(128).toSm()
-      expect(encode(num, 'hex')).toEqual('0080')
-      num = new BigNumber(-128).toSm()
-      expect(encode(num, 'hex')).toEqual('8080')
-      num = new BigNumber(127).toSm()
-      expect(encode(num, 'hex')).toEqual('7f')
-      num = new BigNumber(-127).toSm()
-      expect(encode(num, 'hex')).toEqual('ff')
-      num = new BigNumber(128).toSm('little')
-      expect(encode(num, 'hex')).toEqual('8000')
-      num = new BigNumber(-128).toSm('little')
-      expect(encode(num, 'hex')).toEqual('8080')
-    })
-  })
-
-  describe('#fromSm', () => {
-    it('should convert from Sm', () => {
-      let buf
-      buf = [0]
-      expect(BigNumber.fromSm(buf).cmpn(0)).toEqual(0)
-      buf = toArray('05', 'hex')
-      expect(BigNumber.fromSm(buf).cmpn(5)).toEqual(0)
-      buf = toArray('85', 'hex')
-      expect(BigNumber.fromSm(buf).cmpn(-5)).toEqual(0)
-      buf = toArray('0080', 'hex')
-      expect(BigNumber.fromSm(buf).cmpn(128)).toEqual(0)
-      buf = toArray('8080', 'hex')
-      expect(BigNumber.fromSm(buf).cmpn(-128)).toEqual(0)
-      buf = toArray('8000', 'hex')
-      expect(BigNumber.fromSm(buf, 'little').cmpn(128)).toEqual(0)
-      buf = toArray('8080', 'hex')
-      expect(BigNumber.fromSm(buf, 'little').cmpn(-128)).toEqual(0)
-      buf = toArray('0080', 'hex') // negative zero
-      expect(BigNumber.fromSm(buf, 'little').cmpn(0)).toEqual(0)
-    })
-  })
-
-  describe('#toScriptNumBuffer', () => {
-    it('should output a little endian Sm number', () => {
-      const bn = new BigNumber(-23434234)
-      expect(bn.toScriptNum()).toEqual(bn.toSm('little'))
-    })
-  })
-
-  describe('#fromScriptNum', () => {
-    it('should parse this normal number', () => {
-      expect(BigNumber.fromScriptNum(toArray('01', 'hex')).toNumber()).toEqual(1)
-      expect(BigNumber.fromScriptNum(toArray('0080', 'hex')).toNumber()).toEqual(0)
-      expect(BigNumber.fromScriptNum(toArray('0180', 'hex')).toNumber()).toEqual(-1)
-    })
-
-    it('should throw an error for a number over 4 bytes', () => {
-      expect(() => BigNumber.fromScriptNum(toArray('8100000000', 'hex'))).toThrow('script number overflow')
-    })
-
-    it('should throw an error for number that is not a minimal size representation', () => {
-      expect(() => BigNumber.fromScriptNum(toArray('80000000', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(() => BigNumber.fromScriptNum(toArray('800000', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(() => BigNumber.fromScriptNum(toArray('00', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(BigNumber.fromScriptNum(toArray('8000', 'hex'), true).toString()).toEqual('128')
-      expect(BigNumber.fromScriptNum(toArray('0081', 'hex'), true).toString()).toEqual('-256')
-      expect(BigNumber.fromScriptNum(toArray('', 'hex'), true).toString()).toEqual('0')
-      expect(BigNumber.fromScriptNum(toArray('01', 'hex'), true).toString()).toEqual('1')
-      expect(BigNumber.fromScriptNum(toArray('00000000', 'hex')).toString()).toEqual('0')
-    })
-  })
-
-  describe('#fromNumber', () => {
-    it('should convert from a number', () => {
-      expect(BigNumber.fromNumber(5).toNumber()).toEqual(5)
-    })
-  })
-
-  describe('#toNumber', () => {
-    it('it should convert to a number', () => {
-      expect(new BigNumber(5).toNumber()).toEqual(5)
-    })
-  })
-})

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

@@ -1,347 +0,0 @@
-/* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-
-describe('BN.js/Utils', () => {
-  describe('.toString()', () => {
-    describe('hex no padding', () => {
-      it('should have same length as input', () => {
-        let hex = '1'
-        for (let i = 1; i <= 128; i++) {
-          const n = new BigNumber(hex, 16)
-          expect(n.toString(16).length).toEqual(i)
-          hex = hex + '0'
-        }
-      })
-    })
-    describe('binary padding', () => {
-      it('should have a length of 256', () => {
-        const a = new BigNumber(0)
-
-        expect(a.toString(2, 256).length).toEqual(256)
-      })
-    })
-    describe('hex padding', () => {
-      it('should have length of 8 from leading 15', () => {
-        const a = new BigNumber('ffb9602', 16)
-
-        expect(a.toString('hex', 2).length).toEqual(8)
-      })
-
-      it('should have length of 8 from leading zero', () => {
-        const a = new BigNumber('fb9604', 16)
-
-        expect(a.toString('hex', 8).length).toEqual(8)
-      })
-
-      it('should have length of 8 from leading zeros', () => {
-        const a = new BigNumber(0)
-
-        expect(a.toString('hex', 8).length).toEqual(8)
-      })
-
-      it('should have length of 64 from leading 15', () => {
-        const a = new BigNumber(
-          'ffb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
-          16)
-
-        expect(a.toString('hex', 2).length).toEqual(64)
-      })
-
-      it('should have length of 64 from leading zero', () => {
-        const a = new BigNumber(
-          'fb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
-          16)
-
-        expect(a.toString('hex', 64).length).toEqual(64)
-      })
-    })
-  })
-
-  describe('.isNeg()', () => {
-    it('should return true for negative numbers', () => {
-      expect(new BigNumber(-1).isNeg()).toEqual(true)
-      expect(new BigNumber(1).isNeg()).toEqual(false)
-      expect(new BigNumber(0).isNeg()).toEqual(false)
-      expect(new BigNumber('-0', 10).isNeg()).toEqual(false)
-    })
-  })
-
-  describe('.isOdd()', () => {
-    it('should return true for odd numbers', () => {
-      expect(new BigNumber(0).isOdd()).toEqual(false)
-      expect(new BigNumber(1).isOdd()).toEqual(true)
-      expect(new BigNumber(2).isOdd()).toEqual(false)
-      expect(new BigNumber('-0', 10).isOdd()).toEqual(false)
-      expect(new BigNumber('-1', 10).isOdd()).toEqual(true)
-      expect(new BigNumber('-2', 10).isOdd()).toEqual(false)
-    })
-  })
-
-  describe('.isEven()', () => {
-    it('should return true for even numbers', () => {
-      expect(new BigNumber(0).isEven()).toEqual(true)
-      expect(new BigNumber(1).isEven()).toEqual(false)
-      expect(new BigNumber(2).isEven()).toEqual(true)
-      expect(new BigNumber('-0', 10).isEven()).toEqual(true)
-      expect(new BigNumber('-1', 10).isEven()).toEqual(false)
-      expect(new BigNumber('-2', 10).isEven()).toEqual(true)
-    })
-  })
-
-  describe('.isZero()', () => {
-    it('should return true for zero', () => {
-      expect(new BigNumber(0).isZero()).toEqual(true)
-      expect(new BigNumber(1).isZero()).toEqual(false)
-      expect(new BigNumber(0xffffffff).isZero()).toEqual(false)
-    })
-  })
-
-  describe('.bitLength()', () => {
-    it('should return proper bitLength', () => {
-      expect(new BigNumber(0).bitLength()).toEqual(0)
-      expect(new BigNumber(0x1).bitLength()).toEqual(1)
-      expect(new BigNumber(0x2).bitLength()).toEqual(2)
-      expect(new BigNumber(0x3).bitLength()).toEqual(2)
-      expect(new BigNumber(0x4).bitLength()).toEqual(3)
-      expect(new BigNumber(0x8).bitLength()).toEqual(4)
-      expect(new BigNumber(0x10).bitLength()).toEqual(5)
-      expect(new BigNumber(0x100).bitLength()).toEqual(9)
-      expect(new BigNumber(0x123456).bitLength()).toEqual(21)
-      expect(new BigNumber('123456789', 16).bitLength()).toEqual(33)
-      expect(new BigNumber('8023456789', 16).bitLength()).toEqual(40)
-    })
-  })
-
-  describe('.byteLength()', () => {
-    it('should return proper byteLength', () => {
-      expect(new BigNumber(0).byteLength()).toEqual(0)
-      expect(new BigNumber(0x1).byteLength()).toEqual(1)
-      expect(new BigNumber(0x2).byteLength()).toEqual(1)
-      expect(new BigNumber(0x3).byteLength()).toEqual(1)
-      expect(new BigNumber(0x4).byteLength()).toEqual(1)
-      expect(new BigNumber(0x8).byteLength()).toEqual(1)
-      expect(new BigNumber(0x10).byteLength()).toEqual(1)
-      expect(new BigNumber(0x100).byteLength()).toEqual(2)
-      expect(new BigNumber(0x123456).byteLength()).toEqual(3)
-      expect(new BigNumber('123456789', 16).byteLength()).toEqual(5)
-      expect(new BigNumber('8023456789', 16).byteLength()).toEqual(5)
-    })
-  })
-
-  describe('.toArray()', () => {
-    it('should return [ 0 ] for `0`', () => {
-      const n = new BigNumber(0)
-      expect(n.toArray('be')).toEqual([0])
-      expect(n.toArray('le')).toEqual([0])
-    })
-
-    it('should zero pad to desired lengths', () => {
-      const n = new BigNumber(0x123456)
-      expect(n.toArray('be', 5)).toEqual([0x00, 0x00, 0x12, 0x34, 0x56])
-      expect(n.toArray('le', 5)).toEqual([0x56, 0x34, 0x12, 0x00, 0x00])
-    })
-
-    it('should throw when naturally larger than desired length', () => {
-      const n = new BigNumber(0x123456)
-      expect(() => {
-        n.toArray('be', 2)
-      }).toThrow(new Error('byte array longer than desired length'))
-    })
-  })
-
-  describe('.toNumber()', () => {
-    it('should return proper Number if below the limit', () => {
-      expect(new BigNumber(0x123456).toNumber()).toEqual(0x123456)
-      expect(new BigNumber(0x3ffffff).toNumber()).toEqual(0x3ffffff)
-      expect(new BigNumber(0x4000000).toNumber()).toEqual(0x4000000)
-      expect(new BigNumber(0x10000000000000).toNumber()).toEqual(0x10000000000000)
-      expect(new BigNumber(0x10040004004000).toNumber()).toEqual(0x10040004004000)
-      expect(new BigNumber(-0x123456).toNumber()).toEqual(-0x123456)
-      expect(new BigNumber(-0x3ffffff).toNumber()).toEqual(-0x3ffffff)
-      expect(new BigNumber(-0x4000000).toNumber()).toEqual(-0x4000000)
-      expect(new BigNumber(-0x10000000000000).toNumber()).toEqual(-0x10000000000000)
-      expect(new BigNumber(-0x10040004004000).toNumber()).toEqual(-0x10040004004000)
-    })
-
-    it('should throw when number exceeds 53 bits', () => {
-      const n = new BigNumber(1).iushln(54)
-      expect(() => {
-        n.toNumber()
-      }).toThrow(new Error('Number can only safely store up to 53 bits'))
-    })
-  })
-
-  describe('.zeroBits()', () => {
-    it('should return proper zeroBits', () => {
-      expect(new BigNumber(0).zeroBits()).toEqual(0)
-      expect(new BigNumber(0x1).zeroBits()).toEqual(0)
-      expect(new BigNumber(0x2).zeroBits()).toEqual(1)
-      expect(new BigNumber(0x3).zeroBits()).toEqual(0)
-      expect(new BigNumber(0x4).zeroBits()).toEqual(2)
-      expect(new BigNumber(0x8).zeroBits()).toEqual(3)
-      expect(new BigNumber(0x10).zeroBits()).toEqual(4)
-      expect(new BigNumber(0x100).zeroBits()).toEqual(8)
-      expect(new BigNumber(0x1000000).zeroBits()).toEqual(24)
-      expect(new BigNumber(0x123456).zeroBits()).toEqual(1)
-    })
-  })
-
-  describe('.toJSON', () => {
-    it('should return hex string', () => {
-      expect(new BigNumber(0x123).toJSON()).toEqual('123')
-    })
-  })
-
-  describe('.cmpn', () => {
-    it('should return -1, 0, 1 correctly', () => {
-      expect(new BigNumber(42).cmpn(42)).toEqual(0)
-      expect(new BigNumber(42).cmpn(43)).toEqual(-1)
-      expect(new BigNumber(42).cmpn(41)).toEqual(1)
-      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffe)).toEqual(0)
-      expect(new BigNumber(0x3fffffe).cmpn(0x3ffffff)).toEqual(-1)
-      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffd)).toEqual(1)
-      expect(() => {
-        new BigNumber(0x3fffffe).cmpn(0x4000000)
-      }).toThrow(new Error('Number is too big'))
-      expect(new BigNumber(42).cmpn(-42)).toEqual(1)
-      expect(new BigNumber(-42).cmpn(42)).toEqual(-1)
-      expect(new BigNumber(-42).cmpn(-42)).toEqual(0)
-      expect(1 / new BigNumber(-42).cmpn(-42)).toEqual(Infinity)
-    })
-  })
-
-  describe('.cmp', () => {
-    it('should return -1, 0, 1 correctly', () => {
-      expect(new BigNumber(42).cmp(new BigNumber(42))).toEqual(0)
-      expect(new BigNumber(42).cmp(new BigNumber(43))).toEqual(-1)
-      expect(new BigNumber(42).cmp(new BigNumber(41))).toEqual(1)
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffe))).toEqual(0)
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3ffffff))).toEqual(-1)
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffd))).toEqual(1)
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x4000000))).toEqual(-1)
-      expect(new BigNumber(42).cmp(new BigNumber(-42))).toEqual(1)
-      expect(new BigNumber(-42).cmp(new BigNumber(42))).toEqual(-1)
-      expect(new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(0)
-      expect(1 / new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(Infinity)
-    })
-  })
-
-  describe('comparison shorthands', () => {
-    it('.gtn greater than', () => {
-      expect(new BigNumber(3).gtn(2)).toEqual(true)
-      expect(new BigNumber(3).gtn(3)).toEqual(false)
-      expect(new BigNumber(3).gtn(4)).toEqual(false)
-    })
-    it('.gt greater than', () => {
-      expect(new BigNumber(3).gt(new BigNumber(2))).toEqual(true)
-      expect(new BigNumber(3).gt(new BigNumber(3))).toEqual(false)
-      expect(new BigNumber(3).gt(new BigNumber(4))).toEqual(false)
-    })
-    it('.gten greater than or equal', () => {
-      expect(new BigNumber(3).gten(3)).toEqual(true)
-      expect(new BigNumber(3).gten(2)).toEqual(true)
-      expect(new BigNumber(3).gten(4)).toEqual(false)
-    })
-    it('.gte greater than or equal', () => {
-      expect(new BigNumber(3).gte(new BigNumber(3))).toEqual(true)
-      expect(new BigNumber(3).gte(new BigNumber(2))).toEqual(true)
-      expect(new BigNumber(3).gte(new BigNumber(4))).toEqual(false)
-    })
-    it('.ltn less than', () => {
-      expect(new BigNumber(2).ltn(3)).toEqual(true)
-      expect(new BigNumber(2).ltn(2)).toEqual(false)
-      expect(new BigNumber(2).ltn(1)).toEqual(false)
-    })
-    it('.lt less than', () => {
-      expect(new BigNumber(2).lt(new BigNumber(3))).toEqual(true)
-      expect(new BigNumber(2).lt(new BigNumber(2))).toEqual(false)
-      expect(new BigNumber(2).lt(new BigNumber(1))).toEqual(false)
-    })
-    it('.lten less than or equal', () => {
-      expect(new BigNumber(3).lten(3)).toEqual(true)
-      expect(new BigNumber(3).lten(2)).toEqual(false)
-      expect(new BigNumber(3).lten(4)).toEqual(true)
-    })
-    it('.lte less than or equal', () => {
-      expect(new BigNumber(3).lte(new BigNumber(3))).toEqual(true)
-      expect(new BigNumber(3).lte(new BigNumber(2))).toEqual(false)
-      expect(new BigNumber(3).lte(new BigNumber(4))).toEqual(true)
-    })
-    it('.eqn equal', () => {
-      expect(new BigNumber(3).eqn(3)).toEqual(true)
-      expect(new BigNumber(3).eqn(2)).toEqual(false)
-      expect(new BigNumber(3).eqn(4)).toEqual(false)
-    })
-    it('.eq equal', () => {
-      expect(new BigNumber(3).eq(new BigNumber(3))).toEqual(true)
-      expect(new BigNumber(3).eq(new BigNumber(2))).toEqual(false)
-      expect(new BigNumber(3).eq(new BigNumber(4))).toEqual(false)
-    })
-  })
-
-  describe('.fromTwos', () => {
-    it('should convert from two\'s complement to negative number', () => {
-      expect(new BigNumber('00000000', 16).fromTwos(32).toNumber()).toEqual(0)
-      expect(new BigNumber('00000001', 16).fromTwos(32).toNumber()).toEqual(1)
-      expect(new BigNumber('7fffffff', 16).fromTwos(32).toNumber()).toEqual(2147483647)
-      expect(new BigNumber('80000000', 16).fromTwos(32).toNumber()).toEqual(-2147483648)
-      expect(new BigNumber('f0000000', 16).fromTwos(32).toNumber()).toEqual(-268435456)
-      expect(new BigNumber('f1234567', 16).fromTwos(32).toNumber()).toEqual(-249346713)
-      expect(new BigNumber('ffffffff', 16).fromTwos(32).toNumber()).toEqual(-1)
-      expect(new BigNumber('fffffffe', 16).fromTwos(32).toNumber()).toEqual(-2)
-      expect(new BigNumber('fffffffffffffffffffffffffffffffe', 16)
-        .fromTwos(128).toNumber()).toEqual(-2)
-      expect(new BigNumber('ffffffffffffffffffffffffffffffff' +
-        'fffffffffffffffffffffffffffffffe', 16).fromTwos(256).toNumber()).toEqual(-2)
-      expect(new BigNumber('ffffffffffffffffffffffffffffffff' +
-        'ffffffffffffffffffffffffffffffff', 16).fromTwos(256).toNumber()).toEqual(-1)
-      expect(
-        new BigNumber('7fffffffffffffffffffffffffffffff' +
-        'ffffffffffffffffffffffffffffffff', 16).fromTwos(256).toString(10)).toEqual(new BigNumber('5789604461865809771178549250434395392663499' +
-        '2332820282019728792003956564819967', 10).toString(10))
-      expect(
-        new BigNumber('80000000000000000000000000000000' +
-        '00000000000000000000000000000000', 16).fromTwos(256).toString(10)).toEqual(new BigNumber('-578960446186580977117854925043439539266349' +
-        '92332820282019728792003956564819968', 10).toString(10))
-    })
-  })
-
-  describe('.toTwos', () => {
-    it('should convert from negative number to two\'s complement', () => {
-      expect(new BigNumber(0).toTwos(32).toString(16)).toEqual('0')
-      expect(new BigNumber(1).toTwos(32).toString(16)).toEqual('1')
-      expect(new BigNumber(2147483647).toTwos(32).toString(16)).toEqual('7fffffff')
-      expect(new BigNumber('-2147483648', 10).toTwos(32).toString(16)).toEqual('80000000')
-      expect(new BigNumber('-268435456', 10).toTwos(32).toString(16)).toEqual('f0000000')
-      expect(new BigNumber('-249346713', 10).toTwos(32).toString(16)).toEqual('f1234567')
-      expect(new BigNumber('-1', 10).toTwos(32).toString(16)).toEqual('ffffffff')
-      expect(new BigNumber('-2', 10).toTwos(32).toString(16)).toEqual('fffffffe')
-      expect(new BigNumber('-2', 10).toTwos(128).toString(16)).toEqual(
-        'fffffffffffffffffffffffffffffffe')
-      expect(new BigNumber('-2', 10).toTwos(256).toString(16)).toEqual(
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe')
-      expect(new BigNumber('-1', 10).toTwos(256).toString(16)).toEqual(
-        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
-      expect(
-        new BigNumber('5789604461865809771178549250434395392663' +
-        '4992332820282019728792003956564819967', 10).toTwos(256).toString(16)).toEqual(
-        '7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
-      expect(
-        new BigNumber('-578960446186580977117854925043439539266' +
-        '34992332820282019728792003956564819968', 10).toTwos(256).toString(16)).toEqual(
-        '8000000000000000000000000000000000000000000000000000000000000000')
-    })
-  })
-
-  describe('.isBN', () => {
-    it('should return true for BN', () => {
-      expect(BigNumber.isBN(new BigNumber())).toEqual(true)
-    })
-
-    it('should return false for everything else', () => {
-      expect(BigNumber.isBN(1)).toEqual(false)
-      expect(BigNumber.isBN([])).toEqual(false)
-      expect(BigNumber.isBN({})).toEqual(false)
-    })
-  })
-})