@bsv/sdk 2.0.12 → 2.0.13

package/src/primitives/__tests/Hash.additional.test.ts

@@ -0,0 +1,59 @@
+import { SHA1HMAC, SHA512HMAC, pbkdf2 } from '../../primitives/Hash'
+
+describe('Hash – additional coverage', () => {
+  describe('SHA1HMAC', () => {
+    it('produces a correct HMAC-SHA1 digest', () => {
+      // SHA1HMAC constructor calls toArray(key, 'hex'), so key must be hex
+      const hmac = new SHA1HMAC('deadbeef')
+      const result = hmac.update('abcd', 'hex').digest()
+      expect(result).toHaveLength(20)
+    })
+
+    it('returns a hex string from digestHex()', () => {
+      const hmac = new SHA1HMAC('deadbeef')
+      const result = hmac.update('deadbeef', 'hex').digestHex()
+      expect(typeof result).toBe('string')
+      expect(result).toHaveLength(40) // SHA1 = 20 bytes = 40 hex chars
+    })
+
+    it('handles a key longer than 64 bytes (key hashed internally)', () => {
+      // Key longer than SHA1 blockSize (64 bytes) → key is SHA1-hashed.
+      // Each hex byte is 2 chars, so 65 bytes = 130 hex chars.
+      const longKey = 'ab'.repeat(65) // 65 bytes when decoded from hex
+      const hmac = new SHA1HMAC(longKey)
+      const result = hmac.update('deadbeef', 'hex').digest()
+      expect(result).toHaveLength(20)
+    })
+  })
+
+  describe('SHA512HMAC', () => {
+    it('produces a correct HMAC-SHA512 digest', () => {
+      // SHA512HMAC string key is treated as hex
+      const hmac = new SHA512HMAC('deadbeef')
+      const result = hmac.update('message').digest()
+      expect(result).toHaveLength(64) // SHA512 = 64 bytes
+    })
+
+    it('returns a hex string from digestHex()', () => {
+      const hmac = new SHA512HMAC('deadbeef')
+      const result = hmac.update(new Uint8Array([1, 2, 3])).digestHex()
+      expect(typeof result).toBe('string')
+      expect(result).toHaveLength(128) // SHA512 = 64 bytes = 128 hex chars
+    })
+
+    it('accepts a Uint8Array key', () => {
+      const key = new Uint8Array([1, 2, 3, 4])
+      const hmac = new SHA512HMAC(key)
+      const result = hmac.update(new Uint8Array([5, 6, 7])).digest()
+      expect(result).toHaveLength(64)
+    })
+  })
+
+  describe('pbkdf2', () => {
+    it('throws when digest is not sha512', () => {
+      expect(() => pbkdf2([1, 2, 3], [4, 5, 6], 1, 32, 'sha256')).toThrow(
+        'Only sha512 is supported in this PBKDF2 implementation'
+      )
+    })
+  })
+})

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

@@ -0,0 +1,308 @@
+import Curve from '../../primitives/Curve'
+import Point from '../../primitives/Point'
+import JacobianPoint from '../../primitives/JacobianPoint'
+import BigNumber from '../../primitives/BigNumber'
+
+const G_COMPRESSED = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
+
+describe('JacobianPoint', () => {
+  const curve = new Curve()
+  const G = curve.g as Point
+
+  // --------------------------------------------------------------------------
+  // Constructor
+  // --------------------------------------------------------------------------
+  describe('constructor', () => {
+    it('creates point at infinity when all null', () => {
+      const jp = new JacobianPoint(null, null, null)
+      expect(jp.isInfinity()).toBe(true)
+    })
+
+    it('creates point from string coordinates', () => {
+      // Use coordinates of 2G in affine form
+      const g2 = G.mul(new BigNumber(2))
+      const xHex = g2.getX().toString(16)
+      const yHex = g2.getY().toString(16)
+      const jp = new JacobianPoint(xHex, yHex, '1')
+      expect(jp.isInfinity()).toBe(false)
+    })
+
+    it('creates point from BigNumber coordinates', () => {
+      const g2 = G.mul(new BigNumber(2))
+      const xBN = g2.getX()
+      const yBN = g2.getY()
+      const jp = new JacobianPoint(xBN, yBN, curve.one)
+      expect(jp.isInfinity()).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // isInfinity
+  // --------------------------------------------------------------------------
+  describe('isInfinity', () => {
+    it('returns true for point at infinity', () => {
+      const jp = new JacobianPoint(null, null, null)
+      expect(jp.isInfinity()).toBe(true)
+    })
+
+    it('returns false for valid point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      expect(jp.isInfinity()).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // toP
+  // --------------------------------------------------------------------------
+  describe('toP', () => {
+    it('toP of infinity gives affine infinity', () => {
+      const jp = new JacobianPoint(null, null, null)
+      const p = jp.toP()
+      expect(p.isInfinity()).toBe(true)
+    })
+
+    it('toP round-trips from affine', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      const restored = jp.toP()
+      expect(restored.eq(g)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // neg
+  // --------------------------------------------------------------------------
+  describe('neg', () => {
+    it('neg of a JacobianPoint', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      const negJp = jp.neg()
+      // jp + neg(jp) should be infinity
+      expect(jp.add(negJp).isInfinity()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // add
+  // --------------------------------------------------------------------------
+  describe('add', () => {
+    it('O + P = P (this is infinity)', () => {
+      const inf = new JacobianPoint(null, null, null)
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const result = inf.add(g)
+      expect(result.toP().eq(g.toP())).toBe(true)
+    })
+
+    it('P + O = P (argument is infinity)', () => {
+      const inf = new JacobianPoint(null, null, null)
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const result = g.add(inf)
+      expect(result.toP().eq(g.toP())).toBe(true)
+    })
+
+    it('P + (-P) = O', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const negG = g.neg()
+      const result = g.add(negG)
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('P + P = 2P (via dbl)', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const g2 = g.dbl()
+      const result = g.add(g)
+      expect(result.toP().eq(g2.toP())).toBe(true)
+    })
+
+    it('P + Q = expected result', () => {
+      const g1 = G.mul(new BigNumber(3)).toJ()
+      const g2 = G.mul(new BigNumber(5)).toJ()
+      const expected = G.mul(new BigNumber(8))
+      const result = g1.add(g2)
+      expect(result.toP().eq(expected)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // mixedAdd
+  // --------------------------------------------------------------------------
+  describe('mixedAdd', () => {
+    it('O + P = P (this is infinity)', () => {
+      const inf = new JacobianPoint(null, null, null)
+      const g = Point.fromString(G_COMPRESSED)
+      const result = inf.mixedAdd(g)
+      expect(result.toP().eq(g)).toBe(true)
+    })
+
+    it('P + O = P (argument is infinity)', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const inf = new Point(null, null)
+      const result = g.mixedAdd(inf)
+      expect(result.toP().eq(g.toP())).toBe(true)
+    })
+
+    it('P + Q (mixed) = expected', () => {
+      const g3 = G.mul(new BigNumber(3)).toJ()
+      const g5 = G.mul(new BigNumber(5))
+      const expected = G.mul(new BigNumber(8))
+      const result = g3.mixedAdd(g5)
+      expect(result.toP().eq(expected)).toBe(true)
+    })
+
+    it('P + P (same point) via mixedAdd triggers dbl path', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const gJ = g.toJ()
+      const result = gJ.mixedAdd(g)
+      const expected = g.mul(new BigNumber(2))
+      expect(result.toP().eq(expected)).toBe(true)
+    })
+
+    it('mixedAdd P + (-P) = O', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const gJ = g.toJ()
+      const negG = g.neg()
+      const result = gJ.mixedAdd(negG)
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('throws when point coordinates are null (non-infinity with null x/y)', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      // Construct a Point-like object that is not infinity but has null x
+      const badPoint = { x: null, y: null, inf: false, isInfinity: () => false, type: 'affine' } as unknown as Point
+      expect(() => g.mixedAdd(badPoint)).toThrow('Point coordinates cannot be null')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // dbl
+  // --------------------------------------------------------------------------
+  describe('dbl', () => {
+    it('dbl of infinity is infinity', () => {
+      const jp = new JacobianPoint(null, null, null)
+      const result = jp.dbl()
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('dbl with zOne=true path', () => {
+      // When a point is created with z=1, the zOne shortcut is used in dbl
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      // zOne should be true since toJ sets z=curve.one
+      const result = g.dbl()
+      const expected = G.mul(new BigNumber(2))
+      expect(result.toP().eq(expected)).toBe(true)
+    })
+
+    it('dbl with zOne=false path', () => {
+      // Get a JacobianPoint where z !== curve.one (e.g. after an add)
+      const g3 = G.mul(new BigNumber(3)).toJ()
+      const g5 = G.mul(new BigNumber(5)).toJ()
+      const sum = g3.add(g5) // z will not be one after arbitrary add
+      const doubled = sum.dbl()
+      const expected = G.mul(new BigNumber(16))
+      expect(doubled.toP().eq(expected)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // dblp
+  // --------------------------------------------------------------------------
+  describe('dblp', () => {
+    it('dblp with pow=0 returns this', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const result = g.dblp(0)
+      expect(result.toP().eq(g.toP())).toBe(true)
+    })
+
+    it('dblp of infinity is infinity', () => {
+      const inf = new JacobianPoint(null, null, null)
+      const result = inf.dblp(3)
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('dblp with pow=3 equals three doublings', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const expected = G.mul(new BigNumber(8)) // 2^3 * 1 = 8
+      const result = g.dblp(3)
+      expect(result.toP().eq(expected)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // eq
+  // --------------------------------------------------------------------------
+  describe('eq', () => {
+    it('same instance is equal', () => {
+      const jp = Point.fromString(G_COMPRESSED).toJ()
+      expect(jp.eq(jp)).toBe(true)
+    })
+
+    it('equal points with different z', () => {
+      // Two different representations of the same affine point
+      const g = Point.fromString(G_COMPRESSED)
+      const jp1 = g.toJ()
+      const jp2 = g.toJ()
+      expect(jp1.eq(jp2)).toBe(true)
+    })
+
+    it('different points are not equal', () => {
+      const jp1 = G.mul(new BigNumber(3)).toJ()
+      const jp2 = G.mul(new BigNumber(5)).toJ()
+      expect(jp1.eq(jp2)).toBe(false)
+    })
+
+    it('infinity equals infinity', () => {
+      const inf1 = new JacobianPoint(null, null, null)
+      const inf2 = new JacobianPoint(null, null, null)
+      expect(inf1.eq(inf2)).toBe(true)
+    })
+
+    it('infinity != non-infinity', () => {
+      const inf = new JacobianPoint(null, null, null)
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      expect(inf.eq(g)).toBe(false)
+    })
+
+    it('eq with an affine Point argument', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      expect(jp.eq(g)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // eqXToP
+  // --------------------------------------------------------------------------
+  describe('eqXToP', () => {
+    it('returns true when x matches', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      expect(jp.eqXToP(g.getX())).toBe(true)
+    })
+
+    it('returns false when x does not match', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const jp = g.toJ()
+      const wrongX = g.getX().addn(1)
+      expect(jp.eqXToP(wrongX)).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // inspect
+  // --------------------------------------------------------------------------
+  describe('inspect', () => {
+    it('returns <EC JPoint Infinity> for infinity', () => {
+      const jp = new JacobianPoint(null, null, null)
+      expect(jp.inspect()).toBe('<EC JPoint Infinity>')
+    })
+
+    it('returns readable string for a valid point', () => {
+      const g = Point.fromString(G_COMPRESSED).toJ()
+      const s = g.inspect()
+      expect(s).toContain('<EC JPoint x:')
+      expect(s).toContain('y:')
+      expect(s).toContain('z:')
+    })
+  })
+})