@bsv/sdk 1.3.13 → 1.3.14

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

@@ -3,14 +3,16 @@ 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/Transaction', () => {
   class MockTransaction {
-    toHex() {
+    toHex (): string {
       return 'mocked_transaction_hex'
     }
-    toHexEF() {
+
+    toHexEF (): string {
       return 'mocked_transaction_hexEF'
     }
   }
@@ -37,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)
@@ -53,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)
@@ -104,13 +108,14 @@ describe('ARC Broadcaster', () => {
     })
     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 () => {
@@ -123,27 +128,28 @@ describe('ARC Broadcaster', () => {
     })
     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 () => {
@@ -156,15 +162,16 @@ describe('ARC Broadcaster', () => {
     })
     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)
@@ -181,7 +188,7 @@ describe('ARC Broadcaster', () => {
 
   it('should handle non-200 responses', async () => {
     const mockFetch = mockedFetch({
-      status: '400',
+      status: 400,
       data: JSON.stringify({
         detail: 'Bad request'
       })
@@ -243,37 +250,65 @@ describe('ARC Broadcaster', () => {
     }
   })
 
-  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(),
@@ -281,6 +316,7 @@ describe('ARC Broadcaster', () => {
         }
       }
     }
+
     jest.mock('https', () => https)
     return https
   }

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

@@ -1,15 +1,16 @@
 import Transaction from '../../../transaction/Transaction'
-import { NodejsHttpClient } from '../../../transaction/http/NodejsHttpClient'
+import { NodejsHttpClient, HttpsNodejs } from '../../../transaction/http/NodejsHttpClient'
 import WhatsOnChainBroadcaster from '../../../transaction/broadcasters/WhatsOnChainBroadcaster'
 import { FetchHttpClient } from '../../../transaction/http/FetchHttpClient'
 
 // Mock Transaction
 jest.mock('../../../transaction/Transaction', () => {
   class MockTransaction {
-    toHex() {
+    toHex (): String {
       return 'mocked_transaction_hex'
     }
-    toHexEF() {
+
+    toHexEF (): String {
       return 'mocked_transaction_hexEF'
     }
   }
@@ -78,7 +79,7 @@ describe('WhatsOnChainBroadcaster', () => {
   })
 
   it('should broadcast successfully using provided https', async () => {
-    const mockHttps = mockedHttps(successResponse)
+    const mockHttps = mockedHttps(successResponse) as unknown as HttpsNodejs
     const broadcaster = new WhatsOnChainBroadcaster(
       network,
       new NodejsHttpClient(mockHttps)
@@ -126,13 +127,13 @@ describe('WhatsOnChainBroadcaster', () => {
     })
   })
 
-  function mockedFetch(response) {
+  function mockedFetch (response: any): jest.Mock<any, any, any> {
     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) {
           if (key === 'Content-Type') {
             return 'text/plain'
           }
@@ -142,13 +143,13 @@ describe('WhatsOnChainBroadcaster', () => {
     })
   }
 
-  function mockedHttps(response) {
+  function mockedHttps (response: any): { request: Function } {
     const https = {
       request: (url, options, callback) => {
         // eslint-disable-next-line
         callback({
           statusCode: response.status,
-          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          statusMessage: response.status === 200 ? 'OK' : 'Bad request',
           headers: {
             'content-type': 'text/plain'
           },

package/src/transaction/broadcasters/index.ts

@@ -1,4 +1,4 @@
-export { default as ARC } from "./ARC";
-export type { ArcConfig } from "./ARC";
-export { default as WhatsOnChainBroadcaster } from "./WhatsOnChainBroadcaster";
-export { defaultBroadcaster } from "./DefaultBroadcaster";
+export { default as ARC } from './ARC.js'
+export type { ArcConfig } from './ARC.js'
+export { default as WhatsOnChainBroadcaster } from './WhatsOnChainBroadcaster.js'
+export { defaultBroadcaster } from './DefaultBroadcaster.js'

package/src/transaction/chaintrackers/DefaultChainTracker.ts

@@ -1,6 +1,6 @@
-import WhatsOnChain from "./WhatsOnChain";
-import ChainTracker from "../ChainTracker";
+import WhatsOnChain from './WhatsOnChain.js'
+import ChainTracker from '../ChainTracker.js'
 
 export function defaultChainTracker(): ChainTracker {
-  return new WhatsOnChain();
+  return new WhatsOnChain()
 }

package/src/transaction/chaintrackers/WhatsOnChain.ts

@@ -1,27 +1,28 @@
-import ChainTracker from "../ChainTracker";
-import { HttpClient } from "../http/HttpClient";
-import { defaultHttpClient } from "../http/DefaultHttpClient";
+
+import ChainTracker from '../ChainTracker.js'
+import { HttpClient } from '../http/HttpClient.js'
+import { defaultHttpClient } from '../http/DefaultHttpClient.js'
 
 /** Configuration options for the WhatsOnChain ChainTracker. */
 export interface WhatsOnChainConfig {
   /** Authentication token for the WhatsOnChain API */
-  apiKey?: string;
+  apiKey?: string
   /** The HTTP client used to make requests to the API. */
-  httpClient?: HttpClient;
+  httpClient?: HttpClient
 }
 
 interface WhatsOnChainBlockHeader {
-  merkleroot: string;
+  merkleroot: string
 }
 
 /**
  * Represents a chain tracker based on What's On Chain .
  */
 export default class WhatsOnChain implements ChainTracker {
-  readonly network: string;
-  readonly apiKey: string;
-  private readonly URL: string;
-  private readonly httpClient: HttpClient;
+  readonly network: string
+  readonly apiKey: string
+  private readonly URL: string
+  private readonly httpClient: HttpClient
 
   /**
    * Constructs an instance of the WhatsOnChain ChainTracker.
@@ -30,72 +31,72 @@ export default class WhatsOnChain implements ChainTracker {
    * @param {WhatsOnChainConfig} config - Configuration options for the WhatsOnChain ChainTracker.
    */
   constructor(
-    network: "main" | "test" | "stn" = "main",
+    network: 'main' | 'test' | 'stn' = 'main',
     config: WhatsOnChainConfig = {}
   ) {
-    const { apiKey, httpClient } = config;
-    this.network = network;
-    this.URL = `https://api.whatsonchain.com/v1/bsv/${network}`;
-    this.httpClient = httpClient ?? defaultHttpClient();
-    this.apiKey = apiKey;
+    const { apiKey, httpClient } = config
+    this.network = network
+    this.URL = `https://api.whatsonchain.com/v1/bsv/${network}`
+    this.httpClient = httpClient ?? defaultHttpClient()
+    this.apiKey = apiKey ?? ''
   }
 
   async isValidRootForHeight(root: string, height: number): Promise<boolean> {
     const requestOptions = {
-      method: "GET",
-      headers: this.getHttpHeaders(),
-    };
+      method: 'GET',
+      headers: this.getHttpHeaders()
+    }
 
     const response = await this.httpClient.request<WhatsOnChainBlockHeader>(
       `${this.URL}/block/${height}/header`,
       requestOptions
-    );
+    )
     if (response.ok) {
-      const { merkleroot } = response.data;
-      return merkleroot === root;
+      const { merkleroot } = response.data
+      return merkleroot === root
     } else if (response.status === 404) {
-      return false;
+      return false
     } else {
       throw new Error(
         `Failed to verify merkleroot for height ${height} because of an error: ${JSON.stringify(response.data)} `
-      );
+      )
     }
   }
 
   async currentHeight(): Promise<number> {
     try {
       const requestOptions = {
-        method: "GET",
-        headers: this.getHttpHeaders(),
-      };
+        method: 'GET',
+        headers: this.getHttpHeaders()
+      }
 
       const response = await this.httpClient.request<{ height: number }>(
         `${this.URL}/block/headers`,
         requestOptions
-      );
+      )
       if (response.ok) {
-        return response.data[0].height;
+        return response.data[0].height
       } else {
         throw new Error(
           `Failed to get current height because of an error: ${JSON.stringify(response.data)} `
-        );
+        )
       }
     } catch (error) {
       throw new Error(
-        `Failed to get current height because of an error: ${error?.message}`
-      );
+        `Failed to get current height because of an error: ${error instanceof Error ? error.message : String(error)}`
+      )
     }
   }
 
-  private getHttpHeaders() {
+  private getHttpHeaders(): Record<string, string> {
     const headers: Record<string, string> = {
-      Accept: "application/json",
-    };
+      Accept: 'application/json'
+    }
 
-    if (this.apiKey) {
-      headers.Authorization = this.apiKey;
+    if (typeof this.apiKey === 'string' && this.apiKey.trim() !== '') {
+      headers.Authorization = this.apiKey
     }
 
-    return headers;
+    return headers
   }
 }