@bsv/sdk 2.0.12 → 2.0.13

package/src/transaction/broadcasters/__tests/Teranode.test.ts

@@ -0,0 +1,349 @@
+import Teranode from '../../../transaction/broadcasters/Teranode'
+import Transaction from '../../../transaction/Transaction'
+import { BinaryFetchClient } from '../../../transaction/http/BinaryFetchClient'
+import { NodejsHttpClient } from '../../../transaction/http/NodejsHttpClient'
+import { RequestOptions } from 'https'
+
+// Mock Transaction so tests don't require a fully-formed BSV tx
+jest.mock('../../../transaction/Transaction', () => {
+  class MockTransaction {
+    toEF (): number[] {
+      return [0x01, 0x02, 0x03, 0x04]
+    }
+
+    id (_encoding: string): string {
+      return 'mocked_txid'
+    }
+  }
+  return { __esModule: true, default: MockTransaction }
+})
+
+describe('Teranode Broadcaster', () => {
+  const URL = 'https://teranode.example.com/api/v1/tx'
+
+  let transaction: Transaction
+
+  beforeEach(() => {
+    transaction = new Transaction()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // Constructor
+  // ---------------------------------------------------------------------------
+
+  it('stores the provided URL', () => {
+    const mockFetch = jest.fn()
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    expect(broadcaster.URL).toBe(URL)
+  })
+
+  it('stores the provided httpClient', () => {
+    const mockFetch = jest.fn()
+    const httpClient = new BinaryFetchClient(mockFetch as any)
+    const broadcaster = new Teranode(URL, httpClient)
+    expect(broadcaster.httpClient).toBe(httpClient)
+  })
+
+  it('uses binaryHttpClient when no httpClient is provided and window.fetch exists', () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => ''
+    })
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
+
+    // Constructor must not throw; httpClient must be defined
+    const broadcaster = new Teranode(URL)
+    expect(broadcaster.httpClient).toBeDefined()
+    expect(typeof broadcaster.httpClient.request).toBe('function')
+  })
+
+  // ---------------------------------------------------------------------------
+  // broadcast() — successful response
+  // ---------------------------------------------------------------------------
+
+  it('returns BroadcastResponse on HTTP 200', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: '' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'broadcast successful'
+    })
+  })
+
+  it('sends a POST with Content-Type application/octet-stream', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: '' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const [calledUrl, calledOptions] = mockFetch.mock.calls[0]
+    expect(calledUrl).toBe(URL)
+    expect(calledOptions.method).toBe('POST')
+    expect(calledOptions.headers['Content-Type']).toBe('application/octet-stream')
+  })
+
+  it('sends a Blob derived from toEF() bytes as request body', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: '' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    await broadcaster.broadcast(transaction)
+
+    const [, calledOptions] = mockFetch.mock.calls[0]
+    expect(calledOptions.body).toBeInstanceOf(Blob)
+  })
+
+  it('returns the tx id from transaction.id("hex")', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: '' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('success')
+    if (response.status === 'success') {
+      expect(response.txid).toBe('mocked_txid')
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // broadcast() — error response
+  // ---------------------------------------------------------------------------
+
+  it('returns BroadcastFailure with status code string on non-200 response', async () => {
+    const mockFetch = mockedFetch({ status: 400, data: 'Bad request data' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('400')
+      expect(response.description).toBe('Bad request data')
+    }
+  })
+
+  it('returns BroadcastFailure on HTTP 500', async () => {
+    const mockFetch = mockedFetch({ status: 500, data: 'Internal Server Error body' })
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('500')
+    }
+  })
+
+  it('uses "ERR_UNKNOWN" code when response.status is missing/falsy', async () => {
+    // Construct a mock where the HttpClient returns a non-ok response with status 0
+    const mockHttpClient = {
+      request: jest.fn().mockResolvedValue({
+        ok: false,
+        status: 0,
+        statusText: '',
+        data: 'some error'
+      })
+    }
+
+    const broadcaster = new Teranode(URL, mockHttpClient)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      // status.toString() of 0 is "0", not falsy in template — code is "0"
+      expect(response.code).toBe('0')
+      expect(response.description).toBe('some error')
+    }
+  })
+
+  it('uses "Unknown error" description when response.data is null/undefined', async () => {
+    const mockHttpClient = {
+      request: jest.fn().mockResolvedValue({
+        ok: false,
+        status: 503,
+        statusText: 'Service Unavailable',
+        data: null
+      })
+    }
+
+    const broadcaster = new Teranode(URL, mockHttpClient)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('503')
+      expect(response.description).toBe('Unknown error')
+    }
+  })
+
+  it('uses "Unknown error" description when response.data is undefined', async () => {
+    const mockHttpClient = {
+      request: jest.fn().mockResolvedValue({
+        ok: false,
+        status: 422,
+        statusText: 'Unprocessable',
+        data: undefined
+      })
+    }
+
+    const broadcaster = new Teranode(URL, mockHttpClient)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.description).toBe('Unknown error')
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // broadcast() — network / thrown errors
+  // ---------------------------------------------------------------------------
+
+  it('returns BroadcastFailure with code 500 on network error (Error instance)', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+
+    const broadcaster = new Teranode(URL, new BinaryFetchClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('500')
+      expect(response.description).toBe('Network error')
+    }
+  })
+
+  it('returns "Internal Server Error" description when thrown error has non-string message', async () => {
+    const mockHttpClient = {
+      request: jest.fn().mockRejectedValue({ message: 42 })
+    }
+
+    const broadcaster = new Teranode(URL, mockHttpClient)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('500')
+      expect(response.description).toBe('Internal Server Error')
+    }
+  })
+
+  it('returns "Internal Server Error" when thrown value has no message property', async () => {
+    const mockHttpClient = {
+      request: jest.fn().mockRejectedValue('plain string error')
+    }
+
+    const broadcaster = new Teranode(URL, mockHttpClient)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('500')
+      expect(response.description).toBe('Internal Server Error')
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // broadcast() — using Node.js https module directly
+  // ---------------------------------------------------------------------------
+
+  it('broadcasts successfully using NodejsHttpClient', async () => {
+    const mockHttps = mockedHttps({ status: 200, data: '' })
+
+    const broadcaster = new Teranode(URL, new NodejsHttpClient(mockHttps))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('success')
+    if (response.status === 'success') {
+      expect(response.txid).toBe('mocked_txid')
+    }
+  })
+
+  it('returns BroadcastFailure using NodejsHttpClient on non-200', async () => {
+    const mockHttps = mockedHttps({ status: 503, data: 'Unavailable' })
+
+    const broadcaster = new Teranode(URL, new NodejsHttpClient(mockHttps))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response.status).toBe('error')
+    if (response.status === 'error') {
+      expect(response.code).toBe('503')
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+
+  function mockedFetch (response: { status: number, data: any }): jest.Mock {
+    return jest.fn().mockResolvedValue({
+      ok: response.status >= 200 && response.status < 300,
+      status: response.status,
+      statusText: response.status === 200 ? 'OK' : 'Error',
+      // BinaryFetchClient calls res.text() then returns result as data
+      text: async () =>
+        typeof response.data === 'string'
+          ? response.data
+          : JSON.stringify(response.data)
+    })
+  }
+
+  function mockedHttps (response: { status: number, data: any }): {
+    request: (
+      url: string,
+      options: RequestOptions,
+      callback: (res: {
+        statusCode: number
+        statusMessage: string
+        headers: { 'content-type': string }
+        on: (event: string, handler: (chunk?: any) => void) => void
+      }) => void
+    ) => {
+      on: jest.Mock
+      write: jest.Mock
+      end: jest.Mock
+    }
+  } {
+    return {
+      request: (
+        url: string,
+        options: RequestOptions,
+        callback: (res: any) => void
+      ) => {
+        const mockResponse = {
+          statusCode: response.status,
+          statusMessage: response.status === 200 ? 'OK' : 'Error',
+          headers: { 'content-type': 'application/octet-stream' },
+          on (event: string, handler: (chunk?: any) => void) {
+            if (event === 'data') {
+              handler(
+                typeof response.data === 'string'
+                  ? response.data
+                  : JSON.stringify(response.data)
+              )
+            }
+            if (event === 'end') handler()
+          }
+        }
+        process.nextTick(() => callback(mockResponse))
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+  }
+})

package/src/transaction/chaintrackers/__tests/BlockHeadersService.test.ts

@@ -0,0 +1,253 @@
+import { BlockHeadersService } from '../../../transaction/chaintrackers/BlockHeadersService'
+
+describe('BlockHeadersService', () => {
+  const baseUrl = 'https://headers.spv.money'
+  const apiKey = 'test-api-key-12345'
+  const merkleRoot = 'abc123merkleroot'
+  const blockHeight = 800000
+
+  function makeHttpClient (response: { ok: boolean, status: number, data: any }): { request: jest.Mock } {
+    return {
+      request: jest.fn().mockResolvedValue(response)
+    }
+  }
+
+  describe('constructor', () => {
+    it('sets baseUrl from first argument', () => {
+      const httpClient = makeHttpClient({ ok: true, status: 200, data: {} })
+      const tracker = new BlockHeadersService(baseUrl, { httpClient })
+      expect((tracker as any).baseUrl).toBe(baseUrl)
+    })
+
+    it('sets apiKey from config', () => {
+      const httpClient = makeHttpClient({ ok: true, status: 200, data: {} })
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      expect((tracker as any).apiKey).toBe(apiKey)
+    })
+
+    it('uses empty string for apiKey when not provided', () => {
+      const httpClient = makeHttpClient({ ok: true, status: 200, data: {} })
+      const tracker = new BlockHeadersService(baseUrl, { httpClient })
+      expect((tracker as any).apiKey).toBe('')
+    })
+
+    it('uses provided httpClient', () => {
+      const httpClient = makeHttpClient({ ok: true, status: 200, data: {} })
+      const tracker = new BlockHeadersService(baseUrl, { httpClient })
+      expect((tracker as any).httpClient).toBe(httpClient)
+    })
+
+    it('falls back to defaultHttpClient when no httpClient provided', () => {
+      const tracker = new BlockHeadersService(baseUrl, { apiKey })
+      // The httpClient should be set (not undefined) – it comes from defaultHttpClient()
+      expect((tracker as any).httpClient).toBeDefined()
+    })
+  })
+
+  describe('isValidRootForHeight', () => {
+    it('returns true when confirmationState is CONFIRMED', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: {
+          confirmationState: 'CONFIRMED',
+          confirmations: [
+            {
+              blockHash: 'hash123',
+              blockHeight,
+              merkleRoot,
+              confirmation: 'CONFIRMED'
+            }
+          ]
+        }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      const result = await tracker.isValidRootForHeight(merkleRoot, blockHeight)
+      expect(result).toBe(true)
+    })
+
+    it('returns false when confirmationState is UNCONFIRMED', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: {
+          confirmationState: 'UNCONFIRMED',
+          confirmations: []
+        }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      const result = await tracker.isValidRootForHeight(merkleRoot, blockHeight)
+      expect(result).toBe(false)
+    })
+
+    it('throws on non-ok HTTP response', async () => {
+      const httpClient = makeHttpClient({
+        ok: false,
+        status: 400,
+        data: { error: 'Bad Request' }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.isValidRootForHeight(merkleRoot, blockHeight)).rejects.toThrow(
+        `Failed to verify merkleroot for height ${blockHeight} because of an error:`
+      )
+    })
+
+    it('throws when httpClient.request rejects', async () => {
+      const httpClient = {
+        request: jest.fn().mockRejectedValue(new Error('Network failure'))
+      }
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.isValidRootForHeight(merkleRoot, blockHeight)).rejects.toThrow(
+        'Failed to verify merkleroot for height'
+      )
+    })
+
+    it('sends correct POST body with blockHeight and merkleRoot', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { confirmationState: 'CONFIRMED', confirmations: [] }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await tracker.isValidRootForHeight(merkleRoot, blockHeight)
+
+      expect(httpClient.request).toHaveBeenCalledTimes(1)
+      const [url, options] = httpClient.request.mock.calls[0]
+      expect(url).toBe(`${baseUrl}/api/v1/chain/merkleroot/verify`)
+      expect(options.method).toBe('POST')
+      expect(options.data).toEqual([
+        {
+          blockHeight,
+          merkleRoot
+        }
+      ])
+    })
+
+    it('sets Authorization header with Bearer token from apiKey', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { confirmationState: 'CONFIRMED', confirmations: [] }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await tracker.isValidRootForHeight(merkleRoot, blockHeight)
+
+      const [, options] = httpClient.request.mock.calls[0]
+      expect(options.headers['Authorization']).toBe(`Bearer ${apiKey}`)
+    })
+
+    it('sets Content-Type and Accept headers', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { confirmationState: 'CONFIRMED', confirmations: [] }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await tracker.isValidRootForHeight(merkleRoot, blockHeight)
+
+      const [, options] = httpClient.request.mock.calls[0]
+      expect(options.headers['Content-Type']).toBe('application/json')
+      expect(options.headers['Accept']).toBe('application/json')
+    })
+  })
+
+  describe('currentHeight', () => {
+    it('returns height from response data', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { height: 875904 }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      const result = await tracker.currentHeight()
+      expect(result).toBe(875904)
+    })
+
+    it('sends GET request to correct URL', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { height: 100 }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await tracker.currentHeight()
+
+      const [url, options] = httpClient.request.mock.calls[0]
+      expect(url).toBe(`${baseUrl}/api/v1/chain/tip/longest`)
+      expect(options.method).toBe('GET')
+    })
+
+    it('sets Authorization header with Bearer token for currentHeight', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { height: 100 }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await tracker.currentHeight()
+
+      const [, options] = httpClient.request.mock.calls[0]
+      expect(options.headers['Authorization']).toBe(`Bearer ${apiKey}`)
+    })
+
+    it('throws on non-ok response', async () => {
+      const httpClient = makeHttpClient({
+        ok: false,
+        status: 500,
+        data: { error: 'Internal Server Error' }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.currentHeight()).rejects.toThrow(
+        'Failed to get current height because of an error:'
+      )
+    })
+
+    it('throws when response.data.height is not a number', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: { height: 'not-a-number' }
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.currentHeight()).rejects.toThrow(
+        'Failed to get current height because of an error:'
+      )
+    })
+
+    it('throws when response.data is missing height field', async () => {
+      const httpClient = makeHttpClient({
+        ok: true,
+        status: 200,
+        data: {}
+      })
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.currentHeight()).rejects.toThrow(
+        'Failed to get current height because of an error:'
+      )
+    })
+
+    it('throws when httpClient.request rejects', async () => {
+      const httpClient = {
+        request: jest.fn().mockRejectedValue(new Error('Connection refused'))
+      }
+
+      const tracker = new BlockHeadersService(baseUrl, { apiKey, httpClient })
+      await expect(tracker.currentHeight()).rejects.toThrow(
+        'Failed to get current height because of an error: Connection refused'
+      )
+    })
+  })
+})

package/src/transaction/chaintrackers/__tests/DefaultChainTracker.test.ts

@@ -0,0 +1,44 @@
+/** eslint-env jest */
+import { defaultChainTracker } from '../DefaultChainTracker'
+import WhatsOnChain from '../WhatsOnChain'
+import ChainTracker from '../../ChainTracker'
+
+// --- Tests ------------------------------------------------------------------
+
+describe('defaultChainTracker', () => {
+  describe('return type and instance', () => {
+    it('returns an instance of WhatsOnChain', () => {
+      const tracker = defaultChainTracker()
+      expect(tracker).toBeInstanceOf(WhatsOnChain)
+    })
+
+    it('satisfies the ChainTracker interface by having isValidRootForHeight method', () => {
+      const tracker = defaultChainTracker()
+      expect(typeof tracker.isValidRootForHeight).toBe('function')
+    })
+
+    it('returns a new instance on each call', () => {
+      const tracker1 = defaultChainTracker()
+      const tracker2 = defaultChainTracker()
+      expect(tracker1).not.toBe(tracker2)
+    })
+  })
+
+  describe('WhatsOnChain defaults', () => {
+    it('defaults to mainnet network', () => {
+      const tracker = defaultChainTracker() as WhatsOnChain
+      expect(tracker.network).toBe('main')
+    })
+
+    it('returns a tracker that responds to isValidRootForHeight as a function', () => {
+      const tracker = defaultChainTracker()
+      // The method exists and is callable (we do not make real HTTP calls in unit tests)
+      expect(tracker.isValidRootForHeight).toBeDefined()
+      const returnValue = tracker.isValidRootForHeight('someRoot', 0)
+      // It must return a Promise (thenable)
+      expect(typeof returnValue.then).toBe('function')
+      // Prevent unhandled rejection from real network call
+      returnValue.catch(() => {})
+    })
+  })
+})