@bsv/sdk 1.0.33 → 1.0.34

package/docs/examples/EXAMPLE_SIMPLE_TX.md

@@ -45,7 +45,7 @@ await tx.sign()
 // Finally, we broadcast it with ARC.
 // get your api key from https://console.taal.com
 const apiKey = 'mainnet_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' // replace
-await tx.broadcast(new ARC('https://api.taal.com/arc', apiKey))
+await tx.broadcast()
 ```
 
 This code snippet demonstrates creating a transaction, adding an input and an output, setting a change script, configuring the fee, signing the transaction, and broadcasting with the ARC broadcaster. It uses the P2PKH Template, which is a specific type of Bitcoin locking program. To learn more about templates, check out this example (link to be provided once cmpplete).
@@ -63,17 +63,36 @@ transaction.addOutput({
 
 The `Transaction` class abstracts the complexity of Bitcoin's transaction structure. It handles inputs, outputs, scripts, and serialization, offering methods to easily modify and interrogate the transaction. Check out the full code-level documentation, refer to other examples, or reach out to the community to learn more.
 
-## Configuring the ARC with http client
+## Choosing broadcasting target (ARC or WhatsOnChain)
+
+### ARC
+
+You can broadcast via selected ARC by providing ARC instance to the `broadcast` method.
+
+```typescript
+await tx.broadcast(new ARC('https://api.taal.com/arc', apiKey))
+```
+
+### WhatsOnChain
+
+You can broadcast via What's On Chain by providing WhatsOnChainBroadcaster instance to the `broadcast` method.
+
+```typescript
+const network = 'main' // or 'test'
+await tx.broadcast(new WhatsOnChainBroadcaster(network))
+```
+
+## Use custom http client for broadcasting
 
 The ARC broadcaster requires an HTTP client to broadcast transactions. By default, the SDK will try to search for `window.fetch` in browser or `https` module on Node.js. 
-If you want to use a custom (or preconfigured) HTTP client, you can pass it as an argument to the ARC constructor:
+If you want to use a custom (or preconfigured) HTTP client, you can pass it with use of the adapter the ARC constructor:
 
 ### fetch
 
 ```typescript
 // In this example we're assuming you have variable fetch holding the fetch function`
 
-const arc = new ARC('https://api.taal.com/arc', apiKey, {fetch})
+const arc = new ARC('https://api.taal.com/arc', apiKey, new FetchHttpClient(mockFetch))
 ```
 
 ### https
@@ -94,7 +113,27 @@ Although the SDK is not providing adapters for axios, it can be easily used with
 You can make your own "adapter" for axios as follows:
 
 ```typescript
-const axiosHttpClient = { fetch: (url, options) => axios(url, {...options, data: options.body})}
+const axiosHttpClient =   const httpClient: HttpClient = {
+  request: async (...args) => {
+    let res;
+    try {
+      res = await axios(...args);
+    } catch (e: unknown) {
+      if (axios.isAxiosError(e)) {
+        res = e.response;
+      } else {
+        throw e;
+      }
+    }
+    if (!res) {
+      throw new Error('No response');
+    }
+    return {
+      ok: res.status >= 200 && res.status <= 299,
+      ...res
+    };
+  },
+};
 
 new ARC('https://api.taal.com/arc', apiKey, axiosHttpClient) 
 ```

package/docs/examples/EXAMPLE_VERIFYING_BEEF.md

@@ -12,26 +12,6 @@ Merkle proofs are simply a way for someone to prove the existence of a given tra
 
 The process for SPV is detailed in [BRC-67](https://github.com/bitcoin-sv/BRCs/blob/master/transactions/0067.md), but the main idea is that when a sender sends a transaction, they include merkle proofs on all of the input transactions. This allows anyone with a copy of the Bitcoin block headers to check that the input transactions are included in the blockchain. Verifiers then check that all the input and output scripts correctly transfer value from one party to the next, ensuring an unbroken chain of spends. The [BEEF data structure](https://github.com/bitcoin-sv/BRCs/blob/master/transactions/0062.md) provides a compact and efficient way for people to represent the data required to perform SPV. 
 
-## Block Headers Client
-
-To verify BEEF structures with the BSV SDK, you'll need to provide a block headers client that, given a merkle root, will indicate to the library whether the merkle root is correct for the block that's in the active chain at the given block height.
-
-For simplicity in this example, we are going to use a mock headers client that always indicates every merkle root as valid no matter what. However, in any real project, **you MUST always use an actual block headers client or attackers will be able to easily fool you with fraudulent transactions!**
-
-The TypeScript BSV SDK does not ship with a block headers client, but check out this example (link to be provided once complete) for setting up Pulse.
-
-Here is the gullible block headers client we will be using:
-
-```typescript
-const gullibleHeadersClient = {
-    // DO NOT USE IN A REAL PROJECT due to security risks of accepting any merkle root as valid without verification
-    isValidRootForHeight: async (merkleRoot, height) => {
-      console.log({ merkleRoot, height })
-      return true
-    }
-}
-```
-
 ## Verifying a BEEF Structure
 
 Now that you have access to a block headers client (either Pulse on a real project or the above code for a toy example), we can proceed to verifying the BEEF structure with the following code:
@@ -46,10 +26,37 @@ const BEEFHex = '0100beef01fe636d0c0007021400fe507c0c7aa754cef1f7889d5fd395cf1f7
 const tx = Transaction.fromHexBEEF(BEEFHex)
 
 // This ensures the BEEF structure is legitimate
-const verified = await tx.verify(gullibleHeadersClient)
+const verified = await tx.verify()
 
 // Print the results
 console.log(verified)
 ```
 
-The above code allows you to ensure that a given BEEF structure is valid according to the rules of SPV.
+The above code allows you to ensure that a given BEEF structure is valid according to the rules of SPV.
+
+## Chain tracker
+
+To verify BEEF structures with the BSV SDK, you'll need to provide a block headers client that, given a merkle root, will indicate to the library whether the merkle root is correct for the block that's in the active chain at the given block height.
+
+The TypeScript BSV SDK does provides default implementation of the chain tracker that use What's On Chain API. 
+
+### What's On Chain configuration
+
+#### BSV network
+
+The default network for the chain tracker is `main`. You can change it to other network by providing the instance of WhatsOnChain ChainTracker configured for other network to `.verify()` method.
+
+```typescript
+tx.verify(new WhatsOnChain())
+```
+
+#### Api Key
+
+It is possible to use WhatsOnChain ChainTracker with obtained API KEY of [WhatsOnChain](https://docs.taal.com/core-products/whatsonchain). 
+To do so, you need to provide to `.verify()` method the custom instance of WhatsOnChain ChainTracker with the API KEY.
+
+```typescript
+import { Transaction, WhatsOnChain } from '@bsv/sdk'
+
+tx.verify(new WhatsOnChain('main', {apiKey: 'YOUR_API_KEY'}))
+```

package/docs/examples/EXAMPLE_VERIFYING_ROOTS.md

@@ -1,6 +1,6 @@
 # Example: Building a Pulse Block Headers Client
 
-When [verifying BEEF structures](EXAMPLE_VERIFYING_BEEF.md), it's necessary to ensure that all transactions are well-anchored: this is to say, that they come from inputs in the honest chain. The SDK doesn't ship with a headers client, but this guide shows an example of how to use it with [Pulse](https://github.com/bitcoin-sv/block-headers-service): a popular client suitable for a wide range of use-cases.
+When [verifying BEEF structures](EXAMPLE_VERIFYING_BEEF.md), it's necessary to ensure that all transactions are well-anchored: this is to say, that they come from inputs in the honest chain. The SDK doesn't ship with a headers client, but this guide shows an example of how to use it with [block-headers-service](https://github.com/bitcoin-sv/block-headers-service): a popular client suitable for a wide range of use-cases.
 
 ## Pre-requisites
 
@@ -41,59 +41,13 @@ export default interface ChainTracker {
 
 ```
 
-We will hide the complexities of making an https request from browsers/node.js in an separate function, which you could then import into the files you need otherwise.
-
-```typescript
-// httpsClient.ts
-async function nodeFetch (https, url, requestOptions): Promise<any> {
-    return await new Promise((resolve, reject) => {
-      const req = https.request(url, requestOptions, res => {
-        let data = ''
-        res.on('data', (chunk: string) => {
-          data += chunk
-        })
-        res.on('end', () => {
-          resolve(data)
-        })
-      })
-
-      req.on('error', error => {
-        reject(error)
-      })
-
-      if (requestOptions.body as boolean) {
-        req.write(requestOptions.body)
-      }
-      req.end()
-    })
-  }
-}
-
-export async function httpsClient (url: string, options: any) : Promise<any> {
-  let response
-  let data: any = {}
-  if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
-    // Use fetch in a browser environment
-    response = await window.fetch(url, options)
-    data = await response.json()
-    return data
-  }
-  if (typeof require === 'undefined') throw new Error('No method available to perform HTTP request')
-  // Use Node.js https module
-  // eslint-disable-next-line
-  const https = require('https')
-  response = await nodeFetch(https, url, requestOptions)
-  data = JSON.parse(response)
-  return data
-}
-```
-
-
 Given an array of merkle roots and corresponding block heights, we return a boolean indicating whether they're all valid.
 
 We can plug in the Block Header Service API with appropriate HTTP handling logic as follows:
 
 ```typescript
+import {defaultHttpClient} from "@bsv/sdk";
+
 /**
  * Represents a Block Headers Client.
  */
@@ -107,9 +61,10 @@ export default class BlockHeadersClient implements ChainTracker {
    * @param {string} URL - The URL endpoint for the Pulse API.
    * @param {string} apiKey - The API key used for authorization with the Pulse API.
    */
-  constructor (URL: string, apiKey: string) {
+  constructor(URL: string, apiKey: string) {
     this.URL = URL
     this.apiKey = apiKey
+    this.httpClient = defaultHttpClient()
   }
 
   /**
@@ -119,19 +74,19 @@ export default class BlockHeadersClient implements ChainTracker {
    * @param height: number - The corresponding height
    * @returns {Promise<boolean>} A promise that resolves to either a success or failure response (true or false).
    */
-  async isValidRootForHeight (root: string, height: number): Promise<boolean> {
-    try {
-      const data = await httpsClient(`${this.URL}/api/v1/chain/merkleroot/verify`, {
-        method: 'POST',
-        body: JSON.stringify([{ merkleRoot: root, blockHeight: height }]),
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      })
-      return data?.confirmationState === 'CONFIRMED'
-    } catch (error) {
-      return false
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const response = await httpsClient(`${this.URL}/api/v1/chain/merkleroot/verify`, {
+      method: 'POST',
+      body: [{merkleRoot: root, blockHeight: height}],
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`
+      }
+    })
+    if (response.ok) {
+      return response.data?.confirmationState === 'CONFIRMED'
+    } else {
+      throw new Error(`Failed to verify root at height ${height} with response ${response.status}`)
     }
   }
 }

package/docs/examples/GETTING_STARTED_NODE_CJS.md

@@ -53,9 +53,7 @@ const tx = new Transaction(version, [input], [output])
 await tx.fee()
 await tx.sign()
 
-// get your api key from https://console.taal.com
-const apiKey = 'mainnet_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' // replace
-await tx.broadcast(new ARC('https://api.taal.com/arc', apiKey))
+await tx.broadcast()
 ```
 
 This script demonstrates the entire process of creating a transaction, from initializing keys to signing and broadcast. When you run this script using Node.js (replacing the source transaction, private key, and ARC credentials), the spend will be signed and broadcast to the BSV network.
@@ -70,4 +68,4 @@ node index.js
 
 ## Conclusion
 
-Congratulations! You've successfully installed the BSV SDK in your NodeJS project and created a signed transaction. This guide covered the basics to get you started, but the BSV SDK is capable of much more. Explore the SDK documentation for detailed information on all the features and functionalities available to build scalable applications with the BSV blockchain.
+Congratulations! You've successfully installed the BSV SDK in your NodeJS project and created a signed transaction. This guide covered the basics to get you started, but the BSV SDK is capable of much more. Explore the SDK documentation for detailed information on all the features and functionalities available to build scalable applications with the BSV blockchain.

package/docs/examples/GETTING_STARTED_REACT.md

@@ -60,9 +60,7 @@ const BsvButton: React.FC = () => {
     await tx.fee()
     await tx.sign()
 
-    // grab your api key from https://console.taal.com
-    const apiKey = 'mainnet_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' // replace
-    await tx.broadcast(new ARC('https://api.taal.com/arc', apiKey))
+    await tx.broadcast()
   }
 
   return (
@@ -118,4 +116,4 @@ Now when you click the button, a transaction will be created, signed, and broadc
 Conclusion
 ----------
 
-Congratulations! You've successfully integrated the BSV SDK into your TypeScript & React application and created a button which broadcasts a bitcoin transaction on click. This guide covered the basic steps needed to get you started, but the BSV SDK can do a lot more. Explore the SDK documentation to dive deep into all the features and functionalities available to build scalable applications on the BSV blockchain.
+Congratulations! You've successfully integrated the BSV SDK into your TypeScript & React application and created a button which broadcasts a bitcoin transaction on click. This guide covered the basic steps needed to get you started, but the BSV SDK can do a lot more. Explore the SDK documentation to dive deep into all the features and functionalities available to build scalable applications on the BSV blockchain.

package/mod.ts

@@ -4,5 +4,6 @@ export * from "./src/script/templates/index.js"
 export * from "./src/transaction/index.js"
 export * from "./src/transaction/fee-models/index.js"
 export * from "./src/transaction/broadcasters/index.js"
+export * from "./src/transaction/http/index.js"
 export * from "./src/messages/index.js"
-export * from "./src/compat/index.js"
+export * from "./src/compat/index.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",
@@ -74,6 +74,26 @@
       "require": "./dist/cjs/src/transaction/broadcaster/*.js",
       "types": "./dist/types/src/transaction/broadcaster/*.d.ts"
     },
+    "./transaction/chaintrackers": {
+      "import": "./dist/esm/src/transaction/chaintrackers/index.js",
+      "require": "./dist/cjs/src/transaction/chaintrackers/index.js",
+      "types": "./dist/types/src/transaction/chaintrackers/index.d.ts"
+    },
+    "./transaction/chaintrackers/*": {
+      "import": "./dist/esm/src/transaction/chaintrackers/*.js",
+      "require": "./dist/cjs/src/transaction/chaintrackers/*.js",
+      "types": "./dist/types/src/transaction/chaintrackers/*.d.ts"
+    },
+    "./transaction/http": {
+      "import": "./dist/esm/src/transaction/http/index.js",
+      "require": "./dist/cjs/src/transaction/http/index.js",
+      "types": "./dist/types/src/transaction/http/index.d.ts"
+    },
+    "./transaction/http/*": {
+      "import": "./dist/esm/src/transaction/http/*.js",
+      "require": "./dist/cjs/src/transaction/http/*.js",
+      "types": "./dist/types/src/transaction/http/*.d.ts"
+    },
     "./transaction/fee-model": {
       "import": "./dist/esm/src/transaction/fee-model/index.js",
       "require": "./dist/cjs/src/transaction/fee-model/index.js",

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')
+}