@bsv/sdk 1.0.32 → 1.0.34

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

@@ -1,5 +1,8 @@
 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";
 
 // Mock Transaction
 jest.mock('../../Transaction', () => {
@@ -14,27 +17,27 @@ jest.mock('../../Transaction', () => {
 
 describe('ARC Broadcaster', () => {
   const URL = 'https://example.com'
-  const apiKey = 'test_api_key'
-  let broadcaster: ARC
+  const successResponse = {
+    status: 200,
+    data: {
+      txid: 'mocked_txid',
+      txStatus: 'success',
+      extraInfo: 'received'
+    }
+  }
+
   let transaction: Transaction
 
   beforeEach(() => {
-    broadcaster = new ARC(URL, apiKey)
     transaction = new Transaction()
   })
 
   it('should broadcast successfully using window.fetch', async () => {
     // Mocking window.fetch
-    const mockFetch = jest.fn().mockResolvedValue({
-      ok: true,
-      json: async () => await Promise.resolve({
-        txid: 'mocked_txid',
-        txStatus: 'success',
-        extraInfo: 'received'
-      })
-    })
-    global.window = { fetch: mockFetch } as any
+    const mockFetch = mockedFetch(successResponse)
+    global.window = {fetch: mockFetch} as any
 
+    const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -47,29 +50,10 @@ describe('ARC Broadcaster', () => {
 
   it('should broadcast successfully using Node.js https', async () => {
     // Mocking Node.js https module
-    jest.mock('https', () => ({
-      request: (url, options, callback) => {
-        // eslint-disable-next-line
-        callback({
-          statusCode: 200,
-          on: (event, handler) => {
-            if (event === 'data') handler(JSON.stringify({
-              txid: 'mocked_txid',
-              txStatus: 'success',
-              extraInfo: 'received'
-            }))
-            if (event === 'end') handler()
-          }
-        })
-        return {
-          on: jest.fn(),
-          write: jest.fn(),
-          end: jest.fn()
-        }
-      }
-    }))
-
+    mockedHttps(successResponse)
     delete global.window
+
+    const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
 
     expect(response).toEqual({
@@ -79,10 +63,95 @@ 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 response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should broadcast successfully using provided https', async () => {
+
+    const mockHttps = mockedHttps(successResponse)
+    const broadcaster = new ARC(URL, {httpClient: new NodejsHttpClient(mockHttps)})
+
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should send default request headers when broadcasting', async () => {
+    const mockFetch = mockedFetch(successResponse)
+
+    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
+
+    expect(headers['Content-Type']).toEqual('application/json')
+    expect(headers['XDeployment-ID']).toBeDefined()
+    expect(headers['XDeployment-ID']).toMatch(/ts-sdk-.*/)
+    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)})
+    await broadcaster.broadcast(transaction)
+
+    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+
+    expect(headers['XDeployment-ID']).toBeDefined()
+    expect(headers['XDeployment-ID']).toMatch(/ts-sdk-.*/)
+    expect(headers['Authorization']).toEqual(`Bearer ${apiKey}`)
+  })
+
+  it('should handle api key as second argument', async () => {
+    const mockFetch = mockedFetch(successResponse)
+    global.window = {fetch: mockFetch} as any
+
+    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
+
+    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)})
+    await broadcaster.broadcast(transaction)
+
+    const {headers} = (mockFetch as jest.Mock).mock.calls[0][1] as HttpClientRequestOptions
+
+    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 any
 
+    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -94,15 +163,14 @@ describe('ARC Broadcaster', () => {
   })
 
   it('should handle non-200 responses', async () => {
-    const mockFetch = jest.fn().mockResolvedValue({
-      ok: false,
-      json: async () => await Promise.resolve({
-        status: '400',
+    const mockFetch = mockedFetch({
+      status: '400',
+      data: {
         detail: 'Bad request'
-      })
+      }
     })
-    global.window = { fetch: mockFetch } as any
 
+    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -112,4 +180,47 @@ describe('ARC Broadcaster', () => {
       description: 'Bad request'
     })
   })
+
+  function mockedFetch(response) {
+    return jest.fn().mockResolvedValue({
+      ok: response.status === 200,
+      status: response.status,
+      statusText: response.status === 200 ? 'OK' : 'Bad request',
+      headers: {
+        get(key: string) {
+          if (key === 'Content-Type') {
+            return 'application/json'
+          }
+        }
+      },
+      json: async () => response.data
+    });
+  }
+
+  function mockedHttps(response) {
+    const https = {
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: response.status,
+          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          headers: {
+            'content-type': 'application/json'
+          },
+          on: (event, handler) => {
+            if (event === 'data') handler(JSON.stringify(response.data))
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+    jest.mock('https', () => https)
+    return https
+  }
 })
+

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

@@ -0,0 +1,165 @@
+import Transaction from '../../../../dist/cjs/src/transaction/Transaction.js'
+import {NodejsHttpClient} from "../../../../dist/cjs/src/transaction/http/NodejsHttpClient.js";
+import WhatsOnChainBroadcaster from "../../../../dist/cjs/src/transaction/broadcasters/WhatsOnChainBroadcaster.js";
+import {FetchHttpClient} from "../../../../dist/cjs/src/transaction/http/FetchHttpClient.js";
+
+// Mock Transaction
+jest.mock('../../Transaction', () => {
+  return {
+    default: jest.fn().mockImplementation(() => {
+      return {
+        toHex: () => 'mocked_transaction_hex'
+      }
+    })
+  }
+})
+
+describe('WhatsOnChainBroadcaster', () => {
+  const network = 'main'
+  const successResponse = {
+    status: 200,
+    data: 'mocked_txid'
+  }
+
+  let transaction: Transaction
+
+  beforeEach(() => {
+    transaction = new Transaction()
+  })
+
+  it('should broadcast successfully using window.fetch', async () => {
+    // Mocking window.fetch
+    const mockFetch = mockedFetch(successResponse)
+    global.window = { fetch: mockFetch } as any
+
+    const broadcaster = new WhatsOnChainBroadcaster(network)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'broadcast successful'
+    })
+  })
+
+  it('should broadcast successfully using Node.js https', async () => {
+    // Mocking Node.js https module
+    mockedHttps(successResponse)
+    delete global.window
+
+    const broadcaster = new WhatsOnChainBroadcaster(network)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'broadcast successful'
+    })
+  })
+
+  it('should broadcast successfully using provided fetch', async () => {
+
+    const mockFetch = mockedFetch(successResponse)
+
+    const broadcaster = new WhatsOnChainBroadcaster(network, new FetchHttpClient(mockFetch))
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'broadcast successful'
+    })
+  })
+
+  it('should broadcast successfully using provided https', async () => {
+
+    const mockHttps = mockedHttps(successResponse)
+    const broadcaster = new WhatsOnChainBroadcaster(network, new NodejsHttpClient(mockHttps))
+
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'broadcast successful'
+    })
+  })
+
+  it('should handle network errors', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+    global.window = { fetch: mockFetch } as any
+
+    const broadcaster = new WhatsOnChainBroadcaster(network)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'error',
+      code: '500',
+      description: 'Network error'
+    })
+  })
+
+  it('should handle non-200 responses', async () => {
+    const mockFetch = mockedFetch({
+      status: 400,
+      data: 'Bad request'
+    })
+    global.window = { fetch: mockFetch } as any
+
+    const broadcaster = new WhatsOnChainBroadcaster(network)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'error',
+      code: '400',
+      description: 'Bad request'
+    })
+  })
+
+  function mockedFetch(response) {
+    return jest.fn().mockResolvedValue({
+      ok: response.status === 200,
+      status: response.status,
+      statusText: response.status === 200 ? 'OK' : 'Bad request',
+      headers: {
+        get(key: string) {
+          if (key === 'Content-Type') {
+            return 'text/plain'
+          }
+        }
+      },
+      text: async () => response.data
+    });
+  }
+
+  function mockedHttps(response) {
+    const https = {
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: response.status,
+          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          headers: {
+            'content-type': 'text/plain'
+          },
+          on: (event, handler) => {
+            if (event === 'data') handler(response.data)
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+    jest.mock('https', () => https)
+    return https
+  }
+})
+

package/src/transaction/broadcasters/index.ts

@@ -1 +1,4 @@
 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

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

package/src/transaction/chaintrackers/WhatsOnChain.ts

@@ -0,0 +1,70 @@
+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
+  /** The HTTP client used to make requests to the API. */
+  httpClient?: HttpClient
+}
+
+interface WhatsOnChainBlockHeader {
+  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
+
+  /**
+   * Constructs an instance of the WhatsOnChain ChainTracker.
+   *
+   * @param {'main' | 'test' | 'stn'} network - The BSV network to use when calling the WhatsOnChain API.
+   * @param {WhatsOnChainConfig} config - Configuration options for the WhatsOnChain ChainTracker.
+   */
+  constructor(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
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const requestOptions = {
+      method: 'GET',
+      headers: this.getHeaders()
+    }
+
+    const response = await this.httpClient.request<WhatsOnChainBlockHeader>(`${this.URL}/block/${height}/header`, requestOptions)
+    if (response.ok) {
+      const { merkleroot} = response.data
+      return merkleroot === root
+    } else if (response.status === 404) {
+      return false
+    } else {
+      throw new Error(`Failed to verify merkleroot for height ${height} because of an error: ${JSON.stringify(response.data)} `)
+    }
+  }
+
+  private getHeaders() {
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+    }
+
+    if (this.apiKey) {
+      headers['Authorization'] = this.apiKey
+    }
+
+    return headers
+  }
+}
+
+

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

@@ -0,0 +1,135 @@
+import {NodejsHttpClient} from "../../../../dist/cjs/src/transaction/http/NodejsHttpClient.js";
+import WhatsOnChain from "../../../../dist/cjs/src/transaction/chaintrackers/WhatsOnChain.js";
+import {FetchHttpClient} from "../../../../dist/cjs/src/transaction/http/FetchHttpClient.js";
+
+
+describe('WhatsOnChain ChainTracker', () => {
+  const network = 'main'
+  const height = 123456
+  const merkleroot = 'mocked_merkleroot'
+
+  const successResponse = {
+    status: 200,
+    data: {
+      merkleroot
+    }
+  }
+
+
+
+  it('should verify merkleroot successfully using window.fetch', async () => {
+    // Mocking window.fetch
+    const mockFetch = mockedFetch(successResponse)
+    global.window = { fetch: mockFetch } as any
+
+    const chainTracker = new WhatsOnChain(network)
+    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using Node.js https', async () => {
+    // Mocking Node.js https module
+    mockedHttps(successResponse)
+    delete global.window
+
+    const chainTracker = new WhatsOnChain(network)
+    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using provided window.fetch', async () => {
+    const mockFetch = mockedFetch(successResponse)
+
+    const chainTracker = new WhatsOnChain(network, {httpClient: new FetchHttpClient(mockFetch)})
+    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using provided Node.js https', async () => {
+    const mockHttps = mockedHttps(successResponse)
+
+    const chainTracker = new WhatsOnChain(network, {httpClient: new NodejsHttpClient(mockHttps)})
+    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+
+    expect(response).toEqual(true)
+  })
+
+  it('should respond with invalid root for height when block for height is not found', async () => {
+    const mockFetch = mockedFetch({
+      status: 404,
+      data: "not found"
+    })
+
+    const chainTracker = new WhatsOnChain(network, {httpClient: new FetchHttpClient(mockFetch)})
+    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+
+    expect(response).toEqual(false)
+  })
+
+  it('should handle network errors', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+
+    const chainTracker = new WhatsOnChain(network, {httpClient: new FetchHttpClient(mockFetch)})
+
+    await expect(chainTracker.isValidRootForHeight(merkleroot, height)).rejects.toThrow('Network error')
+  })
+
+  it('should throw error when received error response', async () => {
+    const mockFetch = mockedFetch({
+      status: 401,
+      data: { error: 'Unauthorized' }
+    })
+
+    const chainTracker = new WhatsOnChain(network, {httpClient: new FetchHttpClient(mockFetch)})
+
+    await expect(chainTracker.isValidRootForHeight(merkleroot, height)).rejects.toThrow(/Failed to verify merkleroot for height \d+ because of an error: .*/)
+  })
+
+  function mockedFetch(response) {
+    return jest.fn().mockResolvedValue({
+      ok: response.status === 200,
+      status: response.status,
+      statusText: response.status === 200 ? 'OK' : 'Bad request',
+      headers: {
+        get(key: string) {
+          if (key === 'Content-Type') {
+            return 'application/json'
+          }
+        }
+      },
+      json: async () => response.data
+    });
+  }
+
+  function mockedHttps(response) {
+    const https = {
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: response.status,
+          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          headers: {
+            'content-type': 'application/json'
+          },
+          on: (event, handler) => {
+            if (event === 'data') handler(JSON.stringify(response.data))
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+    jest.mock('https', () => https)
+    return https
+  }
+})
+

package/src/transaction/chaintrackers/index.ts

@@ -0,0 +1,3 @@
+export { default as WhatsOnChain } from './WhatsOnChain.js'
+export type { WhatsOnChainConfig } from './WhatsOnChain.js'
+export { defaultChainTracker } from './DefaultChainTracker.js'

package/src/transaction/http/DefaultHttpClient.ts

@@ -0,0 +1,32 @@
+import { HttpClient, HttpClientResponse } from './HttpClient.js';
+import { NodejsHttpClient } from './NodejsHttpClient.js';
+import { FetchHttpClient } from './FetchHttpClient.js';
+
+/**
+ * Returns a default HttpClient implementation based on the environment that it is run on.
+ * This method will attempt to use `window.fetch` if available (in browser environments).
+ * If running in a Node.js environment, it falls back to using the Node.js `https` module
+ */
+export function defaultHttpClient(): HttpClient {
+  const noHttpClient: HttpClient = {
+    request(..._): Promise<HttpClientResponse> {
+      throw new Error('No method available to perform HTTP request');
+    },
+  };
+
+  if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+    // Use fetch in a browser environment
+    return new FetchHttpClient(window.fetch);
+  } else if (typeof require !== 'undefined') {
+    // Use Node.js https module
+    // eslint-disable-next-line
+    try {
+      const https = require('https');
+      return new NodejsHttpClient(https);
+    } catch (e) {
+      return noHttpClient;
+    }
+  } else {
+    return noHttpClient;
+  }
+}