@bsv/sdk 2.0.12 → 2.0.13

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

@@ -0,0 +1,383 @@
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import BigNumber from '../../primitives/BigNumber'
+import Signature from '../../primitives/Signature'
+import { sha256 } from '../../primitives/Hash'
+
+/**
+ * Additional tests for PublicKey.ts
+ *
+ * The existing PublicKey.test.ts covers:
+ *   - fromPrivateKey
+ *   - fromString / fromDER round-trip
+ *   - constructor DER-string guard
+ *   - deriveSharedSecret (valid and invalid)
+ *   - verify (valid signature)
+ *   - toDER returning number[] and hex string
+ *   - deriveChild (BRC-42 vectors)
+ *
+ * The methods/branches below are NOT yet exercised:
+ *   - toDER with enc='hex' explicitly
+ *   - toHash returning number[] and hex string
+ *   - toAddress with all prefix variants ('mainnet', 'main', 'testnet', 'test', array, invalid)
+ *   - fromMsgHashAndCompactSignature (happy-path and all error paths)
+ *   - constructor with a Point instance (x instanceof Point branch)
+ *   - constructor with explicit isRed = false (skips the DER-string guard)
+ *   - verify with 'hex' encoding
+ *   - deriveChild with cache functions (both retrieve-hit and retrieve-miss paths)
+ */
+
+// ---------------------------------------------------------------------------
+// Fixed deterministic key pair used throughout these tests
+// ---------------------------------------------------------------------------
+const PRIV_HEX = 'f97c89aaacf0cd2e47ddbacc97dae1f88bec49106ac37716c451dcdd008a581b'
+const privateKey = PrivateKey.fromString(PRIV_HEX, 'hex')
+const publicKey = PublicKey.fromPrivateKey(privateKey)
+
+describe('PublicKey – additional coverage', () => {
+  // -------------------------------------------------------------------------
+  // toDER
+  // -------------------------------------------------------------------------
+  describe('toDER', () => {
+    it('returns a 66-char hex string when enc is "hex"', () => {
+      const hex = publicKey.toDER('hex')
+      expect(typeof hex).toBe('string')
+      expect((hex as string).length).toBe(66)
+      // Compressed keys start with 02 or 03
+      expect((hex as string)).toMatch(/^0[23][0-9a-f]{64}$/)
+    })
+
+    it('returns a 33-byte number array when enc is undefined', () => {
+      const bytes = publicKey.toDER()
+      expect(Array.isArray(bytes)).toBe(true)
+      expect((bytes as number[]).length).toBe(33)
+    })
+
+    it('toDER hex and toDER array encode the same key', () => {
+      const hex = publicKey.toDER('hex') as string
+      const arr = publicKey.toDER() as number[]
+      const arrFromHex = Buffer.from(hex, 'hex')
+      expect(Array.from(arrFromHex)).toEqual(arr)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // fromDER (number array → PublicKey)
+  // -------------------------------------------------------------------------
+  describe('fromDER', () => {
+    it('creates a PublicKey from a DER byte array', () => {
+      const derBytes = publicKey.toDER() as number[]
+      const recovered = PublicKey.fromDER(derBytes)
+      expect(recovered).toBeInstanceOf(PublicKey)
+      expect(recovered.toString()).toBe(publicKey.toString())
+    })
+
+    it('round-trips through toDER → fromDER correctly', () => {
+      const original = PublicKey.fromPrivateKey(PrivateKey.fromRandom())
+      const bytes = original.toDER() as number[]
+      const restored = PublicKey.fromDER(bytes)
+      expect(restored.toString()).toBe(original.toString())
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // toHash
+  // -------------------------------------------------------------------------
+  describe('toHash', () => {
+    it('returns a non-empty number array by default', () => {
+      const hash = publicKey.toHash()
+      expect(Array.isArray(hash)).toBe(true)
+      expect((hash as number[]).length).toBeGreaterThan(0)
+    })
+
+    it('returns a hex string when enc is "hex"', () => {
+      const hex = publicKey.toHash('hex')
+      expect(typeof hex).toBe('string')
+      // hash160 = 20 bytes = 40 hex chars
+      expect((hex as string).length).toBe(40)
+      expect((hex as string)).toMatch(/^[0-9a-f]{40}$/)
+    })
+
+    it('toHash() and toHash("hex") represent the same bytes', () => {
+      const arr = publicKey.toHash() as number[]
+      const hex = publicKey.toHash('hex') as string
+      expect(Buffer.from(arr).toString('hex')).toBe(hex)
+    })
+
+    it('different keys produce different hashes', () => {
+      const other = PublicKey.fromPrivateKey(PrivateKey.fromRandom())
+      expect(publicKey.toHash('hex')).not.toBe(other.toHash('hex'))
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // toAddress
+  // -------------------------------------------------------------------------
+  describe('toAddress', () => {
+    it('returns a string when called with no arguments (mainnet default)', () => {
+      const addr = publicKey.toAddress()
+      expect(typeof addr).toBe('string')
+      expect(addr.length).toBeGreaterThan(0)
+    })
+
+    it('accepts "mainnet" prefix string', () => {
+      const addr = publicKey.toAddress('mainnet')
+      expect(addr).toBe(publicKey.toAddress([0x00]))
+    })
+
+    it('accepts "main" prefix string (alias for mainnet)', () => {
+      const addr = publicKey.toAddress('main')
+      expect(addr).toBe(publicKey.toAddress([0x00]))
+    })
+
+    it('accepts "testnet" prefix string', () => {
+      const addr = publicKey.toAddress('testnet')
+      expect(addr).toBe(publicKey.toAddress([0x6f]))
+    })
+
+    it('accepts "test" prefix string (alias for testnet)', () => {
+      const addr = publicKey.toAddress('test')
+      expect(addr).toBe(publicKey.toAddress([0x6f]))
+    })
+
+    it('accepts an explicit byte-array prefix', () => {
+      // P2PKH mainnet prefix
+      const addr = publicKey.toAddress([0x00])
+      expect(typeof addr).toBe('string')
+    })
+
+    it('mainnet and testnet addresses differ for the same key', () => {
+      expect(publicKey.toAddress('mainnet')).not.toBe(publicKey.toAddress('testnet'))
+    })
+
+    it('throws on an unrecognised string prefix', () => {
+      expect(() => publicKey.toAddress('regtest')).toThrow('Invalid prefix regtest')
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // Constructor – Point overload
+  // -------------------------------------------------------------------------
+  describe('constructor with Point argument', () => {
+    it('builds a PublicKey from an existing Point (uses x/y of point)', () => {
+      // The point from the existing key IS a Point; passing it should succeed
+      // without going through the string-length guard.
+      const copy = new PublicKey(publicKey)
+      expect(copy).toBeInstanceOf(PublicKey)
+      expect(copy.toString()).toBe(publicKey.toString())
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // Constructor – isRed = false (skips the DER string guard)
+  // -------------------------------------------------------------------------
+  describe('constructor with isRed = false', () => {
+    it('does not throw for a 66-char string when isRed is false', () => {
+      // With isRed=false the guard is bypassed (y is still null, but isRed is
+      // false, so the condition is not met).
+      // We test that the guard is only active when isRed is true.
+      const derHex = publicKey.toString() // 66 hex chars
+      expect(() => new PublicKey(derHex, null, false)).not.toThrow()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // verify – hex-encoded message
+  // -------------------------------------------------------------------------
+  describe('verify with hex encoding', () => {
+    it('verifies a signature against a hex-encoded message', () => {
+      const msgHex = 'deadbeef'
+      const sig = privateKey.sign(msgHex, 'hex')
+      expect(publicKey.verify(msgHex, sig, 'hex')).toBe(true)
+    })
+
+    it('returns false for a wrong signature with hex encoding', () => {
+      const msgHex = 'deadbeef'
+      const otherKey = PrivateKey.fromRandom()
+      const wrongSig = otherKey.sign(msgHex, 'hex')
+      expect(publicKey.verify(msgHex, wrongSig, 'hex')).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // fromMsgHashAndCompactSignature
+  // -------------------------------------------------------------------------
+  describe('fromMsgHashAndCompactSignature', () => {
+    /**
+     * Build a compact signature manually from a Signature object using the
+     * compact-signature convention used by the BSV SDK:
+     *   byte 0  = 27 + recovery_param          (uncompressed variants use 27-30)
+     *             or 31 + recovery_param        (compressed variants use 31-34)
+     *   bytes 1-32  = r (big-endian, 32 bytes)
+     *   bytes 33-64 = s (big-endian, 32 bytes)
+     */
+    function makeCompactBytes (sig: Signature, recoveryParam: number, compressed: boolean): number[] {
+      const compactByte = (compressed ? 31 : 27) + recoveryParam
+      const rBytes = sig.r.toArray('be', 32)
+      const sBytes = sig.s.toArray('be', 32)
+      return [compactByte, ...rBytes, ...sBytes]
+    }
+
+    it('recovers the correct public key from a compact signature', () => {
+      // privateKey.sign(msg, 'hex') internally does: msgHash = SHA256(msg as hex bytes)
+      // so we must use that same SHA256 hash as the msgHash for recovery
+      const msgHex = 'deadbeef'
+      const sig = privateKey.sign(msgHex, 'hex')
+      const msgHash = new BigNumber(sha256(msgHex, 'hex'), 16)
+      // Try all valid recovery params until we get one that produces our key
+      let recovered: PublicKey | null = null
+      for (let r = 0; r <= 3; r++) {
+        try {
+          const compact = makeCompactBytes(sig, r, true)
+          const candidate = PublicKey.fromMsgHashAndCompactSignature(msgHash, compact)
+          if (candidate.toString() === publicKey.toString()) {
+            recovered = candidate
+            break
+          }
+        } catch {
+          // This recovery param didn't work, try next
+        }
+      }
+      expect(recovered).not.toBeNull()
+      expect(recovered!.toString()).toBe(publicKey.toString())
+    })
+
+    it('throws for a signature array that is not 65 bytes', () => {
+      const msgHash = new BigNumber(1)
+      expect(() =>
+        PublicKey.fromMsgHashAndCompactSignature(msgHash, new Array(64).fill(0))
+      ).toThrow('Invalid Compact Signature')
+    })
+
+    it('throws for a signature array that is 66 bytes', () => {
+      const msgHash = new BigNumber(1)
+      expect(() =>
+        PublicKey.fromMsgHashAndCompactSignature(msgHash, new Array(66).fill(0))
+      ).toThrow('Invalid Compact Signature')
+    })
+
+    it('throws for a compact byte below the valid range (< 27)', () => {
+      const msgHash = new BigNumber(1)
+      const compact = new Array(65).fill(0)
+      compact[0] = 26 // just below 27
+      expect(() =>
+        PublicKey.fromMsgHashAndCompactSignature(msgHash, compact)
+      ).toThrow('Invalid Compact Byte')
+    })
+
+    it('throws for a compact byte at or above 35', () => {
+      const msgHash = new BigNumber(1)
+      const compact = new Array(65).fill(0)
+      compact[0] = 35 // >= 35
+      expect(() =>
+        PublicKey.fromMsgHashAndCompactSignature(msgHash, compact)
+      ).toThrow('Invalid Compact Byte')
+    })
+
+    it('handles hex-encoded compact signature string', () => {
+      const msgHex = 'cafebabe'
+      const sig = privateKey.sign(msgHex, 'hex')
+      const msgHash = new BigNumber(sha256(msgHex, 'hex'), 16)
+
+      for (let r = 0; r <= 3; r++) {
+        try {
+          const compactBytes = makeCompactBytes(sig, r, true)
+          const hexStr = Buffer.from(compactBytes).toString('hex')
+          const candidate = PublicKey.fromMsgHashAndCompactSignature(msgHash, hexStr, 'hex')
+          if (candidate.toString() === publicKey.toString()) {
+            expect(candidate).toBeInstanceOf(PublicKey)
+            return // test passed
+          }
+        } catch {
+          // continue trying recovery params
+        }
+      }
+      // If we reach here all recovery params failed to match – that's a test data issue
+      throw new Error('Could not find a valid recovery param for the test key pair')
+    })
+
+    it('handles uncompressed compact byte (27-30 range)', () => {
+      const msgHex = 'aabbccdd'
+      const sig = privateKey.sign(msgHex, 'hex')
+      const msgHash = new BigNumber(sha256(msgHex, 'hex'), 16)
+
+      // Try uncompressed recovery params (byte 27-30, i.e. r=0..3 without the +4)
+      let passed = false
+      for (let r = 0; r <= 3; r++) {
+        try {
+          const compact = makeCompactBytes(sig, r, false) // uncompressed variant (byte 27-30)
+          const candidate = PublicKey.fromMsgHashAndCompactSignature(msgHash, compact)
+          if (candidate.toString() === publicKey.toString()) {
+            passed = true
+            break
+          }
+        } catch {
+          // next
+        }
+      }
+      // At least one recovery param should work
+      expect(passed).toBe(true)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // deriveChild – cache callbacks
+  // -------------------------------------------------------------------------
+  describe('deriveChild cache callbacks', () => {
+    const invoiceNumber = 'test-invoice-001'
+
+    it('calls cacheSharedSecret when retrieveCachedSharedSecret returns undefined', () => {
+      const cacheSharedSecret = jest.fn()
+      const retrieveCachedSharedSecret = jest.fn().mockReturnValue(undefined)
+
+      const derived = publicKey.deriveChild(
+        privateKey,
+        invoiceNumber,
+        cacheSharedSecret,
+        retrieveCachedSharedSecret
+      )
+
+      expect(derived).toBeInstanceOf(PublicKey)
+      expect(retrieveCachedSharedSecret).toHaveBeenCalledTimes(1)
+      expect(cacheSharedSecret).toHaveBeenCalledTimes(1)
+    })
+
+    it('uses cached shared secret when retrieveCachedSharedSecret returns a Point', () => {
+      // First derive without cache to capture the real shared secret
+      const realSharedSecret = publicKey.deriveSharedSecret(privateKey)
+
+      const cacheSharedSecret = jest.fn()
+      const retrieveCachedSharedSecret = jest.fn().mockReturnValue(realSharedSecret)
+
+      const derivedWithCache = publicKey.deriveChild(
+        privateKey,
+        invoiceNumber,
+        cacheSharedSecret,
+        retrieveCachedSharedSecret
+      )
+      const derivedWithout = publicKey.deriveChild(privateKey, invoiceNumber)
+
+      // Both derivations must produce the same child key
+      expect(derivedWithCache.toString()).toBe(derivedWithout.toString())
+      expect(retrieveCachedSharedSecret).toHaveBeenCalledTimes(1)
+      // cacheSharedSecret should NOT be called when a cached value is found
+      expect(cacheSharedSecret).not.toHaveBeenCalled()
+    })
+
+    it('does not call cacheSharedSecret when it is not provided (cache miss path)', () => {
+      // retrieveCachedSharedSecret returns undefined but no cacheSharedSecret provided
+      const retrieveCachedSharedSecret = jest.fn().mockReturnValue(undefined)
+
+      expect(() =>
+        publicKey.deriveChild(privateKey, invoiceNumber, undefined, retrieveCachedSharedSecret)
+      ).not.toThrow()
+
+      expect(retrieveCachedSharedSecret).toHaveBeenCalledTimes(1)
+    })
+
+    it('derives without any cache callbacks (direct path)', () => {
+      const derived = publicKey.deriveChild(privateKey, invoiceNumber)
+      expect(derived).toBeInstanceOf(PublicKey)
+    })
+  })
+})

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

@@ -0,0 +1,262 @@
+/* eslint-env jest */
+/**
+ * Additional tests for src/primitives/Random.ts
+ *
+ * The existing Random.test.ts covers the happy-path via the real Node.js 18+
+ * globalThis.crypto path.  These tests exercise the remaining branches by
+ * isolating the module in different synthetic environments so that the Rand
+ * constructor walks a different code path each time.
+ *
+ * Because the module caches its `ayn` singleton at the module level we must
+ * re-require a fresh copy via jest.isolateModules() for every environment
+ * variant.
+ *
+ * NOTE: In Node 18+, globalThis.crypto is a getter on the prototype, not an
+ * own property. To shadow it, we use Object.defineProperty to install an own
+ * property with configurable:true, then delete it in afterEach to restore.
+ */
+
+/** Shadow globalThis.crypto with the given value (or undefined). */
+function shadowCrypto (value: any): void {
+  Object.defineProperty(globalThis, 'crypto', {
+    value,
+    configurable: true,
+    writable: true
+  })
+}
+
+/** Remove the own-property shadow so the prototype getter is visible again. */
+function restoreCrypto (): void {
+  // Only delete if we installed an own property
+  if (Object.prototype.hasOwnProperty.call(globalThis, 'crypto')) {
+    delete (globalThis as any).crypto
+  }
+}
+
+describe('Random – environment branches', () => {
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+
+  /** Load a fresh copy of the Random module inside the current environment. */
+  function loadRandom (): (len: number) => number[] {
+    let Random: (len: number) => number[]
+    // isolateModules executes synchronously
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      Random = require('../../primitives/Random').default
+    })
+    return Random!
+  }
+
+  // -------------------------------------------------------------------------
+  // 1. globalThis.crypto path (already covered by the main test suite but
+  //    explicitly validated here to confirm isolateModules works).
+  // -------------------------------------------------------------------------
+  describe('globalThis.crypto path', () => {
+    it('produces bytes when globalThis.crypto is available', () => {
+      // Node 18+ exposes globalThis.crypto – do not mock, just verify the
+      // isolated module still works.
+      const Random = loadRandom()
+      const bytes = Random(16)
+      expect(bytes).toHaveLength(16)
+      bytes.forEach(b => {
+        expect(b).toBeGreaterThanOrEqual(0)
+        expect(b).toBeLessThanOrEqual(255)
+      })
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 2. self.crypto path (Web Worker / Service Worker environment)
+  // -------------------------------------------------------------------------
+  describe('self.crypto path', () => {
+    const hadSelf = typeof self !== 'undefined'
+    let originalSelf: any
+    let originalProcess: any
+
+    beforeEach(() => {
+      // Shadow globalThis.crypto with undefined so the first branch is skipped
+      shadowCrypto(undefined)
+      originalSelf = (globalThis as any).self
+      // Remove process so the Node.js < 18 branch (which precedes self.crypto) is also skipped
+      originalProcess = (globalThis as any).process
+      delete (globalThis as any).process
+    })
+
+    afterEach(() => {
+      restoreCrypto()
+      if (hadSelf) {
+        (globalThis as any).self = originalSelf
+      } else {
+        delete (globalThis as any).self
+      }
+      ;(globalThis as any).process = originalProcess
+    })
+
+    it('uses self.crypto.getRandomValues when globalThis.crypto is absent', () => {
+      const mockGetRandomValues = jest.fn((arr: Uint8Array) => {
+        for (let i = 0; i < arr.length; i++) arr[i] = 42
+        return arr
+      })
+
+      // Install a synthetic `self` with a working crypto object.
+      ;(globalThis as any).self = {
+        crypto: { getRandomValues: mockGetRandomValues }
+      }
+
+      const Random = loadRandom()
+      const bytes = Random(4)
+
+      expect(bytes).toHaveLength(4)
+      expect(bytes).toEqual([42, 42, 42, 42])
+      expect(mockGetRandomValues).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 3. window.crypto path (browser main-thread environment)
+  // -------------------------------------------------------------------------
+  describe('window.crypto path', () => {
+    const hadSelf = typeof self !== 'undefined'
+    const hadWindow = typeof window !== 'undefined'
+    let originalSelf: any
+    let originalWindow: any
+    let originalProcess: any
+
+    beforeEach(() => {
+      // Shadow globalThis.crypto with undefined
+      shadowCrypto(undefined)
+      originalSelf = (globalThis as any).self
+      originalWindow = (globalThis as any).window
+      // Remove process and self so the Node.js and self.crypto branches are skipped
+      originalProcess = (globalThis as any).process
+      delete (globalThis as any).process
+      delete (globalThis as any).self
+    })
+
+    afterEach(() => {
+      restoreCrypto()
+      if (hadSelf) {
+        (globalThis as any).self = originalSelf
+      } else {
+        delete (globalThis as any).self
+      }
+      if (hadWindow) {
+        (globalThis as any).window = originalWindow
+      } else {
+        delete (globalThis as any).window
+      }
+      ;(globalThis as any).process = originalProcess
+    })
+
+    it('uses window.crypto.getRandomValues when globalThis/self.crypto are absent', () => {
+      const mockGetRandomValues = jest.fn((arr: Uint8Array) => {
+        for (let i = 0; i < arr.length; i++) arr[i] = 99
+        return arr
+      })
+
+      ;(globalThis as any).window = {
+        crypto: { getRandomValues: mockGetRandomValues }
+      }
+
+      const Random = loadRandom()
+      const bytes = Random(3)
+
+      expect(bytes).toHaveLength(3)
+      expect(bytes).toEqual([99, 99, 99])
+      expect(mockGetRandomValues).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 4. noRand path – throws when no crypto is available anywhere
+  // -------------------------------------------------------------------------
+  describe('noRand path', () => {
+    const hadSelf = typeof self !== 'undefined'
+    const hadWindow = typeof window !== 'undefined'
+    let originalSelf: any
+    let originalWindow: any
+    let originalProcess: any
+
+    beforeEach(() => {
+      // Shadow globalThis.crypto with undefined
+      shadowCrypto(undefined)
+      originalSelf = (globalThis as any).self
+      delete (globalThis as any).self
+      originalWindow = (globalThis as any).window
+      delete (globalThis as any).window
+      // Remove process entirely so that the Node < 18 require('crypto') branch is skipped
+      originalProcess = (globalThis as any).process
+      delete (globalThis as any).process
+    })
+
+    afterEach(() => {
+      restoreCrypto()
+      if (hadSelf) {
+        (globalThis as any).self = originalSelf
+      } else {
+        delete (globalThis as any).self
+      }
+      if (hadWindow) {
+        (globalThis as any).window = originalWindow
+      } else {
+        delete (globalThis as any).window
+      }
+      ;(globalThis as any).process = originalProcess
+    })
+
+    it('throws an error when no crypto source is available', () => {
+      const Random = loadRandom()
+      expect(() => Random(16)).toThrow(
+        'No secure random number generator is available in this environment.'
+      )
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 5. Node.js < 18 require('crypto') fallback path
+  // -------------------------------------------------------------------------
+  describe('Node.js < 18 require(\'crypto\') fallback path', () => {
+    beforeEach(() => {
+      // Shadow globalThis.crypto with undefined so the first branch is skipped
+      // and the constructor falls through to the process.release.name === 'node' check
+      shadowCrypto(undefined)
+    })
+
+    afterEach(() => {
+      restoreCrypto()
+    })
+
+    it('falls through to require("crypto").randomBytes when globalThis.crypto is absent', () => {
+      // process.release.name === 'node' is already true in Jest / Node.
+      // With globalThis.crypto shadowed as undefined the module should attempt require('crypto')
+      // and use randomBytes successfully.
+      const Random = loadRandom()
+      const bytes = Random(8)
+      expect(bytes).toHaveLength(8)
+      bytes.forEach(b => {
+        expect(b).toBeGreaterThanOrEqual(0)
+        expect(b).toBeLessThanOrEqual(255)
+      })
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 6. Singleton caching – ayn is reused across calls
+  // -------------------------------------------------------------------------
+  describe('singleton caching', () => {
+    it('caches the Rand instance across multiple calls within the same module scope', () => {
+      // We cannot access `ayn` directly, but we can verify that calling the
+      // exported function multiple times without resetting the module still
+      // produces valid results (the cached instance is reused without error).
+      jest.isolateModules(() => {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const Random = require('../../primitives/Random').default as (len: number) => number[]
+        expect(Random(4)).toHaveLength(4)
+        expect(Random(4)).toHaveLength(4)
+        expect(Random(4)).toHaveLength(4)
+      })
+    })
+  })
+})