@bsv/sdk 1.9.22 → 1.9.24

package/package.json

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

package/src/primitives/Hash.ts

@@ -282,13 +282,15 @@ export function toArray (
   return res
 }
 
-function htonl (w: number): number {
-  const res =
-    (w >>> 24) |
-    ((w >>> 8) & 0xff00) |
-    ((w << 8) & 0xff0000) |
-    ((w & 0xff) << 24)
-  return res >>> 0
+/**
+ * @deprecated
+ * This function behaves differently from the standard C `htonl()`.
+ * It always performs an unconditional 32-bit byte swap.
+ * Use `swapBytes32()` for explicit byte swapping, or `realHtonl()` for
+ * standards-compliant host-to-network conversion.
+ */
+export function htonl (w: number): number {
+  return swapBytes32(w)
 }
 
 function toHex32 (msg: number[], endian?: 'little' | 'big'): string {
@@ -1857,3 +1859,66 @@ export function pbkdf2 (
   const out = pbkdf2Fast(p, s, iterations, keylen)
   return Array.from(out)
 }
+
+/**
+ * Unconditionally swaps the byte order of a 32-bit unsigned integer.
+ *
+ * This function performs a strict 32-bit byte swap regardless of host
+ * endianness. It is equivalent to the behavior commonly referred to as
+ * `bswap32` in low-level libraries.
+ *
+ * This function is introduced as part of TOB-20 to provide a clearly-named
+ * alternative to `htonl()`, which was previously implemented as an
+ * unconditional byte swap and did not match the semantics of the traditional
+ * C `htonl()` function.
+ *
+ * @param w - A 32-bit unsigned integer.
+ * @returns The value with its byte order reversed.
+ *
+ * @example
+ * swapBytes32(0x11223344) // → 0x44332211
+ */
+export function swapBytes32 (w: number): number {
+  const res =
+    (w >>> 24) |
+    ((w >>> 8) & 0xff00) |
+    ((w << 8) & 0xff0000) |
+    ((w & 0xff) << 24)
+  return res >>> 0
+}
+
+// Detect the host machine's endianness at runtime.
+//
+// This is used by `realHtonl()` to determine whether the value must be
+// byte-swapped or returned unchanged. JavaScript engines on common platforms
+// are almost always little-endian, but this check is included for correctness.
+const isLittleEndian = (() => {
+  const b = new ArrayBuffer(4)
+  const a = new Uint32Array(b)
+  const c = new Uint8Array(b)
+  a[0] = 0x01020304
+  return c[0] === 0x04
+})()
+
+/**
+ * Converts a 32-bit unsigned integer from host byte order to network byte order.
+ *
+ * Unlike the legacy `htonl()` implementation (which always swapped bytes),
+ * this function behaves like the traditional C `htonl()`:
+ *
+ * - On **little-endian** machines → performs a byte swap.
+ * - On **big-endian** machines → returns the value unchanged.
+ *
+ * This function is provided to resolve TOB-20, which identified that the
+ * previous `htonl()` implementation had a misleading name and did not match
+ * platform-dependent semantics.
+ *
+ * @param w - A 32-bit unsigned integer.
+ * @returns The value converted to network byte order.
+ *
+ * @example
+ * realHtonl(0x11223344) // → 0x44332211 on little-endian systems
+ */
+export function realHtonl (w: number): number {
+  return isLittleEndian ? swapBytes32(w) : (w >>> 0)
+}

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/Hash.test.ts

@@ -105,9 +105,9 @@ describe('Hash', function () {
   describe('BaseHash padding and endianness', () => {
     it('encodes length in big-endian for SHA1', () => {
       const sha1 = new (hash as any).SHA1()
-      ;(sha1 as any).pendingTotal = 12345
-      const pad = (sha1 as any)._pad() as number[]
-      const padLength = (sha1 as any).padLength as number
+      ;(sha1).pendingTotal = 12345
+      const pad = (sha1)._pad() as number[]
+      const padLength = (sha1).padLength as number
       const lengthBytes = pad.slice(-padLength)
 
       const totalBits = BigInt(12345) * 8n
@@ -123,9 +123,9 @@ describe('Hash', function () {
 
     it('encodes length in little-endian for RIPEMD160', () => {
       const ripemd = new (hash as any).RIPEMD160()
-      ;(ripemd as any).pendingTotal = 12345
-      const pad = (ripemd as any)._pad() as number[]
-      const padLength = (ripemd as any).padLength as number
+      ;(ripemd).pendingTotal = 12345
+      const pad = (ripemd)._pad() as number[]
+      const padLength = (ripemd).padLength as number
       const lengthBytes = pad.slice(-padLength)
 
       const totalBits = BigInt(12345) * 8n
@@ -141,11 +141,11 @@ describe('Hash', function () {
 
     it('throws when message length exceeds maximum encodable bits', () => {
       const sha1 = new (hash as any).SHA1()
-      ;(sha1 as any).padLength = 1
-      ;(sha1 as any).pendingTotal = 40
+      ;(sha1).padLength = 1
+      ;(sha1).pendingTotal = 40
 
       expect(() => {
-        ;(sha1 as any)._pad()
+        ;(sha1)._pad()
       }).toThrow(new Error('Message too long for this hash function'))
     })
   })
@@ -180,7 +180,6 @@ describe('Hash', function () {
   })
 
   describe('Hash strict length validation (TOB-21)', () => {
-
     it('throws when pendingTotal is not a safe integer', () => {
       const h = new SHA1()
 
@@ -201,4 +200,57 @@ describe('Hash', function () {
       }).toThrow('Message too long for this hash function')
     })
   })
+
+  describe('TOB-20 byte-order helper functions', () => {
+    const { htonl, swapBytes32, realHtonl } = hash
+
+    it('swapBytes32 performs a strict 32-bit byte swap', () => {
+      expect(swapBytes32(0x11223344)).toBe(0x44332211)
+      expect(swapBytes32(0xaabbccdd)).toBe(0xddccbbaa)
+      expect(swapBytes32(0x00000000)).toBe(0x00000000)
+      expect(swapBytes32(0xffffffff)).toBe(0xffffffff)
+    })
+
+    it('swapBytes32 always returns an unsigned 32-bit integer', () => {
+      expect(swapBytes32(-1)).toBe(0xffffffff) // wraps to unsigned
+      expect(swapBytes32(0x80000000)).toBe(0x00000080) // MSB becomes LSB
+    })
+
+    it('htonl is now an alias for swapBytes32 (deprecated)', () => {
+      expect(htonl(0x11223344)).toBe(swapBytes32(0x11223344))
+      expect(htonl(0xaabbccdd)).toBe(swapBytes32(0xaabbccdd))
+    })
+
+    it('realHtonl matches swapBytes32 on little-endian systems', () => {
+      // All JS engines used for Node/Jest are little-endian
+      expect(realHtonl(0x11223344)).toBe(0x44332211)
+      expect(realHtonl(0xaabbccdd)).toBe(0xddccbbaa)
+    })
+
+    it('realHtonl preserves value when system is big-endian (forced simulation)', () => {
+      // We simulate the big-endian branch of realHtonl by calling
+      // the fallback path directly.
+      const forceBigEndianRealHtonl = (w: number) => (w >>> 0)
+
+      expect(forceBigEndianRealHtonl(0x11223344)).toBe(0x11223344)
+      expect(forceBigEndianRealHtonl(0xaabbccdd)).toBe(0xaabbccdd)
+      expect(forceBigEndianRealHtonl(0xffffffff)).toBe(0xffffffff >>> 0)
+    })
+
+    it('htonl, swapBytes32, realHtonl never throw for any 32-bit input', () => {
+      const inputs = [
+        0, 1, -1,
+        0x7fffffff,
+        0x80000000,
+        0xffffffff,
+        0x12345678
+      ]
+
+      for (const n of inputs) {
+        expect(() => htonl(n)).not.toThrow()
+        expect(() => swapBytes32(n)).not.toThrow()
+        expect(() => realHtonl(n)).not.toThrow()
+      }
+    })
+  })
 })

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()
+  })
+})