@bsv/sdk 1.9.22 → 1.9.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.9.22",
+  "version": "1.9.23",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/primitives/JacobianPoint.ts

@@ -73,6 +73,14 @@ export default class JacobianPoint extends BasePoint {
     }
 
     this.zOne = this.z === this.curve.one
+
+    // --- Canonicalize point at infinity ---
+    if (this.isInfinity()) {
+      this.x = this.curve.one
+      this.y = this.curve.one
+      this.z = new BigNumber(0).toRed(this.curve.red)
+      this.zOne = false
+    }
   }
 
   /**
@@ -361,9 +369,18 @@ export default class JacobianPoint extends BasePoint {
       return true
     }
 
+    p = p as JacobianPoint
+
+    // --- Infinity handling ---
+    if (this.isInfinity() && p.isInfinity()) {
+      return true
+    }
+    if (this.isInfinity() !== p.isInfinity()) {
+      return false
+    }
+
     // x1 * z2^2 == x2 * z1^2
     const z2 = this.z.redSqr()
-    p = p as JacobianPoint
     const pz2 = p.z.redSqr()
     if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) {
       return false

package/src/primitives/Point.ts

@@ -445,6 +445,10 @@ export default class Point extends BasePoint {
    * const encodedPointHex = aPoint.encode(true, 'hex');
    */
   encode (compact: boolean = true, enc?: 'hex'): number[] | string {
+    if (this.inf) {
+      if (enc === 'hex') return '00'
+      return [0x00]
+    }
     const len = this.curve.p.byteLength()
     const x = this.getX().toArray('be', len)
     let res: number[]

package/src/primitives/__tests/Curve.unit.test.ts

@@ -212,3 +212,66 @@ describe('Point codec', () => {
     makeShortTest(shortPointOddY)
   )
 })
+
+describe('JacobianPoint – Infinity handling and equality (TOB-18)', () => {
+  function J(x: any, y: any, z: any) {
+    return new JPoint(x, y, z)
+  }
+
+  it('Multiple infinity representations are canonicalized and equal', () => {
+    const inf1 = J(null, null, null)
+    const inf2 = J('0', '0', '0')
+    const inf3 = J(new BigNumber(0), new BigNumber(0), new BigNumber(0))
+
+    expect(inf1.isInfinity()).toBe(true)
+    expect(inf2.isInfinity()).toBe(true)
+    expect(inf3.isInfinity()).toBe(true)
+
+    expect(inf1.eq(inf2)).toBe(true)
+    expect(inf2.eq(inf3)).toBe(true)
+    expect(inf1.eq(inf3)).toBe(true)
+  })
+
+  it('Infinity must not equal a finite point', () => {
+    const inf = J(null, null, null)
+
+    const good = J(
+      new BigNumber('e7789226', 16),
+      new BigNumber('4b76b191', 16),
+      new BigNumber('cbf8d990', 16)
+    )
+
+    expect(inf.eq(good)).toBe(false)
+    expect(good.eq(inf)).toBe(false)
+  })
+
+  it('Infinity equals infinity (canonicalized)', () => {
+    const inf1 = J(null, null, null)
+    const inf2 = J('0', '0', '0')
+
+    expect(inf1.eq(inf2)).toBe(true)
+    expect(inf2.eq(inf1)).toBe(true)
+  })
+
+  it('Infinity is detected when z is zero in RED form', () => {
+    const redZero = new BigNumber(0).toRed(new Curve().red)
+    const p = J('1', '2', redZero)
+
+    expect(p.isInfinity()).toBe(true)
+
+    const clean = J(null, null, null)
+    expect(p.eq(clean)).toBe(true)
+    expect(clean.eq(p)).toBe(true)
+  })
+
+  it('eq() must handle mixed canonical and non-canonical infinity cases', () => {
+    const canonical = J(null, null, null)
+    const messy = J('1', '1', new BigNumber(0))
+
+    expect(messy.isInfinity()).toBe(true)
+    expect(canonical.eq(messy)).toBe(true)
+    expect(messy.eq(canonical)).toBe(true)
+  })
+})
+
+

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

@@ -11,6 +11,7 @@ import {
   toBase58Check,
   verifyNotNull
 } from '../../primitives/utils'
+import Point from '../../primitives/Point'
 
 describe('utils', () => {
   it('should convert to array', () => {
@@ -359,3 +360,19 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
 
 })
 
+describe('Point.encode infinity handling', () => {
+  it('encodes infinity as 00 (array)', () => {
+    const p = new Point(null, null)
+    expect(p.encode()).toEqual([0x00])
+  })
+
+  it('encodes infinity as 00 (hex)', () => {
+    const p = new Point(null, null)
+    expect(p.encode(true, 'hex')).toBe('00')
+  })
+
+  it('does not throw for infinity', () => {
+    const p = new Point(null, null)
+    expect(() => p.encode()).not.toThrow()
+  })
+})