@bsv/sdk 2.1.2 → 2.1.4

package/src/overlay-tools/__tests/LookupResolver.additional.test.ts

@@ -472,6 +472,22 @@ describe('LookupResolver – additional coverage', () => {
       ).rejects.toThrow('Request timed out')
     })
 
+    it('rejects within the timeout even when fetch never settles', async () => {
+      // Simulate the CORS-blocked / hung-preflight case where the fetch promise
+      // does not honor the AbortController signal and never settles.
+      const neverFetch = jest.fn().mockImplementation(
+        () => new Promise(() => { /* never resolves */ })
+      )
+      const facilitator = new HTTPSOverlayLookupFacilitator(neverFetch, true)
+      const start = Date.now()
+      await expect(
+        facilitator.lookup('http://host', { service: 'ls_test', query: {} }, 50)
+      ).rejects.toThrow('Request timed out')
+      const elapsed = Date.now() - start
+      // Allow generous slack but must complete well before any global jest timeout.
+      expect(elapsed).toBeLessThan(2000)
+    })
+
     it('parses octet-stream responses', async () => {
       // Build a minimal octet-stream payload: 1 outpoint, then BEEF bytes
       const tx = new Transaction(
@@ -506,6 +522,36 @@ describe('LookupResolver – additional coverage', () => {
       expect(result.outputs[0].outputIndex).toBe(0)
     })
 
+    it('parses octet-stream responses when header carries parameters or differing case', async () => {
+      const tx = new Transaction(
+        1,
+        [],
+        [{ lockingScript: LockingScript.fromHex('88'), satoshis: 1 }],
+        0
+      )
+      const beef = tx.toBEEF()
+      const txid = Buffer.from(tx.id('hex'), 'hex')
+      const payload = Buffer.concat([
+        Buffer.from([0x01]), txid, Buffer.from([0x00]), Buffer.from([0x00]), Buffer.from(beef)
+      ])
+
+      for (const header of [
+        'application/octet-stream; charset=utf-8',
+        'Application/Octet-Stream',
+        '  application/octet-stream  '
+      ]) {
+        const mockFetch = jest.fn().mockResolvedValue({
+          ok: true,
+          headers: { get: () => header },
+          arrayBuffer: async () => payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength)
+        })
+        const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+        const result = await facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+        expect(result.type).toBe('output-list')
+        expect(result.outputs).toHaveLength(1)
+      }
+    })
+
     it('parses octet-stream responses with context bytes', async () => {
       const tx = new Transaction(
         1,
@@ -547,6 +593,50 @@ describe('LookupResolver – additional coverage', () => {
       ).rejects.toThrow('DNS failure')
     })
 
+    it('normalises string thrown values from fetch', async () => {
+      const mockFetch = jest.fn().mockRejectedValue('boom')
+      const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+      await expect(
+        facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+      ).rejects.toThrow('boom')
+    })
+
+    it('normalises object-with-message thrown values from fetch', async () => {
+      const mockFetch = jest.fn().mockRejectedValue({ message: 'object boom' })
+      const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+      await expect(
+        facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+      ).rejects.toThrow('object boom')
+    })
+
+    it('normalises plain-object thrown values via JSON', async () => {
+      const mockFetch = jest.fn().mockRejectedValue({ code: 42 })
+      const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+      await expect(
+        facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+      ).rejects.toThrow('{"code":42}')
+    })
+
+    it('normalises number/boolean/null thrown values from fetch', async () => {
+      for (const value of [123, true, null]) {
+        const mockFetch = jest.fn().mockRejectedValue(value)
+        const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+        await expect(
+          facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+        ).rejects.toThrow(String(value))
+      }
+    })
+
+    it('normalises circular thrown values without crashing', async () => {
+      const circular: { self?: unknown } = {}
+      circular.self = circular
+      const mockFetch = jest.fn().mockRejectedValue(circular)
+      const facilitator = new HTTPSOverlayLookupFacilitator(mockFetch, true)
+      await expect(
+        facilitator.lookup('https://host', { service: 'ls_test', query: {} })
+      ).rejects.toThrow('Unknown error')
+    })
+
     it('sends correct request body to /lookup endpoint', async () => {
       const mockFetch = jest.fn().mockResolvedValue({
         ok: true,

package/src/script/__tests/Spend.test.ts

@@ -512,7 +512,7 @@ describe('Spend', () => {
     })
   })
 
-  it('Successfully validates a spend where sequence is set to undefined', async () => {
+  it('Rejects spending an immature coinbase transaction', async () => {
     const sourceTransaction = new Transaction(
       1,
       [{
@@ -531,8 +531,49 @@ describe('Spend', () => {
     )
     const txid = sourceTransaction.id('hex')
     sourceTransaction.merklePath = MerklePath.fromCoinbaseTxidAndHeight(txid, 0)
-    const chain = new MockChain({ blockheaders: [] })
-    chain.addBlock(txid)
+    const chain = new MockChain({ blockheaders: [txid] })
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          unlockingScript: Script.fromASM('OP_TRUE'),
+          sourceTransaction,
+          sourceOutputIndex: 0
+        }
+      ],
+      [{
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 1
+      }],
+      0
+    )
+
+    await expect(spendTx.verify(chain)).rejects.toThrow(
+      `Invalid merkle path for transaction ${txid}`
+    )
+  })
+
+  it('Successfully validates a mature coinbase spend where sequence is set to undefined', async () => {
+    const sourceTransaction = new Transaction(
+      1,
+      [{
+        sourceTXID: '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+        sequence: 0xffffffff
+      }],
+      [
+        {
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 2
+        }
+      ],
+      0
+    )
+    const txid = sourceTransaction.id('hex')
+    sourceTransaction.merklePath = MerklePath.fromCoinbaseTxidAndHeight(txid, 0)
+    const chain = new MockChain({ blockheaders: [txid, ...new Array(100).fill('')] })
 
     const spendTx = new Transaction(
       1,
@@ -551,7 +592,7 @@ describe('Spend', () => {
     )
 
     const valid = await spendTx.verify(chain)
-    
+
     expect(valid).toBe(true)
 
     const b = spendTx.toBinary()

package/src/transaction/MerklePath.ts

@@ -375,7 +375,7 @@ export default class MerklePath {
     if (this.indexOf(txid) === 0) {
       // Coinbase transaction outputs can only be spent once they're 100 blocks deep.
       const height = await chainTracker.currentHeight()
-      if (this.blockHeight + 100 < height) {
+      if (this.blockHeight + 100 > height) {
         return false
       }
     }

package/src/transaction/__tests/Transaction.test.ts

@@ -15,6 +15,23 @@ import MerklePath from '../../transaction/MerklePath'
 import { BEEF_V1 } from '../../transaction/Beef'
 import SatoshisPerKilobyte from '../../transaction/fee-models/SatoshisPerKilobyte'
 
+// Default Transaction.fee() resolves to LivePolicy.getInstance(), which fetches the live ARC
+// policy endpoint. Replace it with a deterministic 100 sat/kb model so tests never hit the
+// network — the live endpoint is unreliable and not part of what these tests exercise.
+jest.mock('../../transaction/fee-models/LivePolicy', () => {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const SPKB = require('../../transaction/fee-models/SatoshisPerKilobyte').default
+  class MockLivePolicy extends SPKB {
+    static instance: MockLivePolicy | null = null
+    constructor () { super(100) }
+    static getInstance (): MockLivePolicy {
+      if (!MockLivePolicy.instance) MockLivePolicy.instance = new MockLivePolicy()
+      return MockLivePolicy.instance
+    }
+  }
+  return { __esModule: true, default: MockLivePolicy }
+})
+
 import sighashVectors from '../../primitives/__tests/sighash.vectors'
 import invalidTransactions from './tx.invalid.vectors'
 import validTransactions from './tx.valid.vectors'