@bsv/sdk 1.0.32 → 1.0.34

package/src/script/Script.ts

@@ -21,7 +21,7 @@ export default class Script {
    * @example
    * const script = Script.fromASM("OP_DUP OP_HASH160 abcd... OP_EQUALVERIFY OP_CHECKSIG")
    */
-  static fromASM(asm: string): Script {
+  static fromASM (asm: string): Script {
     const chunks: ScriptChunk[] = []
     const tokens = asm.split(' ')
     let i = 0
@@ -100,7 +100,7 @@ export default class Script {
    * @example
    * const script = Script.fromHex("76a9...");
    */
-  static fromHex(hex: string): Script {
+  static fromHex (hex: string): Script {
     if (hex.length === 0) return Script.fromBinary([])
     if (hex.length % 2 !== 0) throw new Error('There is an uneven number of characters in the string which suggests it is not hex encoded.')
     if (!/^[0-9a-fA-F]+$/.test(hex)) throw new Error('Some elements in this string are not hex encoded.')
@@ -115,7 +115,7 @@ export default class Script {
    * @example
    * const script = Script.fromBinary([0x76, 0xa9, ...])
    */
-  static fromBinary(bin: number[]): Script {
+  static fromBinary (bin: number[]): Script {
     bin = [...bin]
     const chunks: ScriptChunk[] = []
 
@@ -179,7 +179,7 @@ export default class Script {
    * Constructs a new Script object.
    * @param chunks=[] - An array of script chunks to directly initialize the script.
    */
-  constructor(chunks: ScriptChunk[] = []) {
+  constructor (chunks: ScriptChunk[] = []) {
     this.chunks = chunks
   }
 
@@ -188,7 +188,7 @@ export default class Script {
    * Serializes the script to an ASM formatted string.
    * @returns The script in ASM string format.
    */
-  toASM(): string {
+  toASM (): string {
     let str = ''
     for (let i = 0; i < this.chunks.length; i++) {
       const chunk = this.chunks[i]
@@ -203,7 +203,7 @@ export default class Script {
    * Serializes the script to a hexadecimal string.
    * @returns The script in hexadecimal format.
    */
-  toHex(): string {
+  toHex (): string {
     return encode(this.toBinary(), 'hex') as string
   }
 
@@ -212,7 +212,7 @@ export default class Script {
    * Serializes the script to a binary array.
    * @returns The script in binary array format.
    */
-  toBinary(): number[] {
+  toBinary (): number[] {
     const writer = new Writer()
 
     for (let i = 0; i < this.chunks.length; i++) {
@@ -244,7 +244,7 @@ export default class Script {
    * @param script - The script to append.
    * @returns This script instance for chaining.
    */
-  writeScript(script: Script): Script {
+  writeScript (script: Script): Script {
     this.chunks = this.chunks.concat(script.chunks)
     return this
   }
@@ -255,7 +255,7 @@ export default class Script {
    * @param op - The opcode to append.
    * @returns This script instance for chaining.
    */
-  writeOpCode(op: number): Script {
+  writeOpCode (op: number): Script {
     this.chunks.push({ op })
     return this
   }
@@ -267,7 +267,7 @@ export default class Script {
    * @param op - The opcode to set.
    * @returns This script instance for chaining.
    */
-  setChunkOpCode(i: number, op: number): Script {
+  setChunkOpCode (i: number, op: number): Script {
     this.chunks[i] = { op }
     return this
   }
@@ -278,7 +278,7 @@ export default class Script {
   * @param bn - The BigNumber to append.
   * @returns This script instance for chaining.
    */
-  writeBn(bn: BigNumber): Script {
+  writeBn (bn: BigNumber): Script {
     if (bn.cmpn(0) === OP.OP_0) {
       this.chunks.push({
         op: OP.OP_0
@@ -306,7 +306,7 @@ export default class Script {
    * @returns This script instance for chaining.
    * @throws {Error} Throws an error if the data is too large to be pushed.
    */
-  writeBin(bin: number[]): Script {
+  writeBin (bin: number[]): Script {
     let op
     if (bin.length > 0 && bin.length < OP.OP_PUSHDATA1) {
       op = bin.length
@@ -334,7 +334,7 @@ export default class Script {
    * @param num - The number to append.
    * @returns This script instance for chaining.
    */
-  writeNumber(num: number): Script {
+  writeNumber (num: number): Script {
     this.writeBn(new BigNumber(num))
     return this
   }
@@ -344,7 +344,7 @@ export default class Script {
    * Removes all OP_CODESEPARATOR opcodes from the script.
    * @returns This script instance for chaining.
    */
-  removeCodeseparators(): Script {
+  removeCodeseparators (): Script {
     const chunks = []
     for (let i = 0; i < this.chunks.length; i++) {
       if (this.chunks[i].op !== OP.OP_CODESEPARATOR) {
@@ -362,7 +362,7 @@ export default class Script {
    *
    * @returns This script instance for chaining.
    */
-  findAndDelete(script: Script): Script {
+  findAndDelete (script: Script): Script {
     const buf = script.toHex()
     for (let i = 0; i < this.chunks.length; i++) {
       const script2 = new Script([this.chunks[i]])
@@ -379,7 +379,7 @@ export default class Script {
    * Checks if the script contains only push data operations.
    * @returns True if the script is push-only, otherwise false.
    */
-  isPushOnly(): boolean {
+  isPushOnly (): boolean {
     for (let i = 0; i < this.chunks.length; i++) {
       const chunk = this.chunks[i]
       const opCodeNum = chunk.op
@@ -395,7 +395,7 @@ export default class Script {
    * Determines if the script is a locking script.
    * @returns True if the script is a locking script, otherwise false.
    */
-  isLockingScript(): boolean {
+  isLockingScript (): boolean {
     throw new Error('Not implemented')
   }
 
@@ -404,7 +404,7 @@ export default class Script {
    * Determines if the script is an unlocking script.
    * @returns True if the script is an unlocking script, otherwise false.
    */
-  isUnlockingScript(): boolean {
+  isUnlockingScript (): boolean {
     throw new Error('Not implemented')
   }
 
@@ -415,7 +415,7 @@ export default class Script {
    * @param chunk - The script chunk.
    * @returns The string representation of the chunk.
    */
-  private _chunkToString(chunk: ScriptChunk): string {
+  private _chunkToString (chunk: ScriptChunk): string {
     const op = chunk.op
     let str = ''
     if (typeof chunk.data === 'undefined') {

package/src/transaction/MerklePath.ts

@@ -39,11 +39,11 @@ export default class MerklePath {
    * @param {string} hex - The hexadecimal string representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromHex(hex: string): MerklePath {
+  static fromHex (hex: string): MerklePath {
     return MerklePath.fromBinary(toArray(hex, 'hex'))
   }
 
-  static fromReader(reader: Reader): MerklePath {
+  static fromReader (reader: Reader): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
     const path = Array(treeHeight).fill(0).map(() => ([]))
@@ -82,12 +82,12 @@ export default class MerklePath {
    * @param {number[]} bump - The binary array representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromBinary(bump: number[]): MerklePath {
+  static fromBinary (bump: number[]): MerklePath {
     const reader = new Reader(bump)
     return MerklePath.fromReader(reader)
   }
 
-  constructor(blockHeight: number, path: Array<Array<{
+  constructor (blockHeight: number, path: Array<Array<{
     offset: number
     hash?: string
     txid?: boolean
@@ -135,7 +135,7 @@ export default class MerklePath {
    *
    * @returns {number[]} - The binary array representation of the Merkle Path.
    */
-  toBinary(): number[] {
+  toBinary (): number[] {
     const writer = new Writer()
     writer.writeVarIntNum(this.blockHeight)
     const treeHeight = this.path.length
@@ -166,7 +166,7 @@ export default class MerklePath {
    *
    * @returns {string} - The hexadecimal string representation of the Merkle Path.
    */
-  toHex(): string {
+  toHex (): string {
     return toHex(this.toBinary())
   }
 
@@ -177,7 +177,7 @@ export default class MerklePath {
    * @returns {string} - The computed Merkle root as a hexadecimal string.
    * @throws {Error} - If the transaction ID is not part of the Merkle Path.
    */
-  computeRoot(txid?: string): string {
+  computeRoot (txid?: string): string {
     if (typeof txid !== 'string') {
       txid = this.path[0].find(leaf => Boolean(leaf?.hash)).hash
     }
@@ -216,7 +216,7 @@ export default class MerklePath {
    * @param {ChainTracker} chainTracker - The ChainTracker instance used to verify the Merkle root.
    * @returns {boolean} - True if the transaction ID is valid within the Merkle Path at the specified block height.
    */
-  async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> {
+  async verify (txid: string, chainTracker: ChainTracker): Promise<boolean> {
     const root = this.computeRoot(txid)
     // Use the chain tracker to determine whether this is a valid merkle root at the given block height
     return await chainTracker.isValidRootForHeight(root, this.blockHeight)
@@ -228,7 +228,7 @@ export default class MerklePath {
    * @param {MerklePath} other - Another MerklePath to combine with this path.
    * @throws {Error} - If the paths have different block heights or roots.
    */
-  combine(other: MerklePath): void {
+  combine (other: MerklePath): void {
     if (this.blockHeight !== other.blockHeight) {
       throw new Error('You cannot combine paths which do not have the same block height.')
     }

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
@@ -125,25 +127,23 @@ export default class Transaction {
    * any application seeking to validate data in output scripts must store the entire transaction as well.
    * Since the transaction data includes the output script data, saving a second copy of potentially
    * large scripts can bloat application storage requirements.
-   * 
+   *
    * This function efficiently parses binary transaction data to determine the offsets and lengths of each script.
    * This supports the efficient retreival of script data from transaction data.
-   * 
+   *
    * @param bin binary transaction data
    * @returns {
    *   inputs: { vin: number, offset: number, length: number }[]
    *   outputs: { vout: number, offset: number, length: number }[]
    * }
    */
-  static parseScriptOffsets(bin: number[])
-  : {
-    inputs: { vin: number, offset: number, length: number }[]
-    outputs: { vout: number, offset: number, length: number }[]
-  }
-  {
+  static parseScriptOffsets (bin: number[]): {
+    inputs: Array<{ vin: number, offset: number, length: number }>
+    outputs: Array<{ vout: number, offset: number, length: number }>
+  } {
     const br = new Reader(bin)
-    const inputs: { vin: number, offset: number, length: number }[] = []
-    const outputs: { vout: number, offset: number, length: number }[] = []
+    const inputs: Array<{ vin: number, offset: number, length: number }> = []
+    const outputs: Array<{ vout: number, offset: number, length: number }> = []
 
     br.pos += 4 // version
     const inputsLength = br.readVarIntNum()
@@ -384,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)
   }
 
@@ -535,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,33 +1,69 @@
-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";
+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
+  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.
    */
-  constructor (URL: string, apiKey: string) {
+  constructor(URL: string, apiKey?: string)
+
+  constructor(URL: string, config?: string | ArcConfig) {
     this.URL = URL
-    this.apiKey = apiKey
+    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()
@@ -37,45 +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 {
-      let response
-      let data: any = {}
-
-      if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
-        // Use fetch in a browser environment
-        response = await window.fetch(`${this.URL}/v1/tx`, requestOptions)
-        data = await response.json()
-      } else if (typeof require !== 'undefined') {
-        // Use Node.js https module
-        // eslint-disable-next-line
-        const https = require('https')
-        response = await this.nodeFetch(https, requestOptions)
-        data = JSON.parse(response)
-      } else {
-        throw new Error('No method available to perform HTTP request')
-      }
-
-      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) {
@@ -89,27 +108,22 @@ export default class ARC implements Broadcaster {
     }
   }
 
-  /** Helper function for Node.js HTTPS requests */
-  private async nodeFetch (https, requestOptions): Promise<any> {
-    return await new Promise((resolve, reject) => {
-      const req = https.request(`${this.URL}/v1/tx`, requestOptions, res => {
-        let data = ''
-        res.on('data', (chunk: string) => {
-          data += chunk
-        })
-        res.on('end', () => {
-          resolve(data)
-        })
-      })
+  private requestHeaders() {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'XDeployment-ID': this.deploymentId,
+    }
 
-      req.on('error', error => {
-        reject(error)
-      })
+    if (this.apiKey) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`
+    }
 
-      if (requestOptions.body as boolean) {
-        req.write(requestOptions.body)
-      }
-      req.end()
-    })
+    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'
+      }
+    }
+  }
+}