@bsv/sdk 1.0.0

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

@@ -0,0 +1,279 @@
+/* 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

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

@@ -0,0 +1,40 @@
+/**
+ * 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

@@ -0,0 +1,198 @@
+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)
+    })
+  })
+})