@bsv/sdk 1.0.33 → 1.0.34

package/src/transaction/broadcasters/WhatsOnChainBroadcaster.ts

@@ -0,0 +1,70 @@
+import {BroadcastResponse, BroadcastFailure, Broadcaster} from '../Broadcaster.js'
+import Transaction from '../Transaction.js'
+import {HttpClient} from "../http/HttpClient.js";
+import {defaultHttpClient} from "../http/DefaultHttpClient.js";
+
+/**
+ * Represents an WhatsOnChain transaction broadcaster.
+ */
+export default class WhatsOnChainBroadcaster implements Broadcaster {
+  readonly network: string
+  private readonly URL: string
+  private readonly httpClient: HttpClient;
+
+  /**
+   * Constructs an instance of the WhatsOnChain 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()) {
+    this.network = network
+    this.URL = `https://api.whatsonchain.com/v1/bsv/${network}/tx/raw`
+    this.httpClient = httpClient
+  }
+
+  /**
+   * Broadcasts a transaction via WhatsOnChain.
+   *
+   * @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> {
+    let rawTx = tx.toHex()
+
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/plain'
+      },
+      data: {txhex: rawTx}
+    }
+
+    try {
+      const response = await this.httpClient.request<string>(this.URL, requestOptions)
+      if (response.ok) {
+        const txid = response.data
+        return {
+          status: 'success',
+          txid: txid,
+          message: 'broadcast successful'
+        }
+      } else {
+        return {
+          status: 'error',
+          code: response.status.toString() ?? 'ERR_UNKNOWN',
+          description: response.data ?? 'Unknown error'
+        }
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        code: '500',
+        description: typeof error.message === 'string'
+          ? error.message
+          : 'Internal Server Error'
+      }
+    }
+  }
+}

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

@@ -1,6 +1,8 @@
 import ARC from '../../../../dist/cjs/src/transaction/broadcasters/ARC.js'
 import Transaction from '../../../../dist/cjs/src/transaction/Transaction.js'
-import {NodejsHttpClient} from "../NodejsHttpClient";
+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', () => {
@@ -15,11 +17,13 @@ jest.mock('../../Transaction', () => {
 
 describe('ARC Broadcaster', () => {
   const URL = 'https://example.com'
-  const apiKey = 'test_api_key'
   const successResponse = {
-    txid: 'mocked_txid',
-    txStatus: 'success',
-    extraInfo: 'received'
+    status: 200,
+    data: {
+      txid: 'mocked_txid',
+      txStatus: 'success',
+      extraInfo: 'received'
+    }
   }
 
   let transaction: Transaction
@@ -31,9 +35,9 @@ 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 any
 
-    const broadcaster = new ARC(URL, apiKey)
+    const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -49,7 +53,7 @@ describe('ARC Broadcaster', () => {
     mockedHttps(successResponse)
     delete global.window
 
-    const broadcaster = new ARC(URL, apiKey)
+    const broadcaster = new ARC(URL)
     const response = await broadcaster.broadcast(transaction)
 
     expect(response).toEqual({
@@ -63,7 +67,7 @@ describe('ARC Broadcaster', () => {
 
     const mockFetch = mockedFetch(successResponse)
 
-    const broadcaster = new ARC(URL, apiKey, { fetch: mockFetch })
+    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -77,7 +81,7 @@ describe('ARC Broadcaster', () => {
   it('should broadcast successfully using provided https', async () => {
 
     const mockHttps = mockedHttps(successResponse)
-    const broadcaster = new ARC(URL, apiKey, new NodejsHttpClient(mockHttps))
+    const broadcaster = new ARC(URL, {httpClient: new NodejsHttpClient(mockHttps)})
 
     const response = await broadcaster.broadcast(transaction)
 
@@ -88,11 +92,66 @@ 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)})
+    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, apiKey)
+    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -106,11 +165,12 @@ describe('ARC Broadcaster', () => {
   it('should handle non-200 responses', async () => {
     const mockFetch = mockedFetch({
       status: '400',
-      detail: 'Bad request'
+      data: {
+        detail: 'Bad request'
+      }
     })
-    global.window = { fetch: mockFetch } as any
 
-    const broadcaster = new ARC(URL, apiKey)
+    const broadcaster = new ARC(URL, {httpClient: new FetchHttpClient(mockFetch)})
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -123,8 +183,17 @@ describe('ARC Broadcaster', () => {
 
   function mockedFetch(response) {
     return jest.fn().mockResolvedValue({
-      ok: response.status === '200',
-      json: async () => response
+      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
     });
   }
 
@@ -133,9 +202,13 @@ describe('ARC Broadcaster', () => {
       request: (url, options, callback) => {
         // eslint-disable-next-line
         callback({
-          statusCode: 200,
+          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))
+            if (event === 'data') handler(JSON.stringify(response.data))
             if (event === 'end') handler()
           }
         })

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,5 +1,4 @@
 export { default as ARC } from './ARC.js'
-export type { HttpClient, HttpClientResponse, HttpClientRequestOptions } from './HttpClient.js'
-export { default as defaultHttpClient } from './DefaultHttpClient.js'
-export { NodejsHttpClient } from './NodejsHttpClient.js'
-export type { HttpsNodejs, NodejsHttpClientRequest } from './NodejsHttpClient.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;
+  }
+}