@bsv/sdk 2.0.11 → 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/PrivateKey.ts

@@ -55,7 +55,7 @@ export class KeyShares {
       const [x, y, t, i] = shareParts
       if (t === undefined) throw new Error('Threshold not found in share ' + idx.toString())
       if (i === undefined) throw new Error('Integrity not found in share ' + idx.toString())
-      const tInt = parseInt(t)
+      const tInt = Number.parseInt(t, 10)
       if (idx !== 0 && threshold !== tInt) { throw new Error('Threshold mismatch in share ' + idx.toString()) }
       if (idx !== 0 && integrity !== i) { throw new Error('Integrity mismatch in share ' + idx.toString()) }
       threshold = tInt
@@ -399,7 +399,7 @@ export default class PrivateKey extends BigNumber {
     let sharedSecret: Point
     if (typeof retrieveCachedSharedSecret === 'function') {
       const retrieved = retrieveCachedSharedSecret(this, publicKey)
-      if (typeof retrieved !== 'undefined') {
+      if (retrieved !== undefined) {
         sharedSecret = retrieved
       } else {
         sharedSecret = this.deriveSharedSecret(publicKey)
@@ -429,7 +429,7 @@ export default class PrivateKey extends BigNumber {
    * const shares = key.toKeyShares(2, 5)
    */
   toKeyShares (threshold: number, totalShares: number): KeyShares {
-    if (typeof threshold !== 'number' || typeof totalShares !== 'number') { throw new Error('threshold and totalShares must be numbers') }
+    if (typeof threshold !== 'number' || typeof totalShares !== 'number') { throw new TypeError('threshold and totalShares must be numbers') }
     if (threshold < 2) throw new Error('threshold must be at least 2')
     if (totalShares < 2) throw new Error('totalShares must be at least 2')
     if (threshold > totalShares) { throw new Error('threshold should be less than or equal to totalShares') }

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