@bsv/sdk 1.0.0

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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,347 @@
+/* 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)
+    })
+  })
+})