@bsv/sdk 1.0.0 → 1.0.1

package/src/primitives/__tests/ReductionContext.test.ts

@@ -1,279 +0,0 @@
-/* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import ReductionContext from '../../../dist/cjs/src/primitives/ReductionContext'
-import MontgomoryMethod from '../../../dist/cjs/src/primitives/MontgomoryMethod'
-import K256 from '../../../dist/cjs/src/primitives/K256'
-
-describe('BN.js/Reduction context', function () {
-  const testMethod = (name: string, Method): void => {
-    describe(name + ' method', function () {
-      it('should support add, iadd, sub, isub operations', () => {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(123).toRed(m)
-        const b = new BigNumber(231).toRed(m)
-
-        expect(a.redAdd(b).fromRed().toString(10)).toEqual('97')
-        expect(a.redSub(b).fromRed().toString(10)).toEqual('149')
-        expect(b.redSub(a).fromRed().toString(10)).toEqual('108')
-
-        expect(a.clone().redIAdd(b).fromRed().toString(10)).toEqual('97')
-        expect(a.clone().redISub(b).fromRed().toString(10)).toEqual('149')
-        expect(b.clone().redISub(a).fromRed().toString(10)).toEqual('108')
-      })
-
-      it('should support pow and mul operations', () => {
-        const p192 = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16)
-        const m = new Method(p192)
-        const a = new BigNumber(123)
-        const b = new BigNumber(231)
-        const c = a.toRed(m).redMul(b.toRed(m)).fromRed()
-        expect(c.cmp(a.mul(b).mod(p192))).toEqual(0)
-
-        expect(a.toRed(m).redPow(new BigNumber(0)).fromRed()
-          .cmp(new BigNumber(1))).toEqual(0)
-        expect(a.toRed(m).redPow(new BigNumber(3)).fromRed()
-          .cmp(a.sqr().mul(a))).toEqual(0)
-        expect(a.toRed(m).redPow(new BigNumber(4)).fromRed()
-          .cmp(a.sqr().sqr())).toEqual(0)
-        expect(a.toRed(m).redPow(new BigNumber(8)).fromRed()
-          .cmp(a.sqr().sqr().sqr())).toEqual(0)
-        expect(a.toRed(m).redPow(new BigNumber(9)).fromRed()
-          .cmp(a.sqr().sqr().sqr().mul(a))).toEqual(0)
-        expect(a.toRed(m).redPow(new BigNumber(17)).fromRed()
-          .cmp(a.sqr().sqr().sqr().sqr().mul(a))).toEqual(0)
-        expect(
-          a.toRed(m).redPow(new BigNumber('deadbeefabbadead', 16)).fromRed()
-            .toString(16)).toEqual('3aa0e7e304e320b68ef61592bcb00341866d6fa66e11a4d6')
-      })
-
-      it('should sqrtm numbers', () => {
-        let p = new BigNumber(263)
-        let m = new Method(p)
-        let q = new BigNumber(11).toRed(m)
-
-        let qr = q.redSqrt()
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        qr = q.redSqrt()
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        p = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16)
-        m = new Method(p)
-
-        q = new BigNumber(13).toRed(m)
-        qr = q.redSqrt(/* true, p */)
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        qr = q.redSqrt(/* false, p */)
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        // Tonelli-shanks
-        p = new BigNumber(13)
-        m = new Method(p)
-        q = new BigNumber(10).toRed(m)
-        expect(q.redSqrt().fromRed().toString(10)).toEqual('7')
-      })
-
-      it('should invm numbers', function () {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(3).toRed(m)
-        const b = a.redInvm()
-        expect(a.redMul(b).fromRed().toString(16)).toEqual('1')
-      })
-
-      it('should invm numbers (regression)', function () {
-        const p = new BigNumber(
-          'ffffffff00000001000000000000000000000000ffffffffffffffffffffffff',
-          16)
-        let a = new BigNumber(
-          'e1d969b8192fbac73ea5b7921896d6a2263d4d4077bb8e5055361d1f7f8163f3',
-          16)
-
-        const m = new Method(p)
-        a = a.toRed(m)
-
-        expect(a.redInvm().fromRed().negative).toEqual(0)
-      })
-
-      it('should imul numbers', function () {
-        const p = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16)
-        const m = new Method(p)
-
-        const a = new BigNumber('deadbeefabbadead', 16)
-        const b = new BigNumber('abbadeadbeefdead', 16)
-        const c = a.mul(b).mod(p)
-
-        expect(a.toRed(m).redIMul(b.toRed(m)).fromRed().toString(16))
-          .toEqual(c.toString(16))
-      })
-
-      it('should pow(base, 0) == 1', function () {
-        const base = new BigNumber(256).toRed(new ReductionContext('k256'))
-        const exponent = new BigNumber(0)
-        const result = base.redPow(exponent)
-        expect(result.toString()).toEqual('1')
-      })
-
-      it('should shl numbers', function () {
-        const base = new BigNumber(256).toRed(new ReductionContext('k256'))
-        const result = base.redShl(1)
-        expect(result.toString()).toEqual('512')
-      })
-
-      it('should reduce when converting to red', function () {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(5).toRed(m)
-
-        expect(() => {
-          const b = a.redISub(new BigNumber(512).toRed(m))
-          b.redISub(new BigNumber(512).toRed(m))
-        }).not.toThrow()
-      })
-
-      it('redNeg and zero value', function () {
-        const a = new BigNumber(0).toRed(new ReductionContext('k256')).redNeg()
-        expect(a.isZero()).toEqual(true)
-      })
-
-      it('should not allow modulus <= 1', function () {
-        expect(() => {
-          return new ReductionContext(new BigNumber(0))
-        }).toThrow(new Error('modulus must be greater than 1'))
-
-        expect(() => {
-          return new ReductionContext(new BigNumber(1))
-        }).toThrow(new Error('modulus must be greater than 1'))
-
-        expect(() => {
-          return new ReductionContext(new BigNumber(2))
-        }).not.toThrow()
-      })
-    })
-  }
-
-  testMethod('Plain', ReductionContext)
-  testMethod('Montgomery', MontgomoryMethod)
-
-  describe('Pseudo-Mersenne Primes', function () {
-    it('should reduce numbers mod k256', function () {
-      const p = new K256()
-
-      expect(p.ireduce(new BigNumber(0xdead)).toString(16)).toEqual('dead')
-      expect(p.ireduce(new BigNumber('deadbeef', 16)).toString(16)).toEqual('deadbeef')
-
-      const num = new BigNumber(
-        'fedcba9876543210fedcba9876543210dead' +
-        'fedcba9876543210fedcba9876543210dead',
-        16)
-      let exp = num.mod(p.p).toString(16)
-      expect(p.ireduce(num).toString(16)).toEqual(exp)
-
-      const regr = new BigNumber(
-        'f7e46df64c1815962bf7bc9c56128798' +
-        '3f4fcef9cb1979573163b477eab93959' +
-        '335dfb29ef07a4d835d22aa3b6797760' +
-        '70a8b8f59ba73d56d01a79af9',
-        16)
-      exp = regr.mod(p.p).toString(16)
-
-      expect(p.ireduce(regr).toString(16)).toEqual(exp)
-    })
-
-    it('should not fail to invm number mod k256', function () {
-      let regr2 = new BigNumber(
-        '6c150c4aa9a8cf1934485d40674d4a7cd494675537bda36d49405c5d2c6f496f', 16)
-      regr2 = regr2.toRed(new ReductionContext('k256'))
-      expect(regr2.redInvm().redMul(regr2).fromRed().cmpn(1)).toEqual(0)
-    })
-
-    it('should correctly square the number', function () {
-      const p = new K256().p
-      const red = new ReductionContext('k256')
-
-      const n = new BigNumber(
-        '9cd8cb48c3281596139f147c1364a3ed' +
-        'e88d3f310fdb0eb98c924e599ca1b3c9',
-        16)
-      const expected = n.sqr().mod(p)
-      const actual = n.toRed(red).redSqr().fromRed()
-
-      expect(actual.toString(16)).toEqual(expected.toString(16))
-    })
-
-    it('redISqr should return right result', function () {
-      const n = new BigNumber('30f28939', 16)
-      const actual = n.toRed(new ReductionContext('k256')).redISqr().fromRed()
-      expect(actual.toString(16)).toEqual('95bd93d19520eb1')
-    })
-  })
-
-  it('should avoid 4.1.0 regresion', function () {
-    const bits2int = (obits, q): BigNumber => {
-      const bits = new BigNumber(obits)
-      const shift = (obits.length << 3) - q.bitLength()
-      if (shift > 0) {
-        bits.ishrn(shift)
-      }
-      return bits
-    }
-    const t = Buffer.from('aff1651e4cd6036d57aa8b2a05ccf1a9d5a40166340ecbbdc55' +
-      'be10b568aa0aa3d05ce9a2fcec9df8ed018e29683c6051cb83e' +
-      '46ce31ba4edb045356a8d0d80b', 'hex')
-    const g = new BigNumber(
-      '5c7ff6b06f8f143fe8288433493e4769c4d988ace5be25a0e24809670' +
-      '716c613d7b0cee6932f8faa7c44d2cb24523da53fbe4f6ec3595892d1' +
-      'aa58c4328a06c46a15662e7eaa703a1decf8bbb2d05dbe2eb956c142a' +
-      '338661d10461c0d135472085057f3494309ffa73c611f78b32adbb574' +
-      '0c361c9f35be90997db2014e2ef5aa61782f52abeb8bd6432c4dd097b' +
-      'c5423b285dafb60dc364e8161f4a2a35aca3a10b1c4d203cc76a470a3' +
-      '3afdcbdd92959859abd8b56e1725252d78eac66e71ba9ae3f1dd24871' +
-      '99874393cd4d832186800654760e1e34c09e4d155179f9ec0dc4473f9' +
-      '96bdce6eed1cabed8b6f116f7ad9cf505df0f998e34ab27514b0ffe7',
-      16)
-    const p = new BigNumber(
-      '9db6fb5951b66bb6fe1e140f1d2ce5502374161fd6538df1648218642' +
-      'f0b5c48c8f7a41aadfa187324b87674fa1822b00f1ecf8136943d7c55' +
-      '757264e5a1a44ffe012e9936e00c1d3e9310b01c7d179805d3058b2a9' +
-      'f4bb6f9716bfe6117c6b5b3cc4d9be341104ad4a80ad6c94e005f4b99' +
-      '3e14f091eb51743bf33050c38de235567e1b34c3d6a5c0ceaa1a0f368' +
-      '213c3d19843d0b4b09dcb9fc72d39c8de41f1bf14d4bb4563ca283716' +
-      '21cad3324b6a2d392145bebfac748805236f5ca2fe92b871cd8f9c36d' +
-      '3292b5509ca8caa77a2adfc7bfd77dda6f71125a7456fea153e433256' +
-      'a2261c6a06ed3693797e7995fad5aabbcfbe3eda2741e375404ae25b',
-      16)
-    const q = new BigNumber('f2c3119374ce76c9356990b465374a17f23f9ed35089bd969f61c6dde' +
-      '9998c1f', 16)
-    const k = bits2int(t, q)
-    const expectedR = '89ec4bb1400eccff8e7d9aa515cd1de7803f2daff09693ee7fd1353e' +
-      '90a68307'
-    const r = g.toRed(new MontgomoryMethod(p)).redPow(k).fromRed().mod(q)
-    expect(r.toString(16)).toEqual(expectedR)
-  })
-
-  it('K256.split for 512 bits number should return equal numbers', function () {
-    const red = new ReductionContext('k256')
-    const input = new BigNumber(1).iushln(512).subn(1)
-    expect(input.bitLength()).toEqual(512)
-    const output = new BigNumber(0)
-    red.prime?.split(input, output)
-    expect(input.cmp(output)).toEqual(0)
-  })
-
-  it('imod should change host object', function () {
-    const red = new ReductionContext(new BigNumber(13))
-    const a = new BigNumber(2).toRed(red)
-    const b = new BigNumber(7).toRed(red)
-    const c = a.redIMul(b)
-    expect(a.toNumber()).toEqual(1)
-    expect(c.toNumber()).toEqual(1)
-  })
-})

package/src/primitives/__tests/SymmetricKey.test.ts

@@ -1,58 +0,0 @@
-import SymmetricKey from '../../../dist/cjs/src/primitives/SymmetricKey'
-import vectors from './SymmetricKey.vectors'
-
-const KEYS: SymmetricKey[] = [
-  new SymmetricKey('5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458', 16),
-  new SymmetricKey('bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4', 16),
-  new SymmetricKey('53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10', 16)
-]
-
-const PLAINTEXT_1 = 'hello there'
-const CIPHERTEXT_1 = '8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52'
-
-describe('SymmetricKey', () => {
-  it('Produces output that can be decrypted', () => {
-    const originalValue = 'a thing to encrypt'
-    const encryptedValue = KEYS[2].encrypt(originalValue)
-    const decryptedValue = KEYS[2].decrypt(encryptedValue, 'utf8')
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  it('Encrypts values as an array', () => {
-    const originalValue = [42, 99, 33, 0, 1]
-    const encryptedValue = KEYS[2].encrypt(
-      originalValue
-    )
-    const decryptedValue = KEYS[2].decrypt(
-      encryptedValue
-    )
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  it('Decrypts a correctly-encrypted value', () => {
-    const result = KEYS[0].decrypt(CIPHERTEXT_1, 'hex') as string
-    expect(Buffer.from(result, 'hex').toString('utf8')).toEqual(PLAINTEXT_1)
-  })
-  it('Throws a useful error when decryption fails', () => {
-    expect(() => {
-      KEYS[2].decrypt(
-        CIPHERTEXT_1,
-        'hex'
-      )
-    }).toThrow(new Error('Decryption failed!'))
-  })
-  it('decrypts values encrypted with the encrypt function', () => {
-    const originalValue = 'secret value'
-    const encryptedValue = KEYS[1].encrypt(originalValue)
-    const decryptedValue = KEYS[1].decrypt(encryptedValue, 'utf8')
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  vectors.forEach((vector, index) => {
-    it(`Should pass test vector #${index + 1}`, () => {
-      const key = new SymmetricKey([...Buffer.from(vector.key, 'base64')])
-      const result = key.decrypt(
-        [...Buffer.from(vector.ciphertext, 'base64')],
-        'hex'
-      )
-      expect(result).toEqual(Buffer.from(vector.plaintext).toString('hex'))
-    })
-  })
-})

package/src/primitives/__tests/SymmetricKey.vectors.ts

@@ -1,40 +0,0 @@
-/**
- * These vectors check our implementation of AES-GCM encryption.
- *
- * The first 32 bytes of the ciphertext contain the initialization vector and
- * the rest is the AES-GCM ciphertext.
- *
- * The plaintext is whatever we want to encrypt represented as a string.
- *
- * Because the initialization vector is generated randomly during the
- * encryption process, we cannot use determanistic test vectors to test the
- * encrypt functionality. Therefore, only the test runner for the decrypt
- * function will execute and validate against the vectors.
- */
-export default [
-  {
-    ciphertext: '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
-    key: 'LIe9CoVXxDDDKt9F4j2lE+GP4oPcMElwyX+LVsuRLqw=',
-    plaintext: '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
-  },
-  {
-    ciphertext: 'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
-    key: 'Di30+CTH8yKVJfXmbkRU6DOesD042IkjZCbFL1lnNqY=',
-    plaintext: '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
-  },
-  {
-    ciphertext: 'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
-    key: 'v7kFn4JdB3OVVjy8lk7UTvWe0vY5Qyzn64Q0EVoezlU=',
-    plaintext: 'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
-  },
-  {
-    ciphertext: 'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
-    key: 'qIgnjD0FfGVMiWo107bP0oHsLA402lhC7AYUFIKY1KQ=',
-    plaintext: 'A cat and a mouse.'
-  },
-  {
-    ciphertext: 'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
-    key: 'K7E/bf3wp6hrVeW0V1KvFJS5JZMhyxwPHCIW6wKBTb0=',
-    plaintext: 'üñîçø∂é'
-  }
-]

package/src/primitives/__tests/Writer.test.ts

@@ -1,198 +0,0 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import { Reader, Writer, encode } from '../../../dist/cjs/src/primitives/utils'
-
-describe('Writer', () => {
-  it('should create a new buffer writer', () => {
-    const bw = new Writer()
-    expect(bw).toBeDefined()
-  })
-
-  describe('#getLength', () => {
-    it('should compute length correctly of two 2 byte buffers', () => {
-      const buf1 = Buffer.from('0000', 'hex')
-      const buf2 = Buffer.from('0000', 'hex')
-      const bw = new Writer().write(buf1).write(buf2)
-      expect(bw.getLength()).toEqual(4)
-    })
-  })
-
-  describe('#toArray', () => {
-    it('should concat these two bufs', () => {
-      const buf1 = [0]
-      const buf2 = [1]
-      const bw = new Writer([buf1, buf2])
-      expect(encode(bw.toArray(), 'hex')).toEqual('0001')
-    })
-  })
-
-  describe('#write', () => {
-    it('should write a buffer', () => {
-      const buf = [0]
-      const bw = new Writer()
-      bw.write(buf)
-      expect(encode(bw.toArray(), 'hex')).toEqual('00')
-    })
-  })
-
-  describe('#writeReverse', () => {
-    it('should write a buffer in reverse', () => {
-      const buf = [0, 1]
-      const bw = new Writer()
-      bw.writeReverse(buf)
-      expect(encode(bw.toArray(), 'hex')).toEqual('0100')
-    })
-  })
-
-  describe('#writeUInt8', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt8(1).toArray(), 'hex')).toEqual('01')
-    })
-  })
-
-  describe('#writeInt8', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt8(1).toArray(), 'hex')).toEqual('01')
-      expect(
-        encode(new Writer().writeInt8(-1).toArray(), 'hex')
-      ).toEqual('ff')
-    })
-  })
-
-  describe('#writeUInt16BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt16BE(1).toArray(), 'hex')).toEqual('0001')
-    })
-  })
-
-  describe('#writeInt16BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt16BE(1).toArray(), 'hex')).toEqual('0001')
-      expect(encode(new Writer().writeInt16BE(-1).toArray(), 'hex')).toEqual('ffff')
-    })
-  })
-
-  describe('#writeUInt16LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt16LE(1).toArray(), 'hex')).toEqual('0100')
-    })
-  })
-
-  describe('#writeInt16LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt16LE(1).toArray(), 'hex')).toEqual('0100')
-      expect(encode(new Writer().writeInt16LE(-1).toArray(), 'hex')).toEqual('ffff')
-    })
-  })
-
-  describe('#writeUInt32BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt32BE(1).toArray(), 'hex')).toEqual('00000001')
-    })
-  })
-
-  describe('#writeInt32BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt32BE(1).toArray(), 'hex')).toEqual('00000001')
-      expect(encode(new Writer().writeInt32BE(-1).toArray(), 'hex')).toEqual('ffffffff')
-    })
-  })
-
-  describe('#writeUInt32LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt32LE(1).toArray(), 'hex')).toEqual('01000000')
-    })
-  })
-
-  describe('#writeInt32LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt32LE(1).toArray(), 'hex')).toEqual('01000000')
-      expect(encode(new Writer().writeInt32LE(-1).toArray(), 'hex')).toEqual('ffffffff')
-    })
-  })
-
-  describe('#writeUInt64BEBn', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')).toEqual('0000000000000001')
-    })
-  })
-
-  describe('#writeUInt64LEBn', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')).toEqual('0100000000000000')
-    })
-  })
-
-  describe('#writeVarInt', () => {
-    it('should write a 1 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(1)
-      expect(bw.toArray().length).toEqual(1)
-    })
-
-    it('should write a 3 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(1000)
-      expect(bw.toArray().length).toEqual(3)
-    })
-
-    it('should write a 5 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(Math.pow(2, 16 + 1))
-      expect(bw.toArray().length).toEqual(5)
-    })
-
-    it('should write a 9 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(Math.pow(2, 32 + 1))
-      expect(bw.toArray().length).toEqual(9)
-    })
-
-    it('should read back the same value it wrote for a 9 byte varInt', () => {
-      const bw = new Writer()
-      const n = Math.pow(2, 53)
-      expect(n).toEqual(n + 1) // javascript number precision limit
-      bw.writeVarIntNum(n)
-      const br = new Reader(bw.toArray())
-      expect(br.readVarIntBn().toHex()).toEqual('20000000000000')
-    })
-  })
-
-  describe('#writeVarIntBn', () => {
-    it('should write a 1 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(1))
-      expect(bw.toArray().length).toEqual(1)
-    })
-
-    it('should write a 3 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(1000))
-      expect(bw.toArray().length).toEqual(3)
-    })
-
-    it('should write a 5 byte varInt', () => {
-      const bw = new Writer()
-      const bn = new BigNumber(Math.pow(2, 16 + 1))
-      bw.writeVarIntBn(bn)
-      expect(bw.toArray().length).toEqual(5)
-    })
-
-    it('should write a 9 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(Math.pow(2, 32 + 1)))
-      expect(bw.toArray().length).toEqual(9)
-    })
-  })
-})