@bsv/sdk 1.3.12 → 1.3.13

package/src/transaction/broadcasters/ARC.ts

@@ -1,41 +1,45 @@
-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'
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster,
+} from "../Broadcaster";
+import Transaction from "../Transaction";
+import { HttpClient, HttpClientRequestOptions } from "../http/HttpClient";
+import { defaultHttpClient } from "../http/DefaultHttpClient";
+import Random from "../../primitives/Random";
+import { toHex } from "../../primitives/utils";
 
 /** Configuration options for the ARC broadcaster. */
 export interface ArcConfig {
   /** Authentication token for the ARC API */
-  apiKey?: string
+  apiKey?: string;
   /** The HTTP client used to make requests to the ARC API. */
-  httpClient?: HttpClient
+  httpClient?: HttpClient;
   /** Deployment id used annotating api calls in XDeployment-ID header - this value will be randomly generated if not set */
-  deploymentId?: string
+  deploymentId?: string;
   /** notification callback endpoint for proofs and double spend notification */
-  callbackUrl?: string
+  callbackUrl?: string;
   /** default access token for notification callback endpoint. It will be used as a Authorization header for the http callback */
-  callbackToken?: string
+  callbackToken?: string;
   /** additional headers to be attached to all tx submissions. */
-  headers?: Record<string, string>
+  headers?: Record<string, string>;
 }
 
 function defaultDeploymentId() {
-  return `ts-sdk-${toHex(Random(16))}`
+  return `ts-sdk-${toHex(Random(16))}`;
 }
 
 /**
  * Represents an ARC transaction broadcaster.
  */
 export default class ARC implements Broadcaster {
-  readonly URL: string
-  readonly apiKey: string | undefined
-  readonly deploymentId: string
-  readonly callbackUrl: string | undefined
-  readonly callbackToken: string | undefined
-  readonly headers: Record<string, string> | undefined
-  private readonly httpClient: HttpClient
+  readonly URL: string;
+  readonly apiKey: string | undefined;
+  readonly deploymentId: string;
+  readonly callbackUrl: string | undefined;
+  readonly callbackToken: string | undefined;
+  readonly headers: Record<string, string> | undefined;
+  private readonly httpClient: HttpClient;
 
   /**
    * Constructs an instance of the ARC broadcaster.
@@ -43,31 +47,38 @@ export default class ARC implements 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)
+  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
-    if (typeof config === 'string') {
-      this.apiKey = config
-      this.httpClient = defaultHttpClient()
-      this.deploymentId = defaultDeploymentId()
-      this.callbackToken = undefined
-      this.callbackUrl = undefined
+    this.URL = URL;
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.httpClient = defaultHttpClient();
+      this.deploymentId = defaultDeploymentId();
+      this.callbackToken = undefined;
+      this.callbackUrl = undefined;
     } else {
-      const { apiKey, deploymentId, httpClient, callbackToken, callbackUrl, headers } = config ?? {} as ArcConfig
-      this.apiKey = apiKey
-      this.httpClient = httpClient ?? defaultHttpClient()
-      this.deploymentId = deploymentId ?? defaultDeploymentId()
-      this.callbackToken = callbackToken
-      this.callbackUrl = callbackUrl
-      this.headers = headers
+      const {
+        apiKey,
+        deploymentId,
+        httpClient,
+        callbackToken,
+        callbackUrl,
+        headers,
+      } = config ?? ({} as ArcConfig);
+      this.apiKey = apiKey;
+      this.httpClient = httpClient ?? defaultHttpClient();
+      this.deploymentId = deploymentId ?? defaultDeploymentId();
+      this.callbackToken = callbackToken;
+      this.callbackUrl = callbackUrl;
+      this.headers = headers;
     }
   }
 
@@ -76,29 +87,29 @@ export default class ARC implements Broadcaster {
    */
   private requestHeaders() {
     const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'XDeployment-ID': this.deploymentId
-    }
+      "Content-Type": "application/json",
+      "XDeployment-ID": this.deploymentId,
+    };
 
     if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`
+      headers.Authorization = `Bearer ${this.apiKey}`;
     }
 
     if (this.callbackUrl) {
-      headers['X-CallbackUrl'] = this.callbackUrl
+      headers["X-CallbackUrl"] = this.callbackUrl;
     }
 
     if (this.callbackToken) {
-      headers['X-CallbackToken'] = this.callbackToken
+      headers["X-CallbackToken"] = this.callbackToken;
     }
 
     if (this.headers) {
       for (const key in this.headers) {
-        headers[key] = this.headers[key]
+        headers[key] = this.headers[key];
       }
     }
 
-    return headers
+    return headers;
   }
 
   /**
@@ -107,69 +118,81 @@ export default class ARC implements Broadcaster {
    * @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
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
+    let rawTx;
     try {
-      rawTx = tx.toHexEF()
+      rawTx = tx.toHexEF();
     } catch (error) {
-      if (error.message === 'All inputs must have source transactions when serializing to EF format') {
-        rawTx = tx.toHex()
+      if (
+        error.message ===
+        "All inputs must have source transactions when serializing to EF format"
+      ) {
+        rawTx = tx.toHex();
       } else {
-        throw error
+        throw error;
       }
     }
 
     const requestOptions: HttpClientRequestOptions = {
-      method: 'POST',
+      method: "POST",
       headers: this.requestHeaders(),
-      data: { rawTx }
-    }
+      data: { rawTx },
+    };
 
     try {
-      const response = await this.httpClient.request<ArcResponse>(`${this.URL}/v1/tx`, requestOptions)
+      const response = await this.httpClient.request<ArcResponse>(
+        `${this.URL}/v1/tx`,
+        requestOptions
+      );
       if (response.ok) {
-        const { txid, extraInfo, txStatus, competingTxs } = response.data
+        const { txid, extraInfo, txStatus, competingTxs } = response.data;
         let broadcastRes: BroadcastResponse = {
-          status: 'success',
+          status: "success",
           txid,
-          message: `${txStatus} ${extraInfo}`
-        }
+          message: `${txStatus} ${extraInfo}`,
+        };
         if (competingTxs) {
-          broadcastRes.competingTxs = competingTxs
+          broadcastRes.competingTxs = competingTxs;
         }
-        return broadcastRes
+        return broadcastRes;
       } else {
-        const st = typeof response.status
+        const st = typeof response.status;
         const r: BroadcastFailure = {
-          status: 'error',
-          code: st === 'number' || st === 'string' ? response.status.toString() : 'ERR_UNKNOWN',
-          description: 'Unknown error'
-        }
-        let d = response.data
-        if (typeof d === 'string') {
+          status: "error",
+          code:
+            st === "number" || st === "string"
+              ? response.status.toString()
+              : "ERR_UNKNOWN",
+          description: "Unknown error",
+        };
+        let d = response.data;
+        if (typeof d === "string") {
           try {
-            d = JSON.parse(response.data)
-          } catch { }
+            d = JSON.parse(response.data);
+          } catch {}
         }
-        if (typeof d === 'object') {
-          r.more = d
-          if (typeof d.txid === 'string') {
-            r.txid = d.txid
+        if (typeof d === "object") {
+          r.more = d;
+          if (typeof d.txid === "string") {
+            r.txid = d.txid;
           }
-          if (typeof d.detail === 'string') {
-            r.description = d.detail
+          if (typeof d.detail === "string") {
+            r.description = d.detail;
           }
         }
-        return r
+        return r;
       }
     } catch (error) {
       return {
-        status: 'error',
-        code: '500',
-        description: typeof error.message === 'string'
-          ? error.message
-          : 'Internal Server Error'
-      }
+        status: "error",
+        code: "500",
+        description:
+          typeof error.message === "string"
+            ? error.message
+            : "Internal Server Error",
+      };
     }
   }
 
@@ -181,11 +204,14 @@ export default class ARC implements Broadcaster {
    * @returns {Promise<Array<object>>} A promise that resolves to an array of objects.
    */
   async broadcastMany(txs: Transaction[]): Promise<Array<object>> {
-    const rawTxs = txs.map(tx => {
+    const rawTxs = txs.map((tx) => {
       try {
         return { rawTx: tx.toHexEF() };
       } catch (error) {
-        if (error.message === 'All inputs must have source transactions when serializing to EF format') {
+        if (
+          error.message ===
+          "All inputs must have source transactions when serializing to EF format"
+        ) {
           return { rawTx: tx.toHex() };
         }
         throw error;
@@ -193,9 +219,9 @@ export default class ARC implements Broadcaster {
     });
 
     const requestOptions: HttpClientRequestOptions = {
-      method: 'POST',
+      method: "POST",
       headers: this.requestHeaders(),
-      data: rawTxs
+      data: rawTxs,
     };
 
     try {
@@ -204,12 +230,12 @@ export default class ARC implements Broadcaster {
         requestOptions
       );
 
-      return response.data
+      return response.data;
     } catch (error) {
       const errorResponse: BroadcastFailure = {
-        status: 'error',
-        code: '500',
-        description: error.message || 'Internal Server Error'
+        status: "error",
+        code: "500",
+        description: error.message || "Internal Server Error",
       };
       return txs.map(() => errorResponse);
     }
@@ -217,8 +243,8 @@ export default class ARC implements Broadcaster {
 }
 
 interface ArcResponse {
-  txid: string
-  extraInfo: string
-  txStatus: string
-  competingTxs?: string[]
+  txid: string;
+  extraInfo: string;
+  txStatus: string;
+  competingTxs?: string[];
 }

package/src/transaction/broadcasters/DefaultBroadcaster.ts

@@ -1,6 +1,12 @@
-import { Broadcaster } from '../Broadcaster.js'
-import ARC, { ArcConfig } from './ARC.js'
+import { Broadcaster } from "../Broadcaster";
+import ARC, { ArcConfig } from "./ARC";
 
-export function defaultBroadcaster (isTestnet: boolean = false, config: ArcConfig = {}): Broadcaster {
-  return new ARC(isTestnet ? 'https://arc-test.taal.com' : 'https://arc.taal.com', config)
-}
+export function defaultBroadcaster(
+  isTestnet: boolean = false,
+  config: ArcConfig = {}
+): Broadcaster {
+  return new ARC(
+    isTestnet ? "https://arc-test.taal.com" : "https://arc.taal.com",
+    config
+  );
+}

package/src/transaction/broadcasters/WhatsOnChainBroadcaster.ts

@@ -1,15 +1,19 @@
-import { BroadcastResponse, BroadcastFailure, Broadcaster } from '../Broadcaster.js'
-import Transaction from '../Transaction.js'
-import { HttpClient } from '../http/HttpClient.js'
-import { defaultHttpClient } from '../http/DefaultHttpClient.js'
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster,
+} from "../Broadcaster";
+import Transaction from "../Transaction";
+import { HttpClient } from "../http/HttpClient";
+import { defaultHttpClient } from "../http/DefaultHttpClient";
 
 /**
  * Represents an WhatsOnChain transaction broadcaster.
  */
 export default class WhatsOnChainBroadcaster implements Broadcaster {
-  readonly network: string
-  private readonly URL: string
-  private readonly httpClient: HttpClient
+  readonly network: string;
+  private readonly URL: string;
+  private readonly httpClient: HttpClient;
 
   /**
    * Constructs an instance of the WhatsOnChain broadcaster.
@@ -17,10 +21,13 @@ export default class WhatsOnChainBroadcaster implements 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
+  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;
   }
 
   /**
@@ -29,42 +36,48 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
    * @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> {
-    const rawTx = tx.toHex()
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
+    const rawTx = tx.toHex();
 
     const requestOptions = {
-      method: 'POST',
+      method: "POST",
       headers: {
-        'Content-Type': 'application/json',
-        Accept: 'text/plain'
+        "Content-Type": "application/json",
+        Accept: "text/plain",
       },
-      data: { txhex: rawTx }
-    }
+      data: { txhex: rawTx },
+    };
 
     try {
-      const response = await this.httpClient.request<string>(this.URL, requestOptions)
+      const response = await this.httpClient.request<string>(
+        this.URL,
+        requestOptions
+      );
       if (response.ok) {
-        const txid = response.data
+        const txid = response.data;
         return {
-          status: 'success',
+          status: "success",
           txid,
-          message: 'broadcast successful'
-        }
+          message: "broadcast successful",
+        };
       } else {
         return {
-          status: 'error',
-          code: response.status.toString() ?? 'ERR_UNKNOWN',
-          description: response.data ?? 'Unknown error'
-        }
+          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'
-      }
+        status: "error",
+        code: "500",
+        description:
+          typeof error.message === "string"
+            ? error.message
+            : "Internal Server Error",
+      };
     }
   }
 }