@bsv/sdk 2.0.12 → 2.0.13

package/src/overlay-tools/__tests/withDoubleSpendRetry.test.ts

@@ -0,0 +1,278 @@
+/** eslint-env jest */
+import { withDoubleSpendRetry } from '../withDoubleSpendRetry'
+import { WERR_REVIEW_ACTIONS } from '../../wallet/WERR_REVIEW_ACTIONS'
+import Transaction from '../../transaction/Transaction'
+import { ReviewActionResult } from '../../wallet/Wallet.interfaces'
+import TopicBroadcaster from '../SHIPBroadcaster'
+
+// --- Module mocks -----------------------------------------------------------
+
+jest.mock('../../transaction/Transaction.js', () => ({
+  fromBEEF: jest.fn()
+}))
+
+jest.mock('../SHIPBroadcaster.js', () => {
+  return jest.fn().mockImplementation(() => ({
+    broadcast: jest.fn()
+  }))
+})
+
+// --- Typed mock refs --------------------------------------------------------
+
+const MockedTransaction = Transaction as jest.Mocked<typeof Transaction>
+
+// --- Helpers ----------------------------------------------------------------
+
+const MAX_DOUBLE_SPEND_RETRIES = 5
+
+function makeMockBroadcaster (): jest.Mocked<TopicBroadcaster> {
+  return {
+    broadcast: jest.fn()
+  } as unknown as jest.Mocked<TopicBroadcaster>
+}
+
+function makeDoubleSpendError (
+  competingBeef: number[] | null = [0x01, 0x02],
+  competingTxs: string[] | null = ['competingtxid111111111111111111111111111111111111111111111111111111']
+): WERR_REVIEW_ACTIONS {
+  const result: ReviewActionResult = {
+    txid: 'originaltxid1111111111111111111111111111111111111111111111111111111',
+    status: 'doubleSpend',
+    ...(competingBeef != null && { competingBeef }),
+    ...(competingTxs != null && { competingTxs })
+  }
+  return new WERR_REVIEW_ACTIONS([result], [])
+}
+
+function makeNonDoubleSpendError (name: string = 'WERR_REVIEW_ACTIONS'): WERR_REVIEW_ACTIONS {
+  const result: ReviewActionResult = {
+    txid: 'originaltxid1111111111111111111111111111111111111111111111111111111',
+    status: 'serviceError'
+  }
+  const err = new WERR_REVIEW_ACTIONS([result], [])
+  err.name = name
+  return err
+}
+
+// --- Tests ------------------------------------------------------------------
+
+describe('withDoubleSpendRetry', () => {
+  let broadcaster: jest.Mocked<TopicBroadcaster>
+  let mockCompetingTx: Partial<Transaction>
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    broadcaster = makeMockBroadcaster()
+    mockCompetingTx = {}
+    ;(MockedTransaction.fromBEEF as jest.Mock).mockReturnValue(mockCompetingTx as Transaction)
+  })
+
+  // --- Happy path -----------------------------------------------------------
+
+  describe('succeeds without retry', () => {
+    it('returns operation result immediately on first successful attempt', async () => {
+      const expectedResult = { success: true }
+      const operation = jest.fn().mockResolvedValue(expectedResult)
+
+      const result = await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(result).toBe(expectedResult)
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+
+    it('returns operation result for non-object results (string)', async () => {
+      const operation = jest.fn().mockResolvedValue('done')
+
+      const result = await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(result).toBe('done')
+      expect(operation).toHaveBeenCalledTimes(1)
+    })
+
+    it('returns operation result for undefined', async () => {
+      const operation = jest.fn().mockResolvedValue(undefined)
+
+      const result = await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(result).toBeUndefined()
+      expect(operation).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  // --- Non-double-spend errors rethrown immediately -------------------------
+
+  describe('rethrows non-WERR_REVIEW_ACTIONS errors immediately', () => {
+    it('rethrows a plain Error without retrying', async () => {
+      const plainError = new Error('Network error')
+      const operation = jest.fn().mockRejectedValue(plainError)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow('Network error')
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+
+    it('rethrows errors with other error names without retrying', async () => {
+      const otherError = new Error('other error')
+      otherError.name = 'SOME_OTHER_ERROR'
+      const operation = jest.fn().mockRejectedValue(otherError)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow('other error')
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+  })
+
+  // --- WERR_REVIEW_ACTIONS without doubleSpend rethrown immediately ---------
+
+  describe('rethrows WERR_REVIEW_ACTIONS that do not represent a valid doubleSpend', () => {
+    it('rethrows WERR_REVIEW_ACTIONS with no doubleSpend result in reviewActionResults', async () => {
+      const error = makeNonDoubleSpendError()
+      const operation = jest.fn().mockRejectedValue(error)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow(error)
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+
+    it('rethrows WERR_REVIEW_ACTIONS where doubleSpend result has no competingBeef', async () => {
+      const error = makeDoubleSpendError(null, ['competingtxid'])
+      const operation = jest.fn().mockRejectedValue(error)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow(error)
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+
+    it('rethrows WERR_REVIEW_ACTIONS where doubleSpend result has no competingTxs', async () => {
+      const error = makeDoubleSpendError([0x01, 0x02], null)
+      const operation = jest.fn().mockRejectedValue(error)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow(error)
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+
+    it('rethrows WERR_REVIEW_ACTIONS where competingTxs is an empty array', async () => {
+      const error = makeDoubleSpendError([0x01, 0x02], [])
+      const operation = jest.fn().mockRejectedValue(error)
+
+      await expect(withDoubleSpendRetry(operation, broadcaster)).rejects.toThrow(error)
+      expect(operation).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).not.toHaveBeenCalled()
+    })
+  })
+
+  // --- Retry on doubleSpend -------------------------------------------------
+
+  describe('retries after broadcasting the competing transaction', () => {
+    it('broadcasts the competing tx and retries the operation when doubleSpend is detected', async () => {
+      const competingBeef = [0xbe, 0xef]
+      const competingTxId = 'competingtxid111111111111111111111111111111111111111111111111111111'
+      const doubleSpendError = makeDoubleSpendError(competingBeef, [competingTxId])
+
+      broadcaster.broadcast.mockResolvedValue({ status: 'success', txid: competingTxId } as any)
+
+      const expectedResult = { done: true }
+      const operation = jest.fn()
+        .mockRejectedValueOnce(doubleSpendError) // first attempt: double-spend
+        .mockResolvedValueOnce(expectedResult) // second attempt: success
+
+      const result = await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(result).toBe(expectedResult)
+      expect(operation).toHaveBeenCalledTimes(2)
+      expect(MockedTransaction.fromBEEF).toHaveBeenCalledWith(competingBeef, competingTxId)
+      expect(broadcaster.broadcast).toHaveBeenCalledTimes(1)
+      expect(broadcaster.broadcast).toHaveBeenCalledWith(mockCompetingTx)
+    })
+
+    it('calls Transaction.fromBEEF with competingBeef and the first competingTx', async () => {
+      const competingBeef = [0x01, 0x02, 0x03]
+      const firstTxId = 'firstcompetingtxid1111111111111111111111111111111111111111111111111'
+      const secondTxId = 'secondcompetingtxid111111111111111111111111111111111111111111111111'
+      const doubleSpendError = makeDoubleSpendError(competingBeef, [firstTxId, secondTxId])
+
+      broadcaster.broadcast.mockResolvedValue({ status: 'success', txid: firstTxId } as any)
+      const operation = jest.fn()
+        .mockRejectedValueOnce(doubleSpendError)
+        .mockResolvedValueOnce('ok')
+
+      await withDoubleSpendRetry(operation, broadcaster)
+
+      // Only the first competingTx should be used
+      expect(MockedTransaction.fromBEEF).toHaveBeenCalledWith(competingBeef, firstTxId)
+    })
+
+    it('retries multiple times until success', async () => {
+      const doubleSpendError = makeDoubleSpendError()
+      broadcaster.broadcast.mockResolvedValue({ status: 'success' } as any)
+
+      const operation = jest.fn()
+        .mockRejectedValueOnce(doubleSpendError) // attempt 1
+        .mockRejectedValueOnce(doubleSpendError) // attempt 2
+        .mockRejectedValueOnce(doubleSpendError) // attempt 3
+        .mockResolvedValueOnce('finally succeeded') // attempt 4
+
+      const result = await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(result).toBe('finally succeeded')
+      expect(operation).toHaveBeenCalledTimes(4)
+      expect(broadcaster.broadcast).toHaveBeenCalledTimes(3)
+    })
+  })
+
+  // --- MAX_DOUBLE_SPEND_RETRIES enforcement ----------------------------------
+
+  describe('throws after MAX_DOUBLE_SPEND_RETRIES is exceeded', () => {
+    it('throws the error after MAX_DOUBLE_SPEND_RETRIES (5) failed attempts', async () => {
+      const doubleSpendError = makeDoubleSpendError()
+      broadcaster.broadcast.mockResolvedValue({ status: 'success' } as any)
+
+      // Operation always double-spends — should fail after maxRetries
+      const operation = jest.fn().mockRejectedValue(doubleSpendError)
+
+      await expect(
+        withDoubleSpendRetry(operation, broadcaster, MAX_DOUBLE_SPEND_RETRIES)
+      ).rejects.toThrow(doubleSpendError)
+
+      // Called maxRetries times; the last attempt's error is rethrown without broadcasting
+      expect(operation).toHaveBeenCalledTimes(MAX_DOUBLE_SPEND_RETRIES)
+      // Broadcast is called for all but the final attempt (last error is rethrown directly)
+      expect(broadcaster.broadcast).toHaveBeenCalledTimes(MAX_DOUBLE_SPEND_RETRIES - 1)
+    })
+
+    it('throws after custom maxRetries value is exceeded', async () => {
+      const doubleSpendError = makeDoubleSpendError()
+      broadcaster.broadcast.mockResolvedValue({ status: 'success' } as any)
+      const operation = jest.fn().mockRejectedValue(doubleSpendError)
+
+      await expect(
+        withDoubleSpendRetry(operation, broadcaster, 2)
+      ).rejects.toThrow(doubleSpendError)
+
+      expect(operation).toHaveBeenCalledTimes(2)
+      expect(broadcaster.broadcast).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  // --- Broadcaster interaction -----------------------------------------------
+
+  describe('broadcaster.broadcast is called with the correct transaction', () => {
+    it('passes the Transaction.fromBEEF result to broadcaster.broadcast', async () => {
+      const competingTxMock = { id: jest.fn().mockReturnValue('abc') }
+      ;(MockedTransaction.fromBEEF as jest.Mock).mockReturnValue(competingTxMock)
+
+      const doubleSpendError = makeDoubleSpendError([0xaa, 0xbb], ['txid'])
+      broadcaster.broadcast.mockResolvedValue({ status: 'success' } as any)
+
+      const operation = jest.fn()
+        .mockRejectedValueOnce(doubleSpendError)
+        .mockResolvedValueOnce('done')
+
+      await withDoubleSpendRetry(operation, broadcaster)
+
+      expect(broadcaster.broadcast).toHaveBeenCalledWith(competingTxMock)
+    })
+  })
+})

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

@@ -0,0 +1,79 @@
+import BigNumber from '../BigNumber'
+
+describe('BigNumber – additional coverage', () => {
+  describe('negative setter', () => {
+    it('sets sign to 0 when magnitude is zero (setting val=1 on zero BN)', () => {
+      const bn = new BigNumber(0)
+      bn.negative = 1
+      expect(bn.negative).toBe(0) // magnitude is 0 so sign stays 0
+    })
+
+    it('sets sign to 1 on a non-zero BigNumber', () => {
+      const bn = new BigNumber(5)
+      bn.negative = 1
+      expect(bn.negative).toBe(1)
+    })
+
+    it('sets sign to 0 on a non-zero BigNumber', () => {
+      const bn = new BigNumber(5)
+      bn.negative = 1
+      bn.negative = 0
+      expect(bn.negative).toBe(0)
+    })
+  })
+
+  describe('inspect', () => {
+    it('returns inspection string for a positive BigNumber', () => {
+      const bn = new BigNumber(255)
+      const s = bn.inspect()
+      expect(s).toContain('ff')
+      expect(s).toContain('BN')
+    })
+  })
+
+  describe('toBitArray', () => {
+    it('returns empty array for zero (static)', () => {
+      expect(BigNumber.toBitArray(new BigNumber(0))).toEqual([])
+    })
+
+    it('instance method returns same as static', () => {
+      const bn = new BigNumber(5) // binary: 101
+      expect(bn.toBitArray()).toEqual([1, 0, 1])
+    })
+  })
+
+  describe('toString with non-standard base', () => {
+    it('converts to base-3 string', () => {
+      const bn = new BigNumber(9)
+      expect(bn.toString(3)).toBe('100') // 9 in base 3 = 100
+    })
+  })
+
+  describe('fromBits / toBits edge cases', () => {
+    it('fromBits(0) returns zero BigNumber', () => {
+      const bn = BigNumber.fromBits(0)
+      expect(bn.toNumber()).toBe(0)
+    })
+
+    it('toBits for zero returns 0', () => {
+      expect(new BigNumber(0).toBits()).toBe(0)
+    })
+
+    it('toBits for a 3-byte number with MSB set in mantissa (triggers shift)', () => {
+      // mB[0] >= 0x80 → (nWordNum & 0x00800000) !== 0 → shift branch
+      const bn = BigNumber.fromHex('800001')
+      const bits = bn.toBits()
+      expect(bits).toBeGreaterThan(0)
+    })
+  })
+
+  describe('toSm', () => {
+    it('returns [0x80] for negative zero (magnitude 0, sign 1)', () => {
+      const bn = new BigNumber(0)
+      bn.negative = 1
+      const result = bn.toSm()
+      // magnitude is 0 so sign gets normalized to 0; returns []
+      expect(Array.isArray(result)).toBe(true)
+    })
+  })
+})

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

@@ -0,0 +1,208 @@
+import Curve from '../../primitives/Curve'
+import Point from '../../primitives/Point'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('Curve – additional coverage', () => {
+  const curve = new Curve()
+  const G = curve.g as Point
+
+  // --------------------------------------------------------------------------
+  // assert
+  // --------------------------------------------------------------------------
+  describe('Curve.assert', () => {
+    it('does not throw when expression is truthy', () => {
+      expect(() => Curve.assert(true)).not.toThrow()
+      expect(() => Curve.assert(1)).not.toThrow()
+      expect(() => Curve.assert('hello')).not.toThrow()
+    })
+
+    it('throws default message when expression is falsy', () => {
+      expect(() => Curve.assert(false)).toThrow('Elliptic curve assertion failed')
+    })
+
+    it('throws custom message', () => {
+      expect(() => Curve.assert(false, 'custom error')).toThrow('custom error')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // getNAF
+  // --------------------------------------------------------------------------
+  describe('getNAF', () => {
+    it('returns non-empty array for a positive number', () => {
+      const naf = curve.getNAF(new BigNumber(7), 2, 256)
+      expect(Array.isArray(naf)).toBe(true)
+      expect(naf.length).toBeGreaterThan(0)
+    })
+
+    it('returns all zeros for BigNumber(0)', () => {
+      const naf = curve.getNAF(new BigNumber(0), 2, 256)
+      // For zero, all entries should be 0
+      expect(naf.every(x => x === 0)).toBe(true)
+    })
+
+    it('handles odd number', () => {
+      const naf = curve.getNAF(new BigNumber(15), 2, 256)
+      expect(Array.isArray(naf)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // getJSF
+  // --------------------------------------------------------------------------
+  describe('getJSF', () => {
+    it('returns two arrays (JSF of k1 and k2)', () => {
+      const k1 = new BigNumber(7)
+      const k2 = new BigNumber(11)
+      const jsf = curve.getJSF(k1, k2)
+      expect(Array.isArray(jsf)).toBe(true)
+      expect(jsf.length).toBe(2)
+      expect(Array.isArray(jsf[0])).toBe(true)
+      expect(Array.isArray(jsf[1])).toBe(true)
+    })
+
+    it('handles large numbers', () => {
+      const k1 = new BigNumber('deadbeef', 16)
+      const k2 = new BigNumber('cafebabe', 16)
+      const jsf = curve.getJSF(k1, k2)
+      expect(jsf[0].length).toBeGreaterThan(0)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // parseBytes
+  // --------------------------------------------------------------------------
+  describe('Curve.parseBytes', () => {
+    it('converts hex string to byte array', () => {
+      const bytes = Curve.parseBytes('deadbeef')
+      expect(bytes).toEqual([0xde, 0xad, 0xbe, 0xef])
+    })
+
+    it('passes byte array through unchanged', () => {
+      const arr = [0x01, 0x02, 0x03]
+      const result = Curve.parseBytes(arr)
+      expect(result).toEqual(arr)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // intFromLE
+  // --------------------------------------------------------------------------
+  describe('Curve.intFromLE', () => {
+    it('converts little-endian bytes to BigNumber', () => {
+      const bn = Curve.intFromLE([0x01, 0x00])
+      // 0x01 in LE means 0x0001 = 1
+      expect(bn.toNumber()).toBe(1)
+    })
+
+    it('converts multi-byte LE number', () => {
+      const bn = Curve.intFromLE([0x02, 0x01])
+      // 0x0102 = 258
+      expect(bn.toNumber()).toBe(0x0102)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // cachedProperty
+  // --------------------------------------------------------------------------
+  describe('Curve.cachedProperty', () => {
+    it('caches the result after first call', () => {
+      let computeCount = 0
+      // Create a class to attach the property to
+      class TestClass {
+        _myProp: any = undefined
+      }
+      Curve.cachedProperty(TestClass, 'myProp', function () {
+        computeCount++
+        return 42
+      })
+      const instance = new TestClass()
+      // Calling twice — should compute once
+      const val1 = (instance as any).myProp()
+      const val2 = (instance as any).myProp()
+      expect(val1).toBe(42)
+      expect(val2).toBe(42)
+      expect(computeCount).toBe(1)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // validate
+  // --------------------------------------------------------------------------
+  describe('validate', () => {
+    it('returns true for point at infinity', () => {
+      const inf = new Point(null, null)
+      expect(curve.validate(inf)).toBe(true)
+    })
+
+    it('returns true for a valid curve point', () => {
+      const p = Point.fromString('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
+      expect(curve.validate(p)).toBe(true)
+    })
+
+    it('returns false for an off-curve point', () => {
+      // Create point with modified y to be off-curve
+      const p = Point.fromString('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
+      const yModified = (p.y as BigNumber).clone().redIAdd(curve.one)
+      // Access internal: just test via validate
+      // Use a different approach to create an off-curve point
+      const offCurve = new Point(p.x, yModified, false)
+      // We need to bypass the isRed check since the modified point isn't on the curve
+      // Just call curve.validate
+      expect(curve.validate(offCurve)).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // _endoSplit
+  // --------------------------------------------------------------------------
+  describe('_endoSplit', () => {
+    it('splits a scalar into balanced k1 and k2', () => {
+      const k = new BigNumber('deadbeefcafe', 16)
+      const split = curve._endoSplit(k)
+      expect(split).toHaveProperty('k1')
+      expect(split).toHaveProperty('k2')
+      // k1 + lambda * k2 ≡ k (mod n)
+      // This is an endomorphism property; just verify the result is plausible
+      expect(BigNumber.isBN(split.k1)).toBe(true)
+      expect(BigNumber.isBN(split.k2)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // _getEndoRoots
+  // --------------------------------------------------------------------------
+  describe('_getEndoRoots', () => {
+    it('computes two roots for the curve order n', () => {
+      const roots = curve._getEndoRoots(curve.n)
+      expect(Array.isArray(roots)).toBe(true)
+      expect(roots.length).toBe(2)
+      expect(BigNumber.isBN(roots[0])).toBe(true)
+      expect(BigNumber.isBN(roots[1])).toBe(true)
+    })
+
+    it('computes two roots for the curve field prime p', () => {
+      const roots = curve._getEndoRoots(curve.p)
+      expect(Array.isArray(roots)).toBe(true)
+      expect(roots.length).toBe(2)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // _getEndoBasis
+  // --------------------------------------------------------------------------
+  describe('_getEndoBasis', () => {
+    it('returns a basis of two vectors', () => {
+      // Use the curve's lambda if available
+      if (curve.endo != null) {
+        const basis = curve._getEndoBasis(curve.endo.lambda)
+        expect(Array.isArray(basis)).toBe(true)
+        expect(basis.length).toBe(2)
+        expect(basis[0]).toHaveProperty('a')
+        expect(basis[0]).toHaveProperty('b')
+        expect(basis[1]).toHaveProperty('a')
+        expect(basis[1]).toHaveProperty('b')
+      }
+    })
+  })
+})

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

@@ -0,0 +1,122 @@
+import * as ECDSA from '../../primitives/ECDSA'
+import BigNumber from '../../primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+import Signature from '../../primitives/Signature'
+import Point from '../../primitives/Point'
+
+const curve = new Curve()
+const key = new BigNumber(
+  '1e5edd45de6d22deebef4596b80444ffcc29143839c1dce18db470e25b4be7b5',
+  16
+)
+const pub = curve.g.mul(key)
+const msg = new BigNumber('deadbeef', 16)
+
+describe('ECDSA – additional coverage', () => {
+  // --------------------------------------------------------------------------
+  // truncateToN paths
+  // --------------------------------------------------------------------------
+  describe('truncateToN paths', () => {
+    it('sign handles msg equal to n (cmp >= 0 path in truncateToN)', () => {
+      // msg == n: after truncation msg.cmp(n) = 0, so msg.sub(n) = 0
+      // But then the loop would handle the edge case
+      // Use msg = n - 1, which is safe
+      const nMinus1 = curve.n.subn(1)
+      const sig = ECDSA.sign(nMinus1, key)
+      expect(ECDSA.verify(nMinus1, sig, pub)).toBe(true)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // verify – out-of-range signature components
+  // --------------------------------------------------------------------------
+  describe('verify out-of-range signature', () => {
+    it('returns false when r = 0', () => {
+      const r = new BigNumber(0)
+      const s = new BigNumber(1)
+      const sig = new Signature(r, s)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(false)
+    })
+
+    it('returns false when s = 0', () => {
+      const r = new BigNumber(1)
+      const s = new BigNumber(0)
+      const sig = new Signature(r, s)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(false)
+    })
+
+    it('returns false when r >= n', () => {
+      const r = curve.n.clone() // r == n
+      const s = new BigNumber(1)
+      const sig = new Signature(r, s)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(false)
+    })
+
+    it('returns false when s >= n', () => {
+      const r = new BigNumber(1)
+      const s = curve.n.clone() // s == n
+      const sig = new Signature(r, s)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(false)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // forceLowS - line 163
+  // --------------------------------------------------------------------------
+  describe('forceLowS', () => {
+    it('produces s <= n/2 with forceLowS=true across multiple messages', () => {
+      const halfN = curve.n.ushrn(1)
+      // Try a few messages to ensure forceLowS is exercised
+      for (let i = 1; i <= 10; i++) {
+        const testMsg = new BigNumber(i * 0xdeadbeef)
+        const sig = ECDSA.sign(testMsg, key, true)
+        expect(sig.s.cmp(halfN) <= 0).toBe(true)
+      }
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // sign with function customK
+  // --------------------------------------------------------------------------
+  describe('sign with function customK', () => {
+    it('accepts a function as customK', () => {
+      let callCount = 0
+      const customK = (iter: number): BigNumber => {
+        callCount++
+        return new BigNumber(1358)
+      }
+      const sig = ECDSA.sign(msg, key, false, customK)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(true)
+      expect(callCount).toBeGreaterThan(0)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // verify - invalid public key path (key with null x or y)
+  // --------------------------------------------------------------------------
+  describe('verify invalid public key', () => {
+    it('throws when public key coordinates are null', () => {
+      const sig = ECDSA.sign(msg, key)
+      const infinityKey = new Point(null, null)
+      expect(() => ECDSA.verify(msg, sig, infinityKey)).toThrow('Invalid public key')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // sign – k function returning invalid k causes iteration
+  // --------------------------------------------------------------------------
+  describe('sign – iterative k generation', () => {
+    it('eventually succeeds when k function returns invalid k on first iter', () => {
+      let callCount = 0
+      const customK = (iter: number): BigNumber => {
+        callCount++
+        // Return valid k on second call
+        if (iter === 0) return new BigNumber(0) // invalid k
+        return new BigNumber(1358) // valid k
+      }
+      const sig = ECDSA.sign(msg, key, false, customK)
+      expect(ECDSA.verify(msg, sig, pub)).toBe(true)
+      expect(callCount).toBeGreaterThanOrEqual(2)
+    })
+  })
+})