@bsv/sdk 2.0.12 → 2.0.13

package/src/transaction/http/__tests/DefaultHttpClient.additional.test.ts

@@ -0,0 +1,192 @@
+// Additional coverage for DefaultHttpClient.ts lines 13 and 28-31:
+//   Line 13   — noHttpClient.request throws 'No method available...'
+//   Lines 28-31 — catch(e) path when require('https') throws → returns noHttpClient
+//              — else path when require is undefined → returns noHttpClient
+//
+// Strategy: jest.isolateModules() reloads the module fresh for every sub-test,
+// allowing us to control whether `https` throws on require.
+
+describe('defaultHttpClient — noHttpClient fallback paths', () => {
+  afterEach(() => {
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+    jest.resetModules()
+  })
+
+  // --------------------------------------------------------------------------
+  // Lines 28-29: require('https') throws → fall back to noHttpClient
+  // Line 13:     noHttpClient.request() throws the expected error message
+  // --------------------------------------------------------------------------
+
+  it('returns a noHttpClient that throws when require("https") throws', async () => {
+    // Make the https module unavailable so the try/catch in DefaultHttpClient fires
+    jest.mock('https', () => {
+      throw new Error('https module not available')
+    })
+
+    // window must be absent so the fetch branch is skipped
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let defaultHttpClient: any
+
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/DefaultHttpClient')
+      defaultHttpClient = mod.defaultHttpClient
+    })
+
+    // The function must still return a client object (noHttpClient)
+    const client = (defaultHttpClient as any)()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+
+    // Calling request() must throw 'No method available to perform HTTP request'
+    await expect(
+      client.request('https://example.com', { method: 'GET' })
+    ).rejects.toThrow('No method available to perform HTTP request')
+  })
+
+  // --------------------------------------------------------------------------
+  // Additional: verify the error message text exactly (line 13 text coverage)
+  // --------------------------------------------------------------------------
+
+  it('noHttpClient.request throws with the exact message text', async () => {
+    jest.mock('https', () => {
+      throw new Error('https not available')
+    })
+
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let client: any
+
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/DefaultHttpClient')
+      client = mod.defaultHttpClient()
+    })
+
+    let thrown: Error | undefined
+    try {
+      await client.request('https://example.com', { method: 'POST', data: {} })
+    } catch (e) {
+      thrown = e as Error
+    }
+
+    expect(thrown).toBeInstanceOf(Error)
+    expect(thrown?.message).toBe('No method available to perform HTTP request')
+  })
+
+  // --------------------------------------------------------------------------
+  // Sanity: confirm the Node.js happy path still works after mock is cleared
+  // --------------------------------------------------------------------------
+
+  it('returns a working NodejsHttpClient when require("https") succeeds (Node.js path)', () => {
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let defaultHttpClient: any
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/DefaultHttpClient')
+      defaultHttpClient = mod.defaultHttpClient
+    })
+
+    const client = defaultHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+  })
+})
+
+// --------------------------------------------------------------------------
+// Additional coverage for BinaryFetchClient.ts lines 97, 112-115:
+//   Line 97    — noHttpClient.request throws 'No method available...'
+//   Lines 112-113 — catch(e) path when require('https') throws
+//   Lines 114-115 — else path when require is undefined
+// --------------------------------------------------------------------------
+
+describe('binaryHttpClient — noHttpClient fallback paths', () => {
+  afterEach(() => {
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+    jest.resetModules()
+  })
+
+  it('returns a noHttpClient that throws when require("https") throws', async () => {
+    jest.mock('https', () => {
+      throw new Error('https module not available')
+    })
+
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let binaryHttpClient: any
+
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/BinaryFetchClient')
+      binaryHttpClient = mod.binaryHttpClient
+    })
+
+    const client = binaryHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+
+    // Line 97: calling request on the noHttpClient throws
+    await expect(
+      client.request('https://example.com', { method: 'GET' })
+    ).rejects.toThrow('No method available to perform HTTP request')
+  })
+
+  it('noHttpClient.request in binaryHttpClient throws with the exact message text', async () => {
+    jest.mock('https', () => {
+      throw new Error('https not available')
+    })
+
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let client: any
+
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/BinaryFetchClient')
+      client = mod.binaryHttpClient()
+    })
+
+    let thrown: Error | undefined
+    try {
+      await client.request('https://example.com', { method: 'POST', data: new Uint8Array([1, 2]) })
+    } catch (e) {
+      thrown = e as Error
+    }
+
+    expect(thrown).toBeInstanceOf(Error)
+    expect(thrown?.message).toBe('No method available to perform HTTP request')
+  })
+
+  it('returns a working BinaryNodejsHttpClient when require("https") succeeds', () => {
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window
+    }
+
+    let binaryHttpClient: any
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const mod = require('../../../transaction/http/BinaryFetchClient')
+      binaryHttpClient = mod.binaryHttpClient
+    })
+
+    const client = binaryHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+  })
+})

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

@@ -0,0 +1,71 @@
+import { defaultHttpClient } from '../../../transaction/http/DefaultHttpClient'
+
+describe('defaultHttpClient', () => {
+  afterEach(() => {
+    // Restore window if it was set
+    if ('window' in globalThis) {
+      delete (globalThis as any).window
+    }
+  })
+
+  it('returns a FetchHttpClient (with a request method) when window.fetch is available', async () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        get: (_key: string) => 'application/json'
+      },
+      json: async () => ({ result: 'ok' })
+    })
+
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
+
+    const client = defaultHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+
+    // Verify it actually uses the window.fetch by making a request
+    await client.request('https://example.com', { method: 'GET' })
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns an httpClient whose request() uses the bound window.fetch', async () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        get: (_key: string) => null
+      },
+      text: async () => 'plain text body'
+    })
+
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
+
+    const client = defaultHttpClient()
+    const response = await client.request('https://example.com/api', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      data: { foo: 'bar' }
+    })
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const [calledUrl, calledOptions] = mockFetch.mock.calls[0]
+    expect(calledUrl).toBe('https://example.com/api')
+    expect(calledOptions.method).toBe('POST')
+    expect(response.ok).toBe(true)
+    expect(response.status).toBe(200)
+  })
+
+  it('returns a NodejsHttpClient when window is absent but require is available (Node.js path)', async () => {
+    // Remove window to force the Node.js path
+    if ('window' in globalThis) {
+      delete (globalThis as any).window
+    }
+
+    const client = defaultHttpClient()
+    expect(client).toBeDefined()
+    expect(typeof client.request).toBe('function')
+  })
+})

package/src/wallet/__tests/ProtoWallet.additional.test.ts

@@ -0,0 +1,134 @@
+import ProtoWallet from '../../wallet/ProtoWallet'
+import PrivateKey from '../../primitives/PrivateKey'
+
+function walletWithNullKeyDeriver (): ProtoWallet {
+  const wallet = new ProtoWallet(PrivateKey.fromRandom())
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(wallet as any).keyDeriver = undefined
+  return wallet
+}
+
+describe('ProtoWallet – additional coverage', () => {
+  describe('getPublicKey', () => {
+    it('throws when identityKey is true and keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(wallet.getPublicKey({ identityKey: true })).rejects.toThrow(
+        'keyDeriver is undefined'
+      )
+    })
+
+    it('throws when protocolID and keyID are missing (non-identityKey path)', async () => {
+      const wallet = new ProtoWallet(PrivateKey.fromRandom())
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await expect(wallet.getPublicKey({} as any)).rejects.toThrow(
+        'protocolID and keyID are required'
+      )
+    })
+
+    it('throws when keyDeriver is null and identityKey is false', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.getPublicKey({
+          protocolID: [1, 'test'],
+          keyID: 'key1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('encrypt', () => {
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.encrypt({
+          plaintext: [1, 2, 3],
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('decrypt', () => {
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.decrypt({
+          ciphertext: [1, 2, 3],
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('createHmac', () => {
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.createHmac({
+          data: [1, 2, 3],
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('verifyHmac', () => {
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.verifyHmac({
+          data: [1, 2, 3],
+          hmac: new Array(32).fill(0),
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('createSignature', () => {
+    it('throws when both data and hashToDirectlySign are missing', async () => {
+      const wallet = new ProtoWallet(PrivateKey.fromRandom())
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await expect(wallet.createSignature({} as any)).rejects.toThrow(
+        'args.data or args.hashToDirectlySign must be valid'
+      )
+    })
+
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.createSignature({
+          data: [1, 2, 3],
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+
+  describe('verifySignature', () => {
+    it('throws when both data and hashToDirectlyVerify are missing', async () => {
+      const wallet = new ProtoWallet(PrivateKey.fromRandom())
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await expect(wallet.verifySignature({} as any)).rejects.toThrow(
+        'args.data or args.hashToDirectlyVerify must be valid'
+      )
+    })
+
+    it('throws when keyDeriver is null', async () => {
+      const wallet = walletWithNullKeyDeriver()
+      await expect(
+        wallet.verifySignature({
+          data: [1, 2, 3],
+          signature: [1, 2, 3],
+          protocolID: [1, 'test'],
+          keyID: 'k1'
+        })
+      ).rejects.toThrow('keyDeriver is undefined')
+    })
+  })
+})

package/src/wallet/__tests/WERR.test.ts

@@ -0,0 +1,212 @@
+import { WERR_REVIEW_ACTIONS } from '../WERR_REVIEW_ACTIONS'
+import { WERR_INSUFFICIENT_FUNDS } from '../WERR_INSUFFICIENT_FUNDS'
+import { WERR_INVALID_PARAMETER } from '../WERR_INVALID_PARAMETER'
+import type { ReviewActionResult, SendWithResult } from '../Wallet.interfaces'
+
+// ---------------------------------------------------------------------------
+// WERR_REVIEW_ACTIONS
+// ---------------------------------------------------------------------------
+describe('WERR_REVIEW_ACTIONS', () => {
+  const reviewActionResults: ReviewActionResult[] = [
+    { txid: 'aaaa', status: 'success' }
+  ]
+  const sendWithResults: SendWithResult[] = [
+    { txid: 'bbbb', status: 'unproven' }
+  ]
+
+  it('is an instance of Error', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err).toBeInstanceOf(Error)
+  })
+
+  it('has the fixed message about review requirements', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.message).toBe(
+      'Undelayed createAction or signAction results require review.'
+    )
+  })
+
+  it('has code 5', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.code).toBe(5)
+  })
+
+  it('has name WERR_REVIEW_ACTIONS', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.name).toBe('WERR_REVIEW_ACTIONS')
+  })
+
+  it('has isError true', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.isError).toBe(true)
+  })
+
+  it('stores reviewActionResults on the instance', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.reviewActionResults).toEqual(reviewActionResults)
+  })
+
+  it('stores sendWithResults on the instance', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.sendWithResults).toEqual(sendWithResults)
+  })
+
+  it('txid defaults to undefined when not provided', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.txid).toBeUndefined()
+  })
+
+  it('stores optional txid when provided', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults, 'txid123')
+    expect(err.txid).toBe('txid123')
+  })
+
+  it('tx defaults to undefined when not provided', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.tx).toBeUndefined()
+  })
+
+  it('stores optional tx when provided', () => {
+    const tx = [0xde, 0xad, 0xbe, 0xef]
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults, undefined, tx)
+    expect(err.tx).toEqual(tx)
+  })
+
+  it('noSendChange defaults to undefined when not provided', () => {
+    const err = new WERR_REVIEW_ACTIONS(reviewActionResults, sendWithResults)
+    expect(err.noSendChange).toBeUndefined()
+  })
+
+  it('stores optional noSendChange when provided', () => {
+    const noSendChange = ['outpoint:0', 'outpoint:1']
+    const err = new WERR_REVIEW_ACTIONS(
+      reviewActionResults,
+      sendWithResults,
+      undefined,
+      undefined,
+      noSendChange
+    )
+    expect(err.noSendChange).toEqual(noSendChange)
+  })
+
+  it('all five optional/required fields are accessible together', () => {
+    const tx = [1, 2, 3]
+    const noSendChange = ['out:0']
+    const err = new WERR_REVIEW_ACTIONS(
+      reviewActionResults,
+      sendWithResults,
+      'txid_full',
+      tx,
+      noSendChange
+    )
+    expect(err.reviewActionResults).toEqual(reviewActionResults)
+    expect(err.sendWithResults).toEqual(sendWithResults)
+    expect(err.txid).toBe('txid_full')
+    expect(err.tx).toEqual(tx)
+    expect(err.noSendChange).toEqual(noSendChange)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// WERR_INSUFFICIENT_FUNDS
+// ---------------------------------------------------------------------------
+describe('WERR_INSUFFICIENT_FUNDS', () => {
+  it('is an instance of Error', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(err).toBeInstanceOf(Error)
+  })
+
+  it('has code 7', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(err.code).toBe(7)
+  })
+
+  it('has name WERR_INSUFFICIENT_FUNDS', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(err.name).toBe('WERR_INSUFFICIENT_FUNDS')
+  })
+
+  it('has isError true', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(err.isError).toBe(true)
+  })
+
+  it('stores totalSatoshisNeeded on the instance', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(2500, 1200)
+    expect(err.totalSatoshisNeeded).toBe(2500)
+  })
+
+  it('stores moreSatoshisNeeded on the instance', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(2500, 1200)
+    expect(err.moreSatoshisNeeded).toBe(1200)
+  })
+
+  it('message contains moreSatoshisNeeded value', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(3000, 750)
+    expect(err.message).toContain('750')
+  })
+
+  it('message contains totalSatoshisNeeded value', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(3000, 750)
+    expect(err.message).toContain('3000')
+  })
+
+  it('message contains both values and key phrase', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(err.message).toMatch(/500 more satoshis are needed/)
+    expect(err.message).toMatch(/total of 1000/)
+  })
+
+  it('handles zero values', () => {
+    const err = new WERR_INSUFFICIENT_FUNDS(0, 0)
+    expect(err.totalSatoshisNeeded).toBe(0)
+    expect(err.moreSatoshisNeeded).toBe(0)
+    expect(err.message).toContain('0')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// WERR_INVALID_PARAMETER
+// ---------------------------------------------------------------------------
+describe('WERR_INVALID_PARAMETER', () => {
+  it('is an instance of Error', () => {
+    const err = new WERR_INVALID_PARAMETER('myParam', 'a valid string')
+    expect(err).toBeInstanceOf(Error)
+  })
+
+  it('has code 6', () => {
+    const err = new WERR_INVALID_PARAMETER('myParam', 'a valid string')
+    expect(err.code).toBe(6)
+  })
+
+  it('has name WERR_INVALID_PARAMETER', () => {
+    const err = new WERR_INVALID_PARAMETER('myParam', 'a valid string')
+    expect(err.name).toBe('WERR_INVALID_PARAMETER')
+  })
+
+  it('has isError true', () => {
+    const err = new WERR_INVALID_PARAMETER('myParam', 'a valid string')
+    expect(err.isError).toBe(true)
+  })
+
+  it('stores parameter on the instance', () => {
+    const err = new WERR_INVALID_PARAMETER('outputValue', 'a positive number')
+    expect(err.parameter).toBe('outputValue')
+  })
+
+  it('message includes the parameter name and mustBe description', () => {
+    const err = new WERR_INVALID_PARAMETER('amount', 'greater than zero')
+    expect(err.message).toBe('The amount parameter must be greater than zero')
+  })
+
+  it('uses default mustBe text ("valid.") when mustBe is not provided', () => {
+    const err = new WERR_INVALID_PARAMETER('lockingScript')
+    expect(err.message).toBe('The lockingScript parameter must be valid.')
+  })
+
+  it('handles an empty string for parameter', () => {
+    const err = new WERR_INVALID_PARAMETER('', 'non-empty')
+    expect(err.parameter).toBe('')
+    expect(err.message).toContain('non-empty')
+  })
+})