@bsv/sdk 2.0.11 → 2.0.13

package/src/transaction/chaintrackers/__tests/WhatsOnChain.additional.test.ts

@@ -0,0 +1,193 @@
+import WhatsOnChain from '../../../transaction/chaintrackers/WhatsOnChain'
+import { FetchHttpClient } from '../../../transaction/http/FetchHttpClient'
+
+// These tests cover the branches that are missing from WhatsOnChainChainTracker.test.ts:
+//   Line 80-85  — currentHeight() non-ok response branch (throws)
+//   Line 84     — currentHeight() catch block re-throws with formatted message
+//   Line 97     — getHttpHeaders() sets Authorization header when apiKey is non-empty
+
+describe('WhatsOnChain — additional coverage', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  // -------------------------------------------------------------------------
+  // currentHeight() — non-ok response (lines 80-83)
+  // -------------------------------------------------------------------------
+
+  it('throws when currentHeight receives a non-ok HTTP response', async () => {
+    const mockFetch = mockedFetch({ status: 503, data: { error: 'Service Unavailable' } })
+
+    const tracker = new WhatsOnChain('main', {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(tracker.currentHeight()).rejects.toThrow(
+      /Failed to get current height because of an error:/
+    )
+  })
+
+  it('includes the serialised response data in the thrown message for non-ok currentHeight', async () => {
+    const mockFetch = mockedFetch({ status: 429, data: { code: 'RATE_LIMITED' } })
+
+    const tracker = new WhatsOnChain('main', {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(tracker.currentHeight()).rejects.toThrow(
+      /RATE_LIMITED/
+    )
+  })
+
+  // -------------------------------------------------------------------------
+  // currentHeight() — catch block (lines 84-87)
+  // The outer try/catch in currentHeight() wraps everything, including the
+  // non-ok branch.  A network-level rejection also exercises lines 84-87.
+  // -------------------------------------------------------------------------
+
+  it('wraps network errors in a formatted message via the catch block', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('connection refused'))
+
+    const tracker = new WhatsOnChain('main', {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(tracker.currentHeight()).rejects.toThrow(
+      'Failed to get current height because of an error: connection refused'
+    )
+  })
+
+  it('handles non-Error thrown values in the catch block', async () => {
+    const mockHttpClient = {
+      request: jest.fn().mockRejectedValue('raw string rejection')
+    }
+
+    const tracker = new WhatsOnChain('main', { httpClient: mockHttpClient })
+
+    await expect(tracker.currentHeight()).rejects.toThrow(
+      'Failed to get current height because of an error: raw string rejection'
+    )
+  })
+
+  // -------------------------------------------------------------------------
+  // getHttpHeaders() — Authorization header when apiKey is set (line 97)
+  // -------------------------------------------------------------------------
+
+  it('includes Authorization header in requests when apiKey is provided', async () => {
+    const apiKey = 'my-test-api-key'
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'root123' } })
+
+    const tracker = new WhatsOnChain('main', {
+      apiKey,
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await tracker.isValidRootForHeight('root123', 100)
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers?.Authorization).toBe(apiKey)
+  })
+
+  it('does NOT include Authorization header when apiKey is an empty string', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'root456' } })
+
+    const tracker = new WhatsOnChain('main', {
+      apiKey: '',
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await tracker.isValidRootForHeight('root456', 200)
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers?.Authorization).toBeUndefined()
+  })
+
+  it('does NOT include Authorization header when apiKey is only whitespace', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'root789' } })
+
+    const tracker = new WhatsOnChain('main', {
+      apiKey: '   ',
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await tracker.isValidRootForHeight('root789', 300)
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers?.Authorization).toBeUndefined()
+  })
+
+  it('always includes Accept: application/json regardless of apiKey', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'rAny' } })
+
+    const tracker = new WhatsOnChain('main', {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await tracker.isValidRootForHeight('rAny', 1)
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers?.Accept).toBe('application/json')
+  })
+
+  it('sends Authorization header to currentHeight endpoint when apiKey is set', async () => {
+    const apiKey = 'another-key'
+    const mockFetch = mockedFetch({
+      status: 200,
+      data: [{ height: 999999 }]
+    })
+
+    const tracker = new WhatsOnChain('test', {
+      apiKey,
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await tracker.currentHeight()
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers?.Authorization).toBe(apiKey)
+  })
+
+  // -------------------------------------------------------------------------
+  // Constructor — network variants
+  // -------------------------------------------------------------------------
+
+  it('builds the correct URL for the "test" network', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'testroot' } })
+
+    const tracker = new WhatsOnChain('test', { httpClient: new FetchHttpClient(mockFetch) })
+    await tracker.isValidRootForHeight('testroot', 10)
+
+    const [calledUrl] = mockFetch.mock.calls[0]
+    expect(calledUrl).toContain('bsv/test')
+  })
+
+  it('builds the correct URL for the "stn" network', async () => {
+    const mockFetch = mockedFetch({ status: 200, data: { merkleroot: 'stnroot' } })
+
+    const tracker = new WhatsOnChain('stn', { httpClient: new FetchHttpClient(mockFetch) })
+    await tracker.isValidRootForHeight('stnroot', 20)
+
+    const [calledUrl] = mockFetch.mock.calls[0]
+    expect(calledUrl).toContain('bsv/stn')
+  })
+
+  // -------------------------------------------------------------------------
+  // Helper
+  // -------------------------------------------------------------------------
+
+  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',
+      headers: {
+        get (key: string): string | undefined {
+          if (key === 'Content-Type') return 'application/json'
+          return undefined
+        }
+      },
+      json: async () => response.data
+    })
+  }
+})

package/src/transaction/fee-models/__tests/SatoshisPerKilobyte.test.ts

@@ -0,0 +1,262 @@
+import SatoshisPerKilobyte from '../SatoshisPerKilobyte'
+import Transaction from '../../Transaction'
+import Script from '../../../script/Script'
+
+/**
+ * Tests for SatoshisPerKilobyte fee model.
+ *
+ * SatoshisPerKilobyte.computeFee() calculates transaction size from:
+ *   - 4 bytes  version
+ *   - varint   number of inputs
+ *   - per input: 40 bytes (fixed) + varint script length + script bytes
+ *   - varint   number of outputs
+ *   - per output: 8 bytes (satoshis) + varint script length + script bytes
+ *   - 4 bytes  lock time
+ *
+ * Fee = ceil(size / 1000 * value)
+ *
+ * The unlocking-script source can be:
+ *   a) an actual UnlockingScript object (.unlockingScript present)
+ *   b) a template (.unlockingScriptTemplate present with .estimateLength())
+ *   c) neither → throws
+ *
+ * getVarIntSize thresholds:
+ *   - <= 253      → 1 byte
+ *   - 254..65535  → 3 bytes  (> 253)
+ *   - 65536..2^32 → 5 bytes  (> 2^16)
+ *   - > 2^32      → 9 bytes
+ */
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Build the simplest possible mock input with an already-compiled unlocking script. */
+function makeScriptInput (scriptBytes: number[]): any {
+  return {
+    unlockingScript: Script.fromBinary(scriptBytes),
+    unlockingScriptTemplate: undefined
+  }
+}
+
+/** Build an input that uses an unlockingScriptTemplate instead. */
+function makeTemplateInput (estimatedLength: number): any {
+  return {
+    unlockingScript: undefined,
+    unlockingScriptTemplate: {
+      estimateLength: jest.fn().mockResolvedValue(estimatedLength)
+    }
+  }
+}
+
+/** Build a simple output with a locking script of the given byte length. */
+function makeOutput (scriptBytes: number[], satoshis = 1000): any {
+  return {
+    lockingScript: Script.fromBinary(scriptBytes),
+    satoshis
+  }
+}
+
+/** Create a minimal Transaction-like object with the given inputs and outputs. */
+function makeTx (inputs: any[], outputs: any[]): Transaction {
+  const tx = new Transaction()
+  tx.inputs = inputs
+  tx.outputs = outputs
+  return tx
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SatoshisPerKilobyte', () => {
+  // -------------------------------------------------------------------------
+  // Constructor
+  // -------------------------------------------------------------------------
+  describe('constructor', () => {
+    it('stores the satoshis-per-kilobyte value', () => {
+      const model = new SatoshisPerKilobyte(50)
+      expect(model.value).toBe(50)
+    })
+
+    it('accepts value of 0', () => {
+      const model = new SatoshisPerKilobyte(0)
+      expect(model.value).toBe(0)
+    })
+
+    it('accepts fractional values', () => {
+      const model = new SatoshisPerKilobyte(0.5)
+      expect(model.value).toBe(0.5)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // computeFee – happy path
+  // -------------------------------------------------------------------------
+  describe('computeFee', () => {
+    it('returns 0 for empty transaction with value 0', async () => {
+      const model = new SatoshisPerKilobyte(0)
+      const tx = makeTx([], [])
+      // size = 4 (version) + 1 (input count varint) + 1 (output count varint) + 4 (locktime) = 10
+      // fee = ceil(10/1000 * 0) = 0
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(0)
+    })
+
+    it('computes correct fee for an empty transaction (no inputs, no outputs)', async () => {
+      const model = new SatoshisPerKilobyte(1000) // 1 sat/byte
+      const tx = makeTx([], [])
+      // size = 4 + 1 + 1 + 4 = 10 bytes
+      // fee = ceil(10/1000 * 1000) = ceil(10) = 10
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(10)
+    })
+
+    it('computes fee for one input with an unlocking script', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const scriptData = new Array(107).fill(0x00) // P2PKH-ish unlock ~107 bytes
+      const tx = makeTx([makeScriptInput(scriptData)], [])
+      // size = 4 (ver) + 1 (input count) + [40 + 1 (script varint) + 107 (script)] + 1 (output count) + 4 (locktime)
+      //      = 4 + 1 + 148 + 1 + 4 = 158 bytes
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(Math.ceil((158 / 1000) * 1000))
+    })
+
+    it('uses unlockingScriptTemplate.estimateLength when no script is compiled', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const templateInput = makeTemplateInput(107)
+      const tx = makeTx([templateInput], [])
+      const fee = await model.computeFee(tx)
+      expect(templateInput.unlockingScriptTemplate.estimateLength).toHaveBeenCalledTimes(1)
+      expect(fee).toBe(Math.ceil((158 / 1000) * 1000))
+    })
+
+    it('computes fee including outputs', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const lockScript = new Array(25).fill(0x00) // P2PKH locking script = 25 bytes
+      const tx = makeTx([], [makeOutput(lockScript)])
+      // size = 4 + 1 + 1 + [8 + 1 + 25] + 4 = 44 bytes
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(Math.ceil((44 / 1000) * 1000))
+    })
+
+    it('computes fee for one input and one output', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const unlockScript = new Array(107).fill(0x00)
+      const lockScript = new Array(25).fill(0x00)
+      const tx = makeTx([makeScriptInput(unlockScript)], [makeOutput(lockScript)])
+      // size = 4 + 1 + (40 + 1 + 107) + 1 + (8 + 1 + 25) + 4
+      //      = 4 + 1 + 148 + 1 + 34 + 4 = 192 bytes
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(Math.ceil((192 / 1000) * 1000))
+    })
+
+    it('uses Math.ceil to round up fractional fees', async () => {
+      // Choose a value where the result is not a whole satoshi
+      const model = new SatoshisPerKilobyte(1) // very small rate
+      const tx = makeTx([], [])
+      // size = 10 bytes → fee = ceil(10/1000 * 1) = ceil(0.01) = 1
+      const fee = await model.computeFee(tx)
+      expect(fee).toBe(1)
+    })
+
+    it('fee scales proportionally with sat/kb rate', async () => {
+      const tx = makeTx([], [])
+      const fee100 = await new SatoshisPerKilobyte(100).computeFee(tx)
+      const fee200 = await new SatoshisPerKilobyte(200).computeFee(tx)
+      expect(fee200).toBeGreaterThanOrEqual(fee100)
+    })
+
+    it('throws when input has neither unlockingScript nor unlockingScriptTemplate', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const badInput: any = {} // no unlockingScript, no unlockingScriptTemplate
+      const tx = makeTx([badInput], [])
+      await expect(model.computeFee(tx)).rejects.toThrow(
+        'All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation.'
+      )
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // getVarIntSize thresholds (tested indirectly through computeFee)
+  // -------------------------------------------------------------------------
+  describe('getVarIntSize thresholds', () => {
+    it('uses 1-byte varint for script length <= 253', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const script253 = new Array(253).fill(0x00)
+      const tx = makeTx([makeScriptInput(script253)], [])
+      const fee = await model.computeFee(tx)
+      // script len 253 ≤ 253, so varint is 1 byte
+      // size = 4 + 1 + 40 + 1 + 253 + 1 + 4 = 304
+      expect(fee).toBe(Math.ceil((304 / 1000) * 1000))
+    })
+
+    it('uses 3-byte varint for script length 254 (> 253)', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const script254 = new Array(254).fill(0x00)
+      const tx = makeTx([makeScriptInput(script254)], [])
+      const fee = await model.computeFee(tx)
+      // script len 254 > 253, so varint is 3 bytes
+      // size = 4 + 1 + 40 + 3 + 254 + 1 + 4 = 307
+      expect(fee).toBe(Math.ceil((307 / 1000) * 1000))
+    })
+
+    it('uses 5-byte varint for script length > 2^16', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      // The condition in getVarIntSize is `i > 2**16` (i.e. strictly greater than 65536).
+      // A script of 65537 bytes is the smallest value that triggers the 5-byte varint path.
+      const bigScript = new Array(65537).fill(0x00)
+      const tx = makeTx([makeScriptInput(bigScript)], [])
+      const fee = await model.computeFee(tx)
+      // varint = 5 bytes (65537 > 2^16)
+      // size = 4 + 1 (input count) + 40 + 5 (script len varint) + 65537 + 1 (output count) + 4 = 65592
+      expect(fee).toBe(Math.ceil((65592 / 1000) * 1000))
+    })
+
+    it('uses multiple inputs and outputs correctly', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const unlockScript = new Array(107).fill(0x00)
+      const lockScript = new Array(25).fill(0x00)
+      const inputs = [
+        makeScriptInput(unlockScript),
+        makeScriptInput(unlockScript),
+        makeScriptInput(unlockScript)
+      ]
+      const outputs = [
+        makeOutput(lockScript),
+        makeOutput(lockScript)
+      ]
+      const tx = makeTx(inputs, outputs)
+
+      const fee = await model.computeFee(tx)
+      // size = 4 + 1 + 3*(40+1+107) + 1 + 2*(8+1+25) + 4
+      //      = 4 + 1 + 444 + 1 + 68 + 4 = 522
+      expect(fee).toBe(Math.ceil((522 / 1000) * 1000))
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // Template vs. compiled script
+  // -------------------------------------------------------------------------
+  describe('unlockingScriptTemplate path', () => {
+    it('calls estimateLength with (tx, inputIndex)', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const templateInput = makeTemplateInput(50)
+      const tx = makeTx([templateInput], [])
+      await model.computeFee(tx)
+      expect(templateInput.unlockingScriptTemplate.estimateLength).toHaveBeenCalledWith(tx, 0)
+    })
+
+    it('correctly handles multiple template inputs, each with different estimated lengths', async () => {
+      const model = new SatoshisPerKilobyte(1000)
+      const input0 = makeTemplateInput(107)
+      const input1 = makeTemplateInput(50)
+      const tx = makeTx([input0, input1], [])
+      const fee = await model.computeFee(tx)
+      // size = 4 + 1 + (40+1+107) + (40+1+50) + 1 + 4 = 249
+      expect(fee).toBe(Math.ceil((249 / 1000) * 1000))
+      expect(input0.unlockingScriptTemplate.estimateLength).toHaveBeenCalledWith(tx, 0)
+      expect(input1.unlockingScriptTemplate.estimateLength).toHaveBeenCalledWith(tx, 1)
+    })
+  })
+})

package/src/transaction/http/__tests/BinaryFetchClient.test.ts

@@ -0,0 +1,212 @@
+import {
+  BinaryFetchClient,
+  BinaryNodejsHttpClient,
+  binaryHttpClient
+} from '../../../transaction/http/BinaryFetchClient'
+import { executeNodejsRequest } from '../../../transaction/http/NodejsHttpRequestUtils'
+
+jest.mock('../../../transaction/http/NodejsHttpRequestUtils', () => ({
+  executeNodejsRequest: jest.fn()
+}))
+
+const mockedExecuteNodejsRequest = executeNodejsRequest as jest.MockedFunction<typeof executeNodejsRequest>
+
+describe('BinaryFetchClient', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  function makeMockFetch (opts: {
+    ok: boolean
+    status: number
+    statusText: string
+    body: string
+  }): jest.Mock {
+    return jest.fn().mockResolvedValue({
+      ok: opts.ok,
+      status: opts.status,
+      statusText: opts.statusText,
+      text: async () => opts.body
+    })
+  }
+
+  it('returns correct HttpClientResponse structure on successful response', async () => {
+    const mockFetch = makeMockFetch({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      body: 'response text'
+    })
+
+    const client = new BinaryFetchClient(mockFetch)
+    const result = await client.request('https://example.com', { method: 'GET' })
+
+    expect(result.ok).toBe(true)
+    expect(result.status).toBe(200)
+    expect(result.statusText).toBe('OK')
+    expect(result.data).toBe('response text')
+  })
+
+  it('sends correct method to fetch', async () => {
+    const mockFetch = makeMockFetch({ ok: true, status: 200, statusText: 'OK', body: '' })
+
+    const client = new BinaryFetchClient(mockFetch)
+    await client.request('https://example.com/endpoint', { method: 'POST' })
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.method).toBe('POST')
+  })
+
+  it('sends correct headers to fetch', async () => {
+    const mockFetch = makeMockFetch({ ok: true, status: 200, statusText: 'OK', body: '' })
+    const headers = { 'Content-Type': 'application/octet-stream', Authorization: 'Bearer token' }
+
+    const client = new BinaryFetchClient(mockFetch)
+    await client.request('https://example.com/endpoint', { method: 'PUT', headers })
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.headers).toEqual(headers)
+  })
+
+  it('sends data as body to fetch', async () => {
+    const mockFetch = makeMockFetch({ ok: true, status: 200, statusText: 'OK', body: '' })
+    const data = Buffer.from('binary data')
+
+    const client = new BinaryFetchClient(mockFetch)
+    await client.request('https://example.com/endpoint', { method: 'POST', data })
+
+    const [, fetchOptions] = mockFetch.mock.calls[0]
+    expect(fetchOptions.body).toBe(data)
+  })
+
+  it('sends correct URL to fetch', async () => {
+    const mockFetch = makeMockFetch({ ok: true, status: 200, statusText: 'OK', body: '' })
+    const url = 'https://example.com/api/v1/resource'
+
+    const client = new BinaryFetchClient(mockFetch)
+    await client.request(url, { method: 'GET' })
+
+    const [calledUrl] = mockFetch.mock.calls[0]
+    expect(calledUrl).toBe(url)
+  })
+
+  it('handles response.text() correctly and stores result as data', async () => {
+    const responseBody = 'raw binary string content'
+    const mockFetch = makeMockFetch({ ok: true, status: 200, statusText: 'OK', body: responseBody })
+
+    const client = new BinaryFetchClient(mockFetch)
+    const result = await client.request<string>('https://example.com', { method: 'GET' })
+
+    expect(result.data).toBe(responseBody)
+  })
+
+  it('reflects non-ok response correctly', async () => {
+    const mockFetch = makeMockFetch({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+      body: 'not found'
+    })
+
+    const client = new BinaryFetchClient(mockFetch)
+    const result = await client.request('https://example.com/missing', { method: 'GET' })
+
+    expect(result.ok).toBe(false)
+    expect(result.status).toBe(404)
+    expect(result.statusText).toBe('Not Found')
+    expect(result.data).toBe('not found')
+  })
+})
+
+describe('BinaryNodejsHttpClient', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('calls executeNodejsRequest with https module, url, options, and Buffer.from serializer', async () => {
+    const mockHttps = {
+      request: jest.fn()
+    }
+
+    const expectedResponse = { ok: true, status: 200, statusText: 'OK', data: Buffer.from('ok') }
+    mockedExecuteNodejsRequest.mockResolvedValue(expectedResponse)
+
+    const client = new BinaryNodejsHttpClient(mockHttps as any)
+    const url = 'https://example.com/binary'
+    const options = { method: 'POST', data: Buffer.from('payload') }
+
+    const result = await client.request(url, options)
+
+    expect(mockedExecuteNodejsRequest).toHaveBeenCalledTimes(1)
+    const [httpsArg, urlArg, optionsArg, serializerArg] = mockedExecuteNodejsRequest.mock.calls[0]
+    expect(httpsArg).toBe(mockHttps)
+    expect(urlArg).toBe(url)
+    expect(optionsArg).toBe(options)
+    expect(typeof serializerArg).toBe('function')
+    expect(result).toBe(expectedResponse)
+  })
+
+  it('serializer passed to executeNodejsRequest wraps data with Buffer.from', async () => {
+    const mockHttps = { request: jest.fn() }
+    mockedExecuteNodejsRequest.mockResolvedValue({
+      ok: true, status: 200, statusText: 'OK', data: ''
+    })
+
+    const client = new BinaryNodejsHttpClient(mockHttps as any)
+    await client.request('https://example.com', { method: 'GET' })
+
+    const serializer = mockedExecuteNodejsRequest.mock.calls[0][3]
+    const input = 'test input'
+    const result = serializer(input)
+    expect(result).toEqual(Buffer.from(input))
+  })
+})
+
+describe('binaryHttpClient', () => {
+  afterEach(() => {
+    if ('window' in globalThis) {
+      delete (globalThis as any).window
+    }
+  })
+
+  it('returns a BinaryFetchClient when window.fetch is available', async () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => 'binary content'
+    })
+
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
+
+    const client = binaryHttpClient()
+    expect(client).toBeDefined()
+    expect(client).toBeInstanceOf(BinaryFetchClient)
+  })
+
+  it('BinaryFetchClient returned by binaryHttpClient uses window.fetch', async () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => 'content'
+    })
+
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
+
+    const client = binaryHttpClient()
+    await client.request('https://example.com', { method: 'GET' })
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns a BinaryNodejsHttpClient when window is absent but require is available (Node.js path)', async () => {
+    if ('window' in globalThis) {
+      delete (globalThis as any).window
+    }
+
+    const client = binaryHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+  })
+})