@bsv/sdk 1.0.0

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

@@ -0,0 +1,119 @@
+export default [{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 32,
+    "results": {
+        "sha512": "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 2,
+    "dkLen": 32,
+    "results": {
+        "sha512": "e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53c"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 64,
+    "results": {
+        "sha512": "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 2,
+    "dkLen": 64,
+    "results": {
+        "sha512": "e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 4096,
+    "dkLen": 32,
+    "results": {
+        "sha512": "d197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5"
+    }
+},
+{
+    "key": "passwordPASSWORDpassword",
+    "salt": "saltSALTsaltSALTsaltSALTsaltSALTsalt",
+    "iterations": 4096,
+    "dkLen": 40,
+    "results": {
+        "sha512": "8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868c005174dc4ee71115b59f9e60cd953"
+    }
+},
+{
+    "key": "pass\u00000word",
+    "salt": "sa\u00000lt",
+    "iterations": 4096,
+    "dkLen": 16,
+    "results": {
+        "sha512": "336d14366099e8aac2c46c94a8f178d2"
+    }
+},
+{
+    "keyHex": "63ffeeddccbbaa",
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 32,
+    "results": {
+        "sha512": "f69de451247225a7b30cc47632899572bb980f500d7c606ac9b1c04f928a3488"
+    }
+},
+{
+    "description": "Unicode salt, no truncation due to hex",
+    "key": "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+    "saltHex": "6d6e656d6f6e6963e383a1e383bce38388e383abe382abe38299e3838fe38299e382a6e38299e382a1e381afe3829ae381afe38299e3818fe38299e3829de38299e381a1e381a1e38299e58d81e4babae58d81e889b2",
+    "iterations": 2048,
+    "dkLen": 64,
+    "results": {
+        "sha512": "ba553eedefe76e67e2602dc20184c564010859faada929a090dd2c57aacb204ceefd15404ab50ef3e8dbeae5195aeae64b0def4d2eead1cdc728a33ced520ffd"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 10,
+    "results": {
+        "sha512": "867f70cf1ade02cff375"
+    }
+},
+{
+    "key": "password",
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 100,
+    "results": {
+        "sha512": "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce7b532e206c2967d4c7d2ffa460539fc4d4e5eec70125d74c6c7cf86d25284f297907fcea"
+    }
+},
+{
+    "keyUint8Array": [112, 97, 115, 115, 119, 111, 114, 100],
+    "salt": "salt",
+    "iterations": 1,
+    "dkLen": 32,
+    "results": {
+        "sha512": "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252"
+    }
+},
+{
+    "key": "password",
+    "saltUint8Array": [115, 97, 108, 116],
+    "iterations": 1,
+    "dkLen": 32,
+    "results": {
+        "sha512": "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252"
+    }
+}
+]

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

@@ -0,0 +1,17 @@
+import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import BRC42Private from './BRC42.private.vectors'
+
+describe('PrivateKey', () => {
+  describe('BRC42 vectors', () => {
+    for (let i = 0; i < BRC42Private.length; i++) {
+      it(`Passes BRC42 private vector #${i + 1}`, () => {
+        const v = BRC42Private[i]
+        const publicKey = PublicKey.fromString(v.senderPublicKey)
+        const privateKey = PrivateKey.fromString(v.recipientPrivateKey, 16)
+        const derived = privateKey.deriveChild(publicKey, v.invoiceNumber)
+        expect(derived.toHex(32)).toEqual(v.privateKey)
+      })
+    }
+  })
+})

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

@@ -0,0 +1,66 @@
+import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import Point from '../../../dist/cjs/src/primitives/Point'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import BRC42Public from './BRC42.public.vectors'
+
+describe('PublicKey', () => {
+  let privateKey
+  let publicKey
+
+  beforeEach(() => {
+    privateKey = PrivateKey.fromRandom()
+    publicKey = PublicKey.fromPrivateKey(privateKey)
+  })
+
+  describe('Static methods', () => {
+    test('fromPrivateKey should return a valid PublicKey', () => {
+      expect(publicKey).toBeInstanceOf(PublicKey)
+    })
+
+    test('fromDER should create a PublicKey from a string', () => {
+      const pubKeyString = publicKey.toString()
+      const newPublicKey = PublicKey.fromString(pubKeyString)
+      expect(newPublicKey).toBeInstanceOf(PublicKey)
+      expect(newPublicKey.x.toHex()).toEqual(publicKey.x.toHex())
+      expect(newPublicKey.y.toHex()).toEqual(publicKey.y.toHex())
+    })
+  })
+
+  describe('Instance methods', () => {
+    test('deriveSharedSecret should derive a shared secret Point', () => {
+      const sharedSecret = publicKey.deriveSharedSecret(privateKey)
+      expect(sharedSecret).toBeInstanceOf(Point)
+    })
+
+    test('deriveSharedSecret should throw error for invalid public key', () => {
+      const invalidPublicKey = new PublicKey(10, 13)
+      expect(() => {
+        invalidPublicKey.deriveSharedSecret(privateKey)
+      }).toThrow('Public key not valid for ECDH secret derivation')
+    })
+
+    test('verify should return true for valid signature', () => {
+      const message = new BigNumber('deadbeef', 16)
+      const signature = privateKey.sign(message)
+      expect(publicKey.verify(message, signature)).toBe(true)
+    })
+
+    test('toDER should return DER encoded string of public key', () => {
+      const derString = publicKey.toDER()
+      expect(typeof derString).toBe('string')
+      expect(derString.length).toBe(66)
+    })
+  })
+  describe('BRC42 vectors', () => {
+    for (let i = 0; i < BRC42Public.length; i++) {
+      it(`Passes BRC42 public vector #${i + 1}`, () => {
+        const v = BRC42Public[i]
+        const publicKey = PublicKey.fromString(v.recipientPublicKey)
+        const privateKey = PrivateKey.fromString(v.senderPrivateKey, 16)
+        const derived = publicKey.deriveChild(privateKey, v.invoiceNumber)
+        expect(derived.toString()).toEqual(v.publicKey)
+      })
+    }
+  })
+})

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

@@ -0,0 +1,14 @@
+/* eslint-env jest */
+import Random from '../../../dist/cjs/src/primitives/Random'
+
+describe('Random', () => {
+  it('Produces random bytes of correct length', () => {
+    expect(Random(3).length).toBe(3)
+    expect(Random(10).length).toBe(10)
+  })
+  it('Does not produce the same thing every time', () => {
+    // While this test may fail once every few hundred trillion years or so,
+    // I haven't seen it fail yet. If you see it fail, please let me know.
+    expect(Random(32)).not.toEqual(Random(32))
+  })
+})

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

@@ -0,0 +1,296 @@
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import { Reader, Writer, toHex } from '../../../dist/cjs/src/primitives/utils'
+
+describe('Reader', () => {
+  it('should make a new Br', () => {
+    let br = new Reader()
+    expect(br).toBeDefined()
+    br = new Reader()
+    expect(br).toBeDefined()
+  })
+
+  it('should create a new Reader with an Array', () => {
+    const arr = []
+    const br = new Reader(arr)
+    expect(br).toBeDefined()
+    expect(Array.isArray(br.bin)).toBeTruthy()
+  })
+
+  describe('#eof', () => {
+    it('should return true for a blank br', () => {
+      const br = new Reader(Buffer.from([]))
+      expect(br.eof()).toBeTruthy()
+    })
+  })
+
+  describe('#read', () => {
+    it('should return the same buffer', () => {
+      const buf = Buffer.from([0])
+      const br = new Reader(buf)
+      expect(br.read().toString('hex')).toEqual(buf.toString('hex'))
+    })
+
+    it('should return a buffer of this length', () => {
+      const buf = Buffer.alloc(10)
+      buf.fill(0)
+      const br = new Reader(buf)
+      const buf2 = br.read(2)
+      expect(buf2.length).toEqual(2)
+      expect(br.eof()).toBeFalsy()
+      expect(br.pos).toEqual(2)
+    })
+
+    it('should be able to read 0 bytes', () => {
+      const buf = Buffer.from('0101', 'hex')
+      expect(new Reader(buf).read(0).length).toEqual(0)
+    })
+  })
+
+  describe('#readReverse', () => {
+    it('should reverse this [0, 1]', () => {
+      const buf = Buffer.from([0, 1])
+      const br = new Reader(buf)
+      expect(toHex(br.readReverse())).toEqual('0100')
+    })
+
+    it('should be able to read 0 bytes', () => {
+      const buf = Buffer.from('0101', 'hex')
+      expect(new Reader(buf).readReverse(0).length).toEqual(0)
+    })
+  })
+
+  describe('#readUInt8', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(1)
+      buf.writeUInt8(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt8()).toEqual(1)
+    })
+  })
+
+  describe('#readInt8', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(1)
+      buf.writeInt8(1, 0)
+      const br = new Reader(buf)
+      expect(br.readInt8()).toEqual(1)
+      expect(new Reader(Buffer.from('ff', 'hex')).readInt8()).toEqual(-1)
+    })
+  })
+
+  describe('#readUInt16BE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(2)
+      buf.writeUInt16BE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt16BE()).toEqual(1)
+    })
+  })
+
+  describe('#readInt16BE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(2)
+      buf.writeInt16BE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readInt16BE()).toEqual(1)
+      expect(new Reader(Buffer.from('ffff', 'hex')).readInt16BE()).toEqual(-1)
+    })
+  })
+
+  describe('#readUInt16LE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(2)
+      buf.writeUInt16LE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt16LE()).toEqual(1)
+    })
+  })
+
+  describe('#readInt16LE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(2)
+      buf.writeInt16LE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readInt16LE()).toEqual(1)
+      expect(new Reader(Buffer.from('ffff', 'hex')).readInt16LE()).toEqual(-1)
+    })
+  })
+
+  describe('#readUInt32BE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(4)
+      buf.writeUInt32BE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt32BE()).toEqual(1)
+    })
+  })
+
+  describe('#readInt32BE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(4)
+      buf.writeInt32BE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readInt32BE()).toEqual(1)
+      expect(new Reader(Buffer.from('ffffffff', 'hex')).readInt32BE()).toEqual(-1)
+    })
+  })
+
+  describe('#readUInt32LE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(4)
+      buf.writeUInt32LE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt32LE()).toEqual(1)
+    })
+  })
+
+  describe('#readInt32LE', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(4)
+      buf.writeInt32LE(1, 0)
+      const br = new Reader([...buf])
+      expect(br.readInt32LE()).toEqual(1)
+      expect(new Reader([...Buffer.from('ffffffff', 'hex')]).readInt32LE()).toEqual(-1)
+    })
+  })
+
+  describe('#readUInt64BEBn', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0)
+      buf.writeUInt32BE(1, 4)
+      const br = new Reader(buf)
+      expect(br.readUInt64BEBn().toNumber()).toEqual(1)
+    })
+
+    it('should return 2^64', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0xff)
+      const br = new Reader(buf)
+      expect(br.readUInt64BEBn().toHex()).toEqual('ffffffffffffffff')
+    })
+  })
+
+  describe('#readUInt64LEBn', () => {
+    it('should return 1', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0)
+      buf.writeUInt32LE(1, 0)
+      const br = new Reader(buf)
+      expect(br.readUInt64LEBn().toNumber()).toEqual(1)
+    })
+
+    it('should return 2^30', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0)
+      buf.writeUInt32LE(Math.pow(2, 30), 0)
+      const br = new Reader(buf)
+      expect(br.readUInt64LEBn().toNumber()).toEqual(Math.pow(2, 30))
+    })
+
+    it('should return 0', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0)
+      const br = new Reader(buf)
+      expect(br.readUInt64LEBn().toNumber()).toEqual(0)
+    })
+
+    it('should return 2^64', () => {
+      const buf = Buffer.alloc(8)
+      buf.fill(0xff)
+      const br = new Reader(buf)
+      expect(br.readUInt64LEBn().toHex()).toEqual('ffffffffffffffff')
+    })
+  })
+
+  describe('#readVarInt', () => {
+    it('should read a 1 byte varInt', () => {
+      const buf = Buffer.from([50])
+      const br = new Reader(buf)
+      expect(br.readVarInt().length).toEqual(1)
+    })
+
+    it('should read a 3 byte varInt', () => {
+      const buf = Buffer.from([253, 253, 0])
+      const br = new Reader(buf)
+      expect(br.readVarInt().length).toEqual(3)
+    })
+
+    it('should read a 5 byte varInt', () => {
+      const buf = Buffer.from([254, 0, 0, 0, 0])
+      buf.writeUInt32LE(50000, 1)
+      const br = new Reader(buf)
+      expect(br.readVarInt().length).toEqual(5)
+    })
+
+    it('should read a 9 byte varInt', () => {
+      const buf = new Writer().writeVarIntBn(new BigNumber(Math.pow(2, 54).toString())).toArray()
+      const br = new Reader(buf)
+      expect(br.readVarInt().length).toEqual(9)
+    })
+  })
+
+  describe('#readVarIntNum', () => {
+    it('should read a 1 byte varInt', () => {
+      const buf = Buffer.from([50])
+      const br = new Reader(buf)
+      expect(br.readVarIntNum()).toEqual(50)
+    })
+
+    it('should read a 3 byte varInt', () => {
+      const buf = Buffer.from([253, 253, 0])
+      const br = new Reader(buf)
+      expect(br.readVarIntNum()).toEqual(253)
+    })
+
+    it('should read a 5 byte varInt', () => {
+      const buf = Buffer.from([254, 0, 0, 0, 0])
+      buf.writeUInt32LE(50000, 1)
+      const br = new Reader(buf)
+      expect(br.readVarIntNum()).toEqual(50000)
+    })
+
+    it('should throw an error on a 9 byte varInt over the javascript uint precision limit', () => {
+      const buf = new Writer().writeVarIntBn(new BigNumber(Math.pow(2, 54).toString())).toArray()
+      const br = new Reader(buf)
+      expect(() => {
+        br.readVarIntNum()
+      }).toThrow('number too large to retain precision - use readVarIntBn')
+    })
+
+    it('should not throw an error on a 9 byte varInt not over the javascript uint precision limit', () => {
+      const buf = new Writer().writeVarIntBn(new BigNumber(Math.pow(2, 53).toString())).toArray()
+      const br = new Reader(buf)
+      expect(() => {
+        br.readVarIntNum()
+      }).not.toThrow('number too large to retain precision - use readVarIntBn')
+    })
+  })
+
+  describe('#readVarIntBn', () => {
+    it('should read a 1 byte varInt', () => {
+      const buf = Buffer.from([50])
+      const br = new Reader(buf)
+      expect(br.readVarIntBn().toNumber()).toEqual(50)
+    })
+
+    it('should read a 3 byte varInt', () => {
+      const buf = Buffer.from([253, 253, 0])
+      const br = new Reader(buf)
+      expect(br.readVarIntBn().toNumber()).toEqual(253)
+    })
+
+    it('should read a 5 byte varInt', () => {
+      const buf = Buffer.from([254, 0, 0, 0, 0])
+      buf.writeUInt32LE(50000, 1)
+      const br = new Reader(buf)
+      expect(br.readVarIntBn().toNumber()).toEqual(50000)
+    })
+
+    it('should read a 9 byte varInt', () => {
+      const buf = Buffer.concat([Buffer.from([255]), Buffer.from('ffffffffffffffff', 'hex')])
+      const br = new Reader(buf)
+      expect(br.readVarIntBn().toHex()).toEqual('ffffffffffffffff')
+    })
+  })
+})