@bsv/sdk 1.0.33 → 1.0.36

package/src/transaction/Transaction.ts

@@ -10,6 +10,8 @@ import { Broadcaster, BroadcastResponse, BroadcastFailure } from './Broadcaster.
 import MerklePath from './MerklePath.js'
 import Spend from '../script/Spend.js'
 import ChainTracker from './ChainTracker.js'
+import { defaultBroadcaster } from './broadcasters/DefaultBroadcaster.js'
+import { defaultChainTracker } from './chaintrackers/DefaultChainTracker.js'
 
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
@@ -382,7 +384,7 @@ export default class Transaction {
    * @param broadcaster The Broadcaster instance wwhere the transaction will be sent
    * @returns A BroadcastResponse or BroadcastFailure from the Broadcaster
    */
-  async broadcast (broadcaster: Broadcaster): Promise<BroadcastResponse | BroadcastFailure> {
+  async broadcast (broadcaster: Broadcaster = defaultBroadcaster()): Promise<BroadcastResponse | BroadcastFailure> {
     return await broadcaster.broadcast(this)
   }
 
@@ -533,11 +535,11 @@ export default class Transaction {
   /**
    * Verifies the legitimacy of the Bitcoin transaction according to the rules of SPV by ensuring all the input transactions link back to valid block headers, the chain of spends for all inputs are valid, and the sum of inputs is not less than the sum of outputs.
    *
-   * @param chainTracker - An instance of ChainTracker, a Bitcoin block header tracker. If the value is set to 'scripts only', headers will not be verified.
+   * @param chainTracker - An instance of ChainTracker, a Bitcoin block header tracker. If the value is set to 'scripts only', headers will not be verified. If not provided then the default chain tracker will be used.
    *
    * @returns Whether the transaction is valid according to the rules of SPV.
    */
-  async verify (chainTracker: ChainTracker | 'scripts only'): Promise<boolean> {
+  async verify (chainTracker: ChainTracker | 'scripts only' = defaultChainTracker()): Promise<boolean> {
     // If the transaction has a valid merkle path, verification is complete.
     if (typeof this.merklePath === 'object' && chainTracker !== 'scripts only') {
       const proofValid = await this.merklePath.verify(

package/src/transaction/__tests/Transaction.test.ts

@@ -16,6 +16,7 @@ import validTransactions from './tx.valid.vectors'
 import bigTX from './bigtx.vectors'
 
 const BRC62Hex = '0100beef01fe636d0c0007021400fe507c0c7aa754cef1f7889d5fd395cf1f785dd7de98eed895dbedfe4e5bc70d1502ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e010b00bc4ff395efd11719b277694cface5aa50d085a0bb81f613f70313acd28cf4557010400574b2d9142b8d28b61d88e3b2c3f44d858411356b49a28a4643b6d1a6a092a5201030051a05fc84d531b5d250c23f4f886f6812f9fe3f402d61607f977b4ecd2701c19010000fd781529d58fc2523cf396a7f25440b409857e7e221766c57214b1d38c7b481f01010062f542f45ea3660f86c013ced80534cb5fd4c19d66c56e7e8c5d4bf2d40acc5e010100b121e91836fd7cd5102b654e9f72f3cf6fdbfd0b161c53a9c54b12c841126331020100000001cd4e4cac3c7b56920d1e7655e7e260d31f29d9a388d04910f1bbd72304a79029010000006b483045022100e75279a205a547c445719420aa3138bf14743e3f42618e5f86a19bde14bb95f7022064777d34776b05d816daf1699493fcdf2ef5a5ab1ad710d9c97bfb5b8f7cef3641210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000001000100000001ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000000'
+const MerkleRootFromBEEF = 'bb6f640cc4ee56bf38eb5a1969ac0c16caa2d3d202b22bf3735d10eec0ca6e00'
 
 describe('Transaction', () => {
   const txIn = {
@@ -354,6 +355,40 @@ describe('Transaction', () => {
   })
 
   describe('Broadcast', () => {
+    it('Broadcasts with the default Broadcaster instance', async () => {
+      const mockedFetch =  jest.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {
+          get(key: string) {
+            if (key === 'Content-Type') {
+              return 'application/json'
+            }
+          }
+        },
+        json: async () => ({
+          txid: 'mocked_txid',
+            txStatus: 'success',
+            extraInfo: 'received'
+        })
+      });
+
+      (global as any).window = {fetch: mockedFetch} as any
+
+      const tx = new Transaction()
+      const rv = await tx.broadcast()
+
+      expect(mockedFetch).toHaveBeenCalled()
+      const url = (mockedFetch as jest.Mock).mock.calls[0][0] as string
+      expect(url).toEqual('https://arc.taal.com/v1/tx')
+      expect(rv).toEqual({
+        status: 'success',
+        txid: 'mocked_txid',
+        message: 'success received'
+      })
+    })
+
     it('Broadcasts with the provided Broadcaster instance', async () => {
       const mockBroadcast = jest.fn(() => 'MOCK_RV')
       const tx = new Transaction()
@@ -391,6 +426,33 @@ describe('Transaction', () => {
       const verified = await tx.verify(alwaysYesChainTracker)
       expect(verified).toBe(true)
     })
+
+    it('Verifies the transaction from the BEEF spec with a default chain tracker', async () => {
+      const mockFetch =  jest.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {
+          get(key: string) {
+            if (key === 'Content-Type') {
+              return 'application/json'
+            }
+          }
+        },
+        json: async () => ({
+          merkleroot: MerkleRootFromBEEF,
+        })
+      });
+      (global as any).window = {fetch: mockFetch}
+
+
+      const tx = Transaction.fromHexBEEF(BRC62Hex)
+
+      const verified = await tx.verify()
+
+      expect(mockFetch).toHaveBeenCalled()
+      expect(verified).toBe(true)
+    })
   })
 
   describe('vectors: a 1mb transaction', () => {

package/src/transaction/broadcasters/ARC.ts

@@ -1,38 +1,69 @@
-import { BroadcastResponse, BroadcastFailure, Broadcaster } from '../Broadcaster.js'
+import {BroadcastResponse, BroadcastFailure, Broadcaster} from '../Broadcaster.js'
 import Transaction from '../Transaction.js'
-import {HttpClient} from "./HttpClient.js";
-import defaultHttpClient from "./DefaultHttpClient.js";
+import {HttpClient, HttpClientRequestOptions} from "../http/HttpClient.js";
+import {defaultHttpClient} from "../http/DefaultHttpClient.js";
+import Random from "../../primitives/Random.js";
+import {toHex} from "../../primitives/utils.js";
+
+/** Configuration options for the ARC broadcaster. */
+export interface ArcConfig {
+  /** Authentication token for the ARC API */
+  apiKey?: string
+  /** Deployment id used annotating api calls in XDeployment-ID header - this value will be randomly generated if not set */
+  deploymentId?: string
+  /** The HTTP client used to make requests to the ARC API. */
+  httpClient?: HttpClient
+}
+
+
+function defaultDeploymentId() {
+  return `ts-sdk-${toHex(Random(16))}`;
+}
 
 /**
  * Represents an ARC transaction broadcaster.
  */
 export default class ARC implements Broadcaster {
-  URL: string
-  apiKey: string
-  private httpClient: HttpClient;
+  readonly URL: string
+  readonly apiKey: string | undefined
+  readonly deploymentId: string
+  private readonly httpClient: HttpClient;
 
+  /**
+   * Constructs an instance of the ARC broadcaster.
+   *
+   * @param {string} URL - The URL endpoint for the ARC API.
+   * @param {ArcConfig} config - Configuration options for the ARC broadcaster.
+   */
+  constructor(URL: string, config?: ArcConfig)
   /**
    * Constructs an instance of the ARC broadcaster.
    *
    * @param {string} URL - The URL endpoint for the ARC API.
    * @param {string} apiKey - The API key used for authorization with the ARC API.
-   * @param {HttpClient} httpClient - The HTTP client used to make requests to the ARC API.
    */
-  constructor (URL: string, apiKey: string, httpClient: HttpClient = defaultHttpClient()) {
+  constructor(URL: string, apiKey?: string)
+
+  constructor(URL: string, config?: string | ArcConfig) {
     this.URL = URL
-    this.apiKey = apiKey
-    this.httpClient = httpClient
+    if (typeof config === 'string') {
+      this.apiKey = config
+      this.httpClient = defaultHttpClient()
+    } else {
+      const {apiKey, deploymentId, httpClient} = config ?? {} as ArcConfig
+      this.httpClient = httpClient ?? defaultHttpClient()
+      this.deploymentId = deploymentId ?? defaultDeploymentId()
+      this.apiKey = apiKey
+    }
   }
 
   /**
    * Broadcasts a transaction via ARC.
-   * 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.
    *
    * @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()
@@ -42,30 +73,28 @@ export default class ARC implements Broadcaster {
       } else {
         throw error
       }
-    } 
-    const requestOptions = {
+    }
+
+    const requestOptions: HttpClientRequestOptions = {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({ rawTx })
+      headers: this.requestHeaders(),
+      data: {rawTx}
     }
 
     try {
-      const response = await this.httpClient.fetch(`${this.URL}/v1/tx`, requestOptions)
-      const data = await response.json()
-      if (data.txid as boolean || response.ok as boolean || response.statusCode === 200) {
+      const response = await this.httpClient.request<ArcResponse>(`${this.URL}/v1/tx`, requestOptions)
+      if (response.ok) {
+        const {txid, extraInfo, txStatus} = response.data
         return {
           status: 'success',
-          txid: data.txid,
-          message: data?.txStatus + ' ' + data?.extraInfo
+          txid: txid,
+          message: `${txStatus} ${extraInfo}`
         }
       } else {
         return {
           status: 'error',
-          code: data.status as boolean ? data.status : 'ERR_UNKNOWN',
-          description: data.detail as boolean ? data.detail : 'Unknown error'
+          code: response.status.toString() ?? 'ERR_UNKNOWN',
+          description: response.data?.detail ?? 'Unknown error'
         }
       }
     } catch (error) {
@@ -78,4 +107,23 @@ export default class ARC implements Broadcaster {
       }
     }
   }
+
+  private requestHeaders() {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'XDeployment-ID': this.deploymentId,
+    }
+
+    if (this.apiKey) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`
+    }
+
+    return headers
+  }
+}
+
+interface ArcResponse {
+  txid: string
+  extraInfo: string
+  txStatus: string
 }

package/src/transaction/broadcasters/DefaultBroadcaster.ts

@@ -0,0 +1,6 @@
+import {Broadcaster} from "../Broadcaster.js";
+import ARC from "./ARC.js";
+
+export function defaultBroadcaster(): Broadcaster {
+  return new ARC('https://arc.taal.com')
+}

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()
           }
         })