@bsv/sdk 1.3.12 → 1.3.14

package/src/transaction/broadcasters/ARC.ts

@@ -1,4 +1,8 @@
-import { BroadcastResponse, BroadcastFailure, Broadcaster } from '../Broadcaster.js'
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster
+} from '../Broadcaster.js'
 import Transaction from '../Transaction.js'
 import { HttpClient, HttpClientRequestOptions } from '../http/HttpClient.js'
 import { defaultHttpClient } from '../http/DefaultHttpClient.js'
@@ -21,7 +25,7 @@ export interface ArcConfig {
   headers?: Record<string, string>
 }
 
-function defaultDeploymentId() {
+function defaultDeploymentId(): string {
   return `ts-sdk-${toHex(Random(16))}`
 }
 
@@ -61,7 +65,15 @@ export default class ARC implements Broadcaster {
       this.callbackToken = undefined
       this.callbackUrl = undefined
     } else {
-      const { apiKey, deploymentId, httpClient, callbackToken, callbackUrl, headers } = config ?? {} as ArcConfig
+      const configObj: ArcConfig = config ?? {}
+      const {
+        apiKey,
+        deploymentId,
+        httpClient,
+        callbackToken,
+        callbackUrl,
+        headers
+      } = configObj
       this.apiKey = apiKey
       this.httpClient = httpClient ?? defaultHttpClient()
       this.deploymentId = deploymentId ?? defaultDeploymentId()
@@ -74,25 +86,25 @@ export default class ARC implements Broadcaster {
   /**
    * Constructs a dictionary of the default & supplied request headers.
    */
-  private requestHeaders() {
+  private requestHeaders(): Record<string, string> {
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
       'XDeployment-ID': this.deploymentId
     }
 
-    if (this.apiKey) {
+    if (this.apiKey != null && this.apiKey !== '') {
       headers.Authorization = `Bearer ${this.apiKey}`
     }
 
-    if (this.callbackUrl) {
+    if (this.callbackUrl != null && this.callbackUrl !== '') {
       headers['X-CallbackUrl'] = this.callbackUrl
     }
 
-    if (this.callbackToken) {
+    if (this.callbackToken != null && this.callbackToken !== '') {
       headers['X-CallbackToken'] = this.callbackToken
     }
 
-    if (this.headers) {
+    if (this.headers != null) {
       for (const key in this.headers) {
         headers[key] = this.headers[key]
       }
@@ -107,12 +119,17 @@ export default class ARC implements Broadcaster {
    * @param {Transaction} tx - The transaction to be broadcasted.
    * @returns {Promise<BroadcastResponse | BroadcastFailure>} A promise that resolves to either a success or failure response.
    */
-  async broadcast(tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> {
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
     let rawTx
     try {
       rawTx = tx.toHexEF()
     } catch (error) {
-      if (error.message === 'All inputs must have source transactions when serializing to EF format') {
+      if (
+        error.message ===
+        'All inputs must have source transactions when serializing to EF format'
+      ) {
         rawTx = tx.toHex()
       } else {
         throw error
@@ -126,15 +143,18 @@ export default class ARC implements Broadcaster {
     }
 
     try {
-      const response = await this.httpClient.request<ArcResponse>(`${this.URL}/v1/tx`, requestOptions)
+      const response = await this.httpClient.request<ArcResponse>(
+        `${this.URL}/v1/tx`,
+        requestOptions
+      )
       if (response.ok) {
         const { txid, extraInfo, txStatus, competingTxs } = response.data
-        let broadcastRes: BroadcastResponse = {
+        const broadcastRes: BroadcastResponse = {
           status: 'success',
           txid,
           message: `${txStatus} ${extraInfo}`
         }
-        if (competingTxs) {
+        if (competingTxs != null) {
           broadcastRes.competingTxs = competingTxs
         }
         return broadcastRes
@@ -142,22 +162,29 @@ export default class ARC implements Broadcaster {
         const st = typeof response.status
         const r: BroadcastFailure = {
           status: 'error',
-          code: st === 'number' || st === 'string' ? response.status.toString() : 'ERR_UNKNOWN',
+          code:
+            st === 'number' || st === 'string'
+              ? response.status.toString()
+              : 'ERR_UNKNOWN',
           description: 'Unknown error'
         }
         let d = response.data
         if (typeof d === 'string') {
           try {
-            d = JSON.parse(response.data)
-          } catch { }
+            d = JSON.parse(response.data as string)
+          } catch {
+            // Intentionally left empty
+          }
         }
         if (typeof d === 'object') {
-          r.more = d
-          if (typeof d.txid === 'string') {
-            r.txid = d.txid
+          if (d !== null) {
+            r.more = d
+          }
+          if ((d != null) && typeof (d as { txid: string }).txid === 'string') {
+            r.txid = (d as { txid: string }).txid
           }
-          if (typeof d.detail === 'string') {
-            r.description = d.detail
+          if ((d != null) && 'detail' in d && typeof (d as { detail: string }).detail === 'string') {
+            r.description = (d as { detail: string }).detail
           }
         }
         return r
@@ -166,9 +193,10 @@ export default class ARC implements Broadcaster {
       return {
         status: 'error',
         code: '500',
-        description: typeof error.message === 'string'
-          ? error.message
-          : 'Internal Server Error'
+        description:
+          typeof error.message === 'string'
+            ? error.message
+            : 'Internal Server Error'
       }
     }
   }
@@ -180,38 +208,41 @@ export default class ARC implements Broadcaster {
    * @param {Transaction[]} txs - Array of transactions to be broadcasted.
    * @returns {Promise<Array<object>>} A promise that resolves to an array of objects.
    */
-  async broadcastMany(txs: Transaction[]): Promise<Array<object>> {
-    const rawTxs = txs.map(tx => {
+  async broadcastMany(txs: Transaction[]): Promise<object[]> {
+    const rawTxs = txs.map((tx) => {
       try {
-        return { rawTx: tx.toHexEF() };
+        return { rawTx: tx.toHexEF() }
       } catch (error) {
-        if (error.message === 'All inputs must have source transactions when serializing to EF format') {
-          return { rawTx: tx.toHex() };
+        if (
+          error.message ===
+          'All inputs must have source transactions when serializing to EF format'
+        ) {
+          return { rawTx: tx.toHex() }
         }
-        throw error;
+        throw error
       }
-    });
+    })
 
     const requestOptions: HttpClientRequestOptions = {
       method: 'POST',
       headers: this.requestHeaders(),
       data: rawTxs
-    };
+    }
 
     try {
-      const response = await this.httpClient.request<Array<object>>(
+      const response = await this.httpClient.request<object[]>(
         `${this.URL}/v1/txs`,
         requestOptions
-      );
+      )
 
-      return response.data
+      return response.data as object[]
     } catch (error) {
       const errorResponse: BroadcastFailure = {
         status: 'error',
         code: '500',
-        description: error.message || 'Internal Server Error'
-      };
-      return txs.map(() => errorResponse);
+        description: typeof error.message === 'string' ? error.message : 'Internal Server Error'
+      }
+      return txs.map(() => errorResponse)
     }
   }
 }

package/src/transaction/broadcasters/DefaultBroadcaster.ts

@@ -1,6 +1,12 @@
 import { Broadcaster } from '../Broadcaster.js'
 import ARC, { ArcConfig } from './ARC.js'
 
-export function defaultBroadcaster (isTestnet: boolean = false, config: ArcConfig = {}): Broadcaster {
-  return new ARC(isTestnet ? 'https://arc-test.taal.com' : 'https://arc.taal.com', config)
-}
+export function defaultBroadcaster(
+  isTestnet: boolean = false,
+  config: ArcConfig = {}
+): Broadcaster {
+  return new ARC(
+    isTestnet ? 'https://arc-test.taal.com' : 'https://arc.taal.com',
+    config
+  )
+}

package/src/transaction/broadcasters/WhatsOnChainBroadcaster.ts

@@ -1,4 +1,8 @@
-import { BroadcastResponse, BroadcastFailure, Broadcaster } from '../Broadcaster.js'
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster
+} from '../Broadcaster.js'
 import Transaction from '../Transaction.js'
 import { HttpClient } from '../http/HttpClient.js'
 import { defaultHttpClient } from '../http/DefaultHttpClient.js'
@@ -17,7 +21,10 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
    * @param {'main' | 'test' | 'stn'} network - The BSV network to use when calling the WhatsOnChain API.
    * @param {HttpClient} httpClient - The HTTP client used to make requests to the API.
    */
-  constructor (network: 'main' | 'test' | 'stn' = 'main', httpClient: HttpClient = defaultHttpClient()) {
+  constructor(
+    network: 'main' | 'test' | 'stn' = 'main',
+    httpClient: HttpClient = defaultHttpClient()
+  ) {
     this.network = network
     this.URL = `https://api.whatsonchain.com/v1/bsv/${network}/tx/raw`
     this.httpClient = httpClient
@@ -29,7 +36,9 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
    * @param {Transaction} tx - The transaction to be broadcasted.
    * @returns {Promise<BroadcastResponse | BroadcastFailure>} A promise that resolves to either a success or failure response.
    */
-  async broadcast (tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> {
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
     const rawTx = tx.toHex()
 
     const requestOptions = {
@@ -42,7 +51,10 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
     }
 
     try {
-      const response = await this.httpClient.request<string>(this.URL, requestOptions)
+      const response = await this.httpClient.request<string>(
+        this.URL,
+        requestOptions
+      )
       if (response.ok) {
         const txid = response.data
         return {
@@ -61,9 +73,10 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
       return {
         status: 'error',
         code: '500',
-        description: typeof error.message === 'string'
-          ? error.message
-          : 'Internal Server Error'
+        description:
+          typeof error.message === 'string'
+            ? error.message
+            : 'Internal Server Error'
       }
     }
   }

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

@@ -1,18 +1,22 @@
-import ARC from '../../../../dist/cjs/src/transaction/broadcasters/ARC.js'
-import Transaction from '../../../../dist/cjs/src/transaction/Transaction.js'
-import {NodejsHttpClient} from "../../../../dist/cjs/src/transaction/http/NodejsHttpClient.js";
-import {FetchHttpClient} from "../../../../dist/cjs/src/transaction/http/FetchHttpClient.js";
-import {HttpClientRequestOptions} from "../../http";
+import ARC from '../../../transaction/broadcasters/ARC'
+import Transaction from '../../../transaction/Transaction'
+import { NodejsHttpClient } from '../../../transaction/http/NodejsHttpClient'
+import { FetchHttpClient } from '../../../transaction/http/FetchHttpClient'
+import { HttpClientRequestOptions } from '../../http'
+import { RequestOptions } from 'https'
 
 // Mock Transaction
-jest.mock('../../Transaction', () => {
-  return {
-    default: jest.fn().mockImplementation(() => {
-      return {
-        toHex: () => 'mocked_transaction_hex'
-      }
-    })
+jest.mock('../../../transaction/Transaction', () => {
+  class MockTransaction {
+    toHex (): string {
+      return 'mocked_transaction_hex'
+    }
+
+    toHexEF (): string {
+      return 'mocked_transaction_hexEF'
+    }
   }
+  return { __esModule: true, default: MockTransaction }
 })
 
 describe('ARC Broadcaster', () => {
@@ -35,7 +39,7 @@ describe('ARC Broadcaster', () => {
   it('should broadcast successfully using window.fetch', async () => {
     // Mocking window.fetch
     const mockFetch = mockedFetch(successResponse)
-    global.window = {fetch: mockFetch} as any
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
 
     const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
@@ -51,7 +55,9 @@ describe('ARC Broadcaster', () => {
   it('should broadcast successfully using Node.js https', async () => {
     // Mocking Node.js https module
     mockedHttps(successResponse)
-    delete global.window
+    if ('window' in globalThis) {
+      delete (globalThis as { window?: unknown }).window // ✅ Explicit property check
+    }
 
     const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
@@ -64,10 +70,11 @@ describe('ARC Broadcaster', () => {
   })
 
   it('should broadcast successfully using provided fetch', async () => {
-
     const mockFetch = mockedFetch(successResponse)
 
-    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -79,9 +86,10 @@ describe('ARC Broadcaster', () => {
   })
 
   it('should broadcast successfully using provided https', async () => {
-
     const mockHttps = mockedHttps(successResponse)
-    const broadcaster = new ARC(URL, {httpClient: new NodejsHttpClient(mockHttps)})
+    const broadcaster = new ARC(URL, {
+      httpClient: new NodejsHttpClient(mockHttps)
+    })
 
     const response = await broadcaster.broadcast(transaction)
 
@@ -95,63 +103,79 @@ describe('ARC Broadcaster', () => {
   it('should send default request headers when broadcasting', async () => {
     const mockFetch = mockedFetch(successResponse)
 
-    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     await broadcaster.broadcast(transaction)
 
-    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+    // Ensure headers exist and cast to the correct type
+    const requestOptions = mockFetch.mock.calls[0][1] as HttpClientRequestOptions
+    const headers = (requestOptions?.headers ?? {}) // ✅ Proper typing
 
     expect(headers['Content-Type']).toEqual('application/json')
     expect(headers['XDeployment-ID']).toBeDefined()
     expect(headers['XDeployment-ID']).toMatch(/ts-sdk-.*/)
-    expect(headers['Authorization']).toBeUndefined()
+    expect(headers.Authorization).toBeUndefined()
   })
 
   it('should send authorization header when api key is provided', async () => {
     const mockFetch = mockedFetch(successResponse)
     const apiKey = 'mainnet_1234567890'
 
-    const broadcaster = new ARC(URL, {apiKey, httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      apiKey,
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     await broadcaster.broadcast(transaction)
 
-    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+    // Extract and properly type headers
+    const requestOptions = mockFetch.mock.calls[0][1] as HttpClientRequestOptions
+    const headers = (requestOptions?.headers ?? {}) // ✅ Correct typing
 
     expect(headers['XDeployment-ID']).toBeDefined()
     expect(headers['XDeployment-ID']).toMatch(/ts-sdk-.*/)
-    expect(headers['Authorization']).toEqual(`Bearer ${apiKey}`)
+    expect(headers.Authorization).toEqual(`Bearer ${apiKey}`) // ✅ Now properly typed
   })
 
   it('should handle api key as second argument', async () => {
     const mockFetch = mockedFetch(successResponse)
-    global.window = {fetch: mockFetch} as any
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
 
     const apiKey = 'mainnet_1234567890'
 
     const broadcaster = new ARC(URL, apiKey)
     await broadcaster.broadcast(transaction)
 
-    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+    // Ensure headers is always defined
+    const headers = (mockFetch.mock.calls[0][1] as HttpClientRequestOptions)?.headers ?? {}
 
-    expect(headers['Authorization']).toEqual(`Bearer ${apiKey}`)
+    expect(headers.Authorization).toEqual(`Bearer ${apiKey}`)
   })
 
-
   it('should send provided deployment id', async () => {
     const mockFetch = mockedFetch(successResponse)
     const deploymentId = 'custom_deployment_id'
 
-    const broadcaster = new ARC(URL, {deploymentId, httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      deploymentId,
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     await broadcaster.broadcast(transaction)
 
-    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+    // Ensure headers is always defined
+    const headers =
+    (mockFetch.mock.calls[0]?.[1]?.headers) ?? {}
 
     expect(headers['XDeployment-ID']).toEqual(deploymentId)
   })
 
   it('should handle network errors', async () => {
     const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
-    global.window = {fetch: mockFetch} as any
+    global.window = { fetch: mockFetch } as unknown as Window & typeof globalThis
 
-    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -164,13 +188,15 @@ describe('ARC Broadcaster', () => {
 
   it('should handle non-200 responses', async () => {
     const mockFetch = mockedFetch({
-      status: '400',
+      status: 400,
       data: JSON.stringify({
         detail: 'Bad request'
       })
     })
 
-    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
+    const broadcaster = new ARC(URL, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -185,15 +211,7 @@ describe('ARC Broadcaster', () => {
   })
 
   it('handles error 460', async () => {
-    // Model the actual response format received from...
-    const apiKey: string = '...'
-    if (apiKey !== '...') {
-      const URL = 'https://arc.taal.com'
-      const arc = new ARC(URL, apiKey)
-      const response = await arc.broadcast(transaction)
-      expect(response.more).toBeTruthy()
-    }
-
+    // Mock the fetch response to simulate the error 460 response
     const mockFetch = mockedFetch({
       status: 460,
       data: {
@@ -203,45 +221,94 @@ describe('ARC Broadcaster', () => {
       }
     })
 
-    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
+    // Initialize the ARC broadcaster with the mocked fetch client
+    const URL = 'https://arc.taal.com'
+    const apiKey = 'mock_api_key' // Example API key
+    const broadcaster = new ARC(URL, {
+      apiKey,
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    // Simulate broadcasting the transaction
     const response = await broadcaster.broadcast(transaction)
-    expect(response.status).toBe('error')
-    expect(response.code).toBe('460')
-    expect(response.description).toBe('Transaction is not in extended format, missing input scripts')
-    expect(response.txid).toBe('d21633ba23f70118185227be58a63527675641ad37967e2aa461559f577aec43')
+
+    // Check if the response is an error as expected
+    if (response.status === 'error') {
+      // Validate the BroadcastFailure response properties
+      expect(response.status).toBe('error')
+      expect(response.code).toBe('460')
+      expect(response.description).toBe(
+        'Transaction is not in extended format, missing input scripts'
+      )
+      expect(response.txid).toBe(
+        'd21633ba23f70118185227be58a63527675641ad37967e2aa461559f577aec43'
+      )
+      expect(response.more).toBeTruthy() // Validate the presence of additional error details
+    } else {
+      // Fail the test if the response is not an error
+      fail('Expected a BroadcastFailure but got a BroadcastResponse')
+    }
   })
 
-  function mockedFetch(response) {
+  function mockedFetch (response: { status: number, data: any }): jest.Mock {
     return jest.fn().mockResolvedValue({
       ok: response.status === 200,
       status: response.status,
       statusText: response.status === 200 ? 'OK' : 'Bad request',
       headers: {
-        get(key: string) {
+        get: (key: string): string | undefined => {
           if (key === 'Content-Type') {
             return 'application/json; charset=UTF-8'
           }
+          return undefined
         }
       },
       json: async () => response.data
-    });
+    })
   }
 
-  function mockedHttps(response) {
+  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
+    }
+  } {
     const https = {
-      request: (url, options, callback) => {
-        // eslint-disable-next-line
-        callback({
+      request: (
+        url: string,
+        options: RequestOptions,
+        callback: (res: {
+          statusCode: number
+          statusMessage: string
+          headers: { 'content-type': string }
+          on: (event: string, handler: (chunk?: any) => void) => void
+        }) => void
+      ) => {
+        const mockResponse = {
           statusCode: response.status,
-          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          statusMessage: response.status === 200 ? 'OK' : 'Bad request',
           headers: {
             'content-type': 'application/json; charset=UTF-8'
           },
-          on: (event, handler) => {
+          on (event: string, handler: (chunk?: any) => void) {
             if (event === 'data') handler(JSON.stringify(response.data))
             if (event === 'end') handler()
           }
-        })
+        }
+
+        // ✅ Call the callback asynchronously to match Node.js behavior
+        process.nextTick(() => callback(mockResponse))
+
         return {
           on: jest.fn(),
           write: jest.fn(),
@@ -249,7 +316,8 @@ describe('ARC Broadcaster', () => {
         }
       }
     }
+
     jest.mock('https', () => https)
     return https
   }
-})
+})