@bsv/sdk 2.0.11 → 2.0.13

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

@@ -0,0 +1,503 @@
+import Point from '../../primitives/Point'
+import BigNumber from '../../primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+
+const G_COMPRESSED = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
+
+describe('Point – additional coverage', () => {
+  const curve = new Curve()
+  const G = curve.g as Point
+
+  // --------------------------------------------------------------------------
+  // Constructor and coordinate handling
+  // --------------------------------------------------------------------------
+  describe('constructor', () => {
+    it('constructs an infinity point with null, null', () => {
+      const inf = new Point(null, null)
+      expect(inf.isInfinity()).toBe(true)
+    })
+
+    it('constructs from number array x/y', () => {
+      const G2 = G.mul(new BigNumber(2))
+      const x = G2.getX().toArray()
+      const y = G2.getY().toArray()
+      const p = new Point(x, y)
+      expect(p.isInfinity()).toBe(false)
+      expect(p.getX().eq(G2.getX())).toBe(true)
+    })
+
+    it('constructs with isRed=false', () => {
+      const G2 = G.mul(new BigNumber(2))
+      const xBN = G2.getX()
+      const yBN = G2.getY()
+      const p = new Point(xBN, yBN, false)
+      expect(p.isInfinity()).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // fromDER – uncompressed and hybrid formats
+  // --------------------------------------------------------------------------
+  describe('fromDER', () => {
+    it('parses uncompressed point (0x04)', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const bytes = g.encode(false) as number[]
+      expect(bytes[0]).toBe(0x04)
+      const restored = Point.fromDER(bytes)
+      expect(restored.eq(g)).toBe(true)
+    })
+
+    it('parses 0x06 hybrid (y-even) format', () => {
+      // Find a point where the last byte of the y coordinate is even
+      let gn: Point | null = null
+      for (let i = 2; i <= 20; i++) {
+        const candidate = G.mul(new BigNumber(i))
+        const uncompressed = candidate.encode(false) as number[]
+        if (uncompressed[uncompressed.length - 1] % 2 === 0) {
+          gn = candidate
+          break
+        }
+      }
+      if (gn === null) {
+        return
+      }
+      const uncompressed = gn.encode(false) as number[]
+      // Replace prefix with 0x06 (even y last byte)
+      uncompressed[0] = 0x06
+      const restored = Point.fromDER(uncompressed)
+      expect(restored.validate()).toBe(true)
+    })
+
+    it('parses 0x07 hybrid (y-odd) format', () => {
+      // Find a point where the last byte of the y coordinate (in the uncompressed encoding) is odd
+      let gn: Point | null = null
+      for (let i = 2; i <= 20; i++) {
+        const candidate = G.mul(new BigNumber(i))
+        const uncompressed = candidate.encode(false) as number[]
+        if (uncompressed[uncompressed.length - 1] % 2 === 1) {
+          gn = candidate
+          break
+        }
+      }
+      if (gn === null) {
+        // Skip if no suitable point found in range
+        return
+      }
+      const uncompressed = gn.encode(false) as number[]
+      // Replace prefix with 0x07 (odd y last byte)
+      uncompressed[0] = 0x07
+      const restored = Point.fromDER(uncompressed)
+      expect(restored.validate()).toBe(true)
+    })
+
+    it('throws for 0x06 when last byte is odd', () => {
+      // Build a valid-looking 65-byte buffer but set last byte to odd
+      // 0x06 requires last byte to be even, so odd → throws
+      const g = Point.fromString(G_COMPRESSED)
+      const uncompressed = g.encode(false) as number[]
+      uncompressed[0] = 0x06
+      // Force last byte to be odd
+      if (uncompressed[uncompressed.length - 1] % 2 === 0) {
+        uncompressed[uncompressed.length - 1] = 0x01
+      }
+      // Note: this may produce an invalid point too (validation error), either way it throws
+      expect(() => Point.fromDER(uncompressed)).toThrow()
+    })
+
+    it('throws for 0x07 when last byte is even', () => {
+      // Build a valid-looking 65-byte buffer but set last byte to even
+      // 0x07 requires last byte to be odd, so even → throws
+      const g = Point.fromString(G_COMPRESSED)
+      const uncompressed = g.encode(false) as number[]
+      uncompressed[0] = 0x07
+      // Force last byte to be even
+      if (uncompressed[uncompressed.length - 1] % 2 === 1) {
+        uncompressed[uncompressed.length - 1] = 0x02
+      }
+      expect(() => Point.fromDER(uncompressed)).toThrow()
+    })
+
+    it('throws for unknown format', () => {
+      const der = [0x05, ...Array(32).fill(0x01)]
+      expect(() => Point.fromDER(der)).toThrow('Unknown point format')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // fromString
+  // --------------------------------------------------------------------------
+  describe('fromString', () => {
+    it('parses a compressed hex point', () => {
+      const p = Point.fromString(G_COMPRESSED)
+      expect(p.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // fromX
+  // --------------------------------------------------------------------------
+  describe('fromX', () => {
+    it('fromX accepts BigNumber', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const xBN = g.getX()
+      const p = Point.fromX(xBN, false)
+      expect(p.validate()).toBe(true)
+    })
+
+    it('fromX accepts number', () => {
+      // Use a valid x value that has a square root mod p
+      const g = G.mul(new BigNumber(7))
+      const xNum = parseInt(g.getX().toString(16).slice(-4), 16)
+      // fromX with a number, may produce a point
+      const p = Point.fromX(g.getX(), true)
+      expect(p.validate()).toBe(true)
+    })
+
+    it('fromX accepts hex string', () => {
+      const g = G.mul(new BigNumber(7))
+      const xHex = g.getX().toString(16)
+      const p = Point.fromX(xHex, false)
+      expect(p.validate()).toBe(true)
+    })
+
+    it('fromX accepts number array', () => {
+      const g = G.mul(new BigNumber(7))
+      const xArr = g.getX().toArray()
+      const p = Point.fromX(xArr, true)
+      expect(p.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // fromJSON
+  // --------------------------------------------------------------------------
+  describe('fromJSON', () => {
+    it('accepts JSON string', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const json = JSON.stringify(g.toJSON())
+      const restored = Point.fromJSON(json, true)
+      expect(restored.eq(g)).toBe(true)
+    })
+
+    it('fromJSON with naf precomputed data', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      // Precomputed data has naf but no doubles
+      const serialized = [g.getX(), g.getY(), { naf: { wnd: 2, points: [] }, doubles: null }]
+      const restored = Point.fromJSON(serialized as any, true)
+      expect(restored.validate()).toBe(true)
+    })
+
+    it('fromJSON with doubles precomputed data', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const serialized = [g.getX(), g.getY(), { doubles: { step: 4, points: [] }, naf: null }]
+      const restored = Point.fromJSON(serialized as any, true)
+      expect(restored.validate()).toBe(true)
+    })
+
+    it('fromJSON with no precomputed (third element absent)', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const serialized = [g.getX(), g.getY()]
+      const restored = Point.fromJSON(serialized as any, true)
+      expect(restored.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // validate
+  // --------------------------------------------------------------------------
+  describe('validate', () => {
+    it('returns false for infinity point', () => {
+      const inf = new Point(null, null)
+      expect(inf.validate()).toBe(false)
+    })
+
+    it('returns true for a valid curve point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      expect(g.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // encode
+  // --------------------------------------------------------------------------
+  describe('encode', () => {
+    it('encodes infinity as [0x00]', () => {
+      const inf = new Point(null, null)
+      expect(inf.encode()).toEqual([0x00])
+    })
+
+    it('encodes infinity as "00" when enc=hex', () => {
+      const inf = new Point(null, null)
+      expect(inf.encode(true, 'hex')).toBe('00')
+    })
+
+    it('encodes compressed point (default compact=true)', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const encoded = g.encode()
+      expect(Array.isArray(encoded)).toBe(true)
+      const prefix = (encoded as number[])[0]
+      expect(prefix === 0x02 || prefix === 0x03).toBe(true)
+    })
+
+    it('encodes uncompressed point (compact=false)', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const encoded = g.encode(false) as number[]
+      expect(encoded[0]).toBe(0x04)
+      expect(encoded.length).toBe(65)
+    })
+
+    it('returns hex when enc=hex', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const hex = g.encode(true, 'hex')
+      expect(typeof hex).toBe('string')
+      expect(hex as string).toMatch(/^0[23][0-9a-f]+$/)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // inspect
+  // --------------------------------------------------------------------------
+  describe('inspect', () => {
+    it('returns "<EC Point Infinity>" for infinity', () => {
+      const inf = new Point(null, null)
+      expect(inf.inspect()).toBe('<EC Point Infinity>')
+    })
+
+    it('returns readable string for valid point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const s = g.inspect()
+      expect(s).toContain('<EC Point x:')
+      expect(s).toContain('y:')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // add – edge cases
+  // --------------------------------------------------------------------------
+  describe('add edge cases', () => {
+    it('O + P = P (this is infinity)', () => {
+      const inf = new Point(null, null)
+      const g = Point.fromString(G_COMPRESSED)
+      const result = inf.add(g)
+      expect(result.eq(g)).toBe(true)
+    })
+
+    it('P + O = P (argument is infinity)', () => {
+      const inf = new Point(null, null)
+      const g = Point.fromString(G_COMPRESSED)
+      const result = g.add(inf)
+      expect(result.eq(g)).toBe(true)
+    })
+
+    it('P + P = 2P', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const g2 = g.dbl()
+      const result = g.add(g)
+      expect(result.eq(g2)).toBe(true)
+    })
+
+    it('P + (-P) = infinity', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const negG = g.neg()
+      const result = g.add(negG)
+      expect(result.isInfinity()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // dbl
+  // --------------------------------------------------------------------------
+  describe('dbl', () => {
+    it('dbl of infinity is infinity', () => {
+      const inf = new Point(null, null)
+      const result = inf.dbl()
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('dbl of a valid point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const g2 = g.dbl()
+      expect(g2.validate()).toBe(true)
+      expect(g2.eq(g)).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // neg
+  // --------------------------------------------------------------------------
+  describe('neg', () => {
+    it('neg of infinity is infinity', () => {
+      const inf = new Point(null, null)
+      expect(inf.neg().isInfinity()).toBe(true)
+    })
+
+    it('neg of a valid point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const negG = g.neg()
+      expect(negG.validate()).toBe(true)
+      expect(g.add(negG).isInfinity()).toBe(true)
+    })
+
+    it('neg with _precompute=true propagates precomputed data', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      // Force precomputation via mul (which caches NAF)
+      g.mul(new BigNumber(2))
+      const negG = g.neg(true)
+      expect(negG.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // dblp
+  // --------------------------------------------------------------------------
+  describe('dblp', () => {
+    it('dblp with k=0 returns same point', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const result = g.dblp(0)
+      expect(result.eq(g)).toBe(true)
+    })
+
+    it('dblp with k=3 equals three doublings', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const tripled = g.dbl().dbl().dbl()
+      const result = g.dblp(3)
+      expect(result.eq(tripled)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // getX / getY
+  // --------------------------------------------------------------------------
+  describe('getX / getY', () => {
+    it('getX and getY return BigNumber', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      expect(BigNumber.isBN(g.getX())).toBe(true)
+      expect(BigNumber.isBN(g.getY())).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // mul – edge cases
+  // --------------------------------------------------------------------------
+  describe('mul', () => {
+    it('mul by 0 returns infinity', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const result = g.mul(new BigNumber(0))
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('mul infinity returns infinity', () => {
+      const inf = new Point(null, null)
+      const result = inf.mul(new BigNumber(5))
+      expect(result.isInfinity()).toBe(true)
+    })
+
+    it('mul by negative scalar', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const k = new BigNumber(3)
+      const r1 = g.mul(k)
+      const r2 = g.mul(k.neg())
+      expect(r1.eq(r2.neg())).toBe(true)
+    })
+
+    it('mul by number', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const r = g.mul(7)
+      expect(r.validate()).toBe(true)
+    })
+
+    it('mul by hex string', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const r = g.mul('0a')
+      expect(r.validate()).toBe(true)
+    })
+
+    it('mul by number array', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const r = g.mul([0x05])
+      expect(r.validate()).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // mulAdd / jmulAdd
+  // --------------------------------------------------------------------------
+  describe('mulAdd / jmulAdd', () => {
+    it('mulAdd(1, G, 0) = G', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const result = g.mulAdd(new BigNumber(1), g, new BigNumber(0))
+      expect(result.eq(g)).toBe(true)
+    })
+
+    it('mulAdd(1, G, 1) = 2G', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const g2 = g.mul(new BigNumber(2))
+      const result = g.mulAdd(new BigNumber(1), g, new BigNumber(1))
+      expect(result.eq(g2)).toBe(true)
+    })
+
+    it('jmulAdd returns a JPoint', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const result = g.jmulAdd(new BigNumber(2), g, new BigNumber(1))
+      expect(result).toBeDefined()
+      const asPoint = result.toP()
+      const g3 = g.mul(new BigNumber(3))
+      expect(asPoint.eq(g3)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // eq
+  // --------------------------------------------------------------------------
+  describe('eq', () => {
+    it('same instance is equal', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      expect(g.eq(g)).toBe(true)
+    })
+
+    it('both infinity are equal', () => {
+      const inf1 = new Point(null, null)
+      const inf2 = new Point(null, null)
+      expect(inf1.eq(inf2)).toBe(true)
+    })
+
+    it('infinity != non-infinity', () => {
+      const inf = new Point(null, null)
+      const g = Point.fromString(G_COMPRESSED)
+      expect(inf.eq(g)).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // toJ
+  // --------------------------------------------------------------------------
+  describe('toJ', () => {
+    it('toJ of infinity gives JPoint at infinity', () => {
+      const inf = new Point(null, null)
+      const j = inf.toJ()
+      expect(j.isInfinity()).toBe(true)
+    })
+
+    it('toJ of valid point gives equivalent JPoint', () => {
+      const g = Point.fromString(G_COMPRESSED)
+      const j = g.toJ()
+      const restored = j.toP()
+      expect(restored.eq(g)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // toJSON with precomputed
+  // --------------------------------------------------------------------------
+  describe('toJSON with precomputed', () => {
+    it('toJSON returns array with precomputed when precomputed is set', () => {
+      // Force precomputation by using internal _getNAFPoints
+      const g = Point.fromString(G_COMPRESSED)
+      // Trigger precomputation via mul (which uses precomputed internally)
+      g.mul(new BigNumber(2))
+      const json = g.toJSON()
+      // Even without precomputed being set externally, should return at least 2 elements
+      expect(json.length).toBeGreaterThanOrEqual(2)
+    })
+  })
+})