@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/PrivateKey.test.ts

@@ -0,0 +1,98 @@
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import BRC42Private from './BRC42.private.vectors'
+import Curve from '../../primitives/Curve'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('PrivateKey', () => {
+  describe('BRC42 vectors', () => {
+    BRC42Private.forEach((vector, index) => {
+      it(`Passes BRC42 private vector #${index + 1}`, () => {
+        const publicKey = PublicKey.fromString(vector.senderPublicKey)
+        const privateKey = PrivateKey.fromString(vector.recipientPrivateKey)
+        const derived = privateKey.deriveChild(publicKey, vector.invoiceNumber)
+        expect(derived.toHex()).toEqual(vector.privateKey)
+      })
+    })
+  })
+
+  describe('PrivateKey Validation and Conversion', () => {
+    const curve = new Curve()
+
+    const isValidPrivateKey = (key: string): boolean => {
+      try {
+        const keyAsNumber = new BigNumber(key, 16)
+        return (
+          !keyAsNumber.isZero() &&
+          keyAsNumber.cmp(curve.n) < 0 &&
+          key.length === 64
+        )
+      } catch {
+        return false
+      }
+    }
+
+    it('Validates and converts valid private keys between hex and string', () => {
+      const validKeys = [
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+        '8a2f85e08360a04c8a36b7c22c5e9e9a0d3bcf2f95c97db2b8bd90fc5f5ff66a',
+        '1b5a8f2392e6959a7de2b0a58f8a64cc528c9bfc1788ee0d32e1455063e71545'
+      ]
+
+      validKeys.forEach((key) => {
+        const privateKeyFromHex = PrivateKey.fromHex(key)
+        const privateKeyFromString = PrivateKey.fromString(key, 'hex')
+        const privateKeyToHex = privateKeyFromHex.toHex()
+        const privateKeyToString = privateKeyFromString.toString('hex')
+        expect(isValidPrivateKey(privateKeyToHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyToString)).toBe(true)
+
+        // Round-trip conversion checks
+        expect(privateKeyToHex).toEqual(key)
+        expect(privateKeyToString).toEqual(key)
+      })
+    })
+
+    // it('Rejects invalid private keys during validation and conversion', () => {
+    //   const invalidKeys = [
+    //     '0000000000000000000000000000000000000000000000000000000000000000',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141',
+    //     'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+    //     'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe',
+    //     '1234567890abcdef',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd03641',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364',
+    //   ]
+
+    //   invalidKeys.forEach((key, index) => {
+    //     const isValid = isValidPrivateKey(key)
+    //     expect(isValid).toBe(false)
+    //     // Ensure invalid keys throw an error during conversion
+    //     expect(() => PrivateKey.fromHex(key)).toThrow()
+    //     expect(() => PrivateKey.fromString(key, 'hex')).toThrow()
+    //   })
+    // })
+
+    it('Tests 10,000 random private keys for valid conversions', () => {
+      for (let i = 0; i < 10000; i++) {
+        const privateKey = PrivateKey.fromRandom()
+        const privateKeyHex = privateKey.toHex()
+        const privateKeyString = privateKey.toString('hex')
+
+        // Validate the random key's format
+        expect(isValidPrivateKey(privateKeyHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyString)).toBe(true)
+
+        // Round-trip conversion checks
+        const roundTripHex = PrivateKey.fromHex(privateKeyHex).toHex()
+        const roundTripString = PrivateKey.fromString(
+          privateKeyString,
+          'hex'
+        ).toString('hex')
+        expect(roundTripHex).toEqual(privateKeyHex)
+        expect(roundTripString).toEqual(privateKeyString)
+      }
+    })
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/PublicKey.test.ts

@@ -0,0 +1,96 @@
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import Point from '../../primitives/Point'
+import BigNumber from '../../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()) // ✅ Safe access
+      expect(newPublicKey.y?.toHex()).toEqual(publicKey.y?.toHex()) // ✅ Safe access
+    })
+
+    describe('Constructor', () => {
+      it('Should throw when accidentally passing in DER', () => {
+        expect(
+          () =>
+            new PublicKey(
+              '036af279b60aa437d48bb0e2ec0b0c6b5cfaa976663f1f08ad456fd7fff149321d'
+            )
+        ).toThrow()
+      })
+    })
+
+    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.toString()
+        expect(typeof derString).toBe('string')
+        expect(derString.length).toBe(66)
+      })
+
+      test('toDER should return DER encoded number[] of public key', () => {
+        const der = publicKey.toDER()
+        expect(typeof der).toBe('object')
+        expect(der.length).toBe(33)
+      })
+
+      test('fromDER and fromString should result in the same public key', () => {
+        const key = PrivateKey.fromRandom()
+        const original = key.toPublicKey()
+        const toDERResult = original.toDER()
+        const backAndForth = Array.isArray(toDERResult)
+          ? PublicKey.fromString(Buffer.from(toDERResult).toString('hex'))
+          : PublicKey.fromString(toDERResult)
+
+        expect(backAndForth.toString()).toEqual(original.toString())
+      })
+    })
+    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/mobile/node_modules/@bsv/sdk/src/primitives/__tests/Random.test.ts

@@ -0,0 +1,35 @@
+/* eslint-env jest */
+import Random from '../../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))
+  })
+  it('Produces values in valid byte range (0-255)', () => {
+    const bytes = Random(100)
+    bytes.forEach(byte => {
+      expect(byte).toBeGreaterThanOrEqual(0)
+      expect(byte).toBeLessThanOrEqual(255)
+    })
+  })
+  it('Works with various lengths including edge cases', () => {
+    expect(Random(1).length).toBe(1)
+    expect(Random(16).length).toBe(16)
+    expect(Random(32).length).toBe(32)
+    expect(Random(64).length).toBe(64)
+    expect(Random(256).length).toBe(256)
+  })
+  it('Returns an array of numbers', () => {
+    const bytes = Random(10)
+    expect(Array.isArray(bytes)).toBe(true)
+    bytes.forEach(byte => {
+      expect(typeof byte).toBe('number')
+    })
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/Reader.test.ts

@@ -0,0 +1,317 @@
+import BigNumber from '../../primitives/BigNumber'
+import { Reader, Writer, toHex } from '../../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(Buffer.from(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)
+    const bufNegative = Buffer.from('ff', 'hex')
+    const brNegative = new Reader([...bufNegative])
+    expect(brNegative.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)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new Reader([...bufNegative])
+    expect(brNegative.readInt8()).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)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new Reader([...bufNegative])
+    expect(brNegative.readInt8()).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)
+    const bufNegative = Buffer.from('ffffffff', 'hex')
+    const brNegative = new Reader([...bufNegative])
+    expect(brNegative.readInt8()).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')
+  })
+})