@bsv/sdk 1.3.13 → 1.3.15

package/src/transaction/broadcasters/ARC.ts

@@ -1,45 +1,45 @@
 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";
+  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;
+  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))}`;
+function defaultDeploymentId(): string {
+  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.
@@ -47,69 +47,70 @@ 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 configObj: ArcConfig = config ?? {}
       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;
+        headers
+      } = configObj
+      this.apiKey = apiKey
+      this.httpClient = httpClient ?? defaultHttpClient()
+      this.deploymentId = deploymentId ?? defaultDeploymentId()
+      this.callbackToken = callbackToken
+      this.callbackUrl = callbackUrl
+      this.headers = headers
     }
   }
 
   /**
    * Constructs a dictionary of the default & supplied request headers.
    */
-  private requestHeaders() {
+  private requestHeaders(): Record<string, string> {
     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}`;
+    if (this.apiKey != null && this.apiKey !== '') {
+      headers.Authorization = `Bearer ${this.apiKey}`
     }
 
-    if (this.callbackUrl) {
-      headers["X-CallbackUrl"] = this.callbackUrl;
+    if (this.callbackUrl != null && this.callbackUrl !== '') {
+      headers['X-CallbackUrl'] = this.callbackUrl
     }
 
-    if (this.callbackToken) {
-      headers["X-CallbackToken"] = this.callbackToken;
+    if (this.callbackToken != null && this.callbackToken !== '') {
+      headers['X-CallbackToken'] = this.callbackToken
     }
 
-    if (this.headers) {
+    if (this.headers != null) {
       for (const key in this.headers) {
-        headers[key] = this.headers[key];
+        headers[key] = this.headers[key]
       }
     }
 
-    return headers;
+    return headers
   }
 
   /**
@@ -121,78 +122,82 @@ export default class ARC implements Broadcaster {
   async broadcast(
     tx: Transaction
   ): Promise<BroadcastResponse | BroadcastFailure> {
-    let rawTx;
+    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"
+        'All inputs must have source transactions when serializing to EF format'
       ) {
-        rawTx = tx.toHex();
+        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
-      );
+      )
       if (response.ok) {
-        const { txid, extraInfo, txStatus, competingTxs } = response.data;
-        let broadcastRes: BroadcastResponse = {
-          status: "success",
+        const { txid, extraInfo, txStatus, competingTxs } = response.data
+        const broadcastRes: BroadcastResponse = {
+          status: 'success',
           txid,
-          message: `${txStatus} ${extraInfo}`,
-        };
-        if (competingTxs) {
-          broadcastRes.competingTxs = competingTxs;
+          message: `${txStatus} ${extraInfo}`
+        }
+        if (competingTxs != null) {
+          broadcastRes.competingTxs = competingTxs
         }
-        return broadcastRes;
+        return broadcastRes
       } else {
-        const st = typeof response.status;
+        const st = typeof response.status
         const r: BroadcastFailure = {
-          status: "error",
+          status: 'error',
           code:
-            st === "number" || st === "string"
+            st === 'number' || st === 'string'
               ? response.status.toString()
-              : "ERR_UNKNOWN",
-          description: "Unknown error",
-        };
-        let d = response.data;
-        if (typeof d === "string") {
+              : '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 as string)
+          } catch {
+            // Intentionally left empty
+          }
         }
-        if (typeof d === "object") {
-          r.more = d;
-          if (typeof d.txid === "string") {
-            r.txid = d.txid;
+        if (typeof d === 'object') {
+          if (d !== null) {
+            r.more = d
           }
-          if (typeof d.detail === "string") {
-            r.description = d.detail;
+          if ((d != null) && typeof (d as { txid: string }).txid === 'string') {
+            r.txid = (d as { txid: string }).txid
+          }
+          if ((d != null) && 'detail' in d && typeof (d as { detail: string }).detail === 'string') {
+            r.description = (d as { detail: string }).detail
           }
         }
-        return r;
+        return r
       }
     } catch (error) {
       return {
-        status: "error",
-        code: "500",
+        status: 'error',
+        code: '500',
         description:
-          typeof error.message === "string"
+          typeof error.message === 'string'
             ? error.message
-            : "Internal Server Error",
-      };
+            : 'Internal Server Error'
+      }
     }
   }
 
@@ -203,48 +208,48 @@ export default class ARC implements Broadcaster {
    * @param {Transaction[]} txs - Array of transactions to be broadcasted.
    * @returns {Promise<Array<object>>} A promise that resolves to an array of objects.
    */
-  async broadcastMany(txs: Transaction[]): Promise<Array<object>> {
+  async broadcastMany(txs: Transaction[]): Promise<object[]> {
     const rawTxs = txs.map((tx) => {
       try {
-        return { rawTx: tx.toHexEF() };
+        return { rawTx: tx.toHexEF() }
       } catch (error) {
         if (
           error.message ===
-          "All inputs must have source transactions when serializing to EF format"
+          'All inputs must have source transactions when serializing to EF format'
         ) {
-          return { rawTx: tx.toHex() };
+          return { rawTx: tx.toHex() }
         }
-        throw error;
+        throw error
       }
-    });
+    })
 
     const requestOptions: HttpClientRequestOptions = {
-      method: "POST",
+      method: 'POST',
       headers: this.requestHeaders(),
-      data: rawTxs,
-    };
+      data: rawTxs
+    }
 
     try {
-      const response = await this.httpClient.request<Array<object>>(
+      const response = await this.httpClient.request<object[]>(
         `${this.URL}/v1/txs`,
         requestOptions
-      );
+      )
 
-      return response.data;
+      return response.data as object[]
     } catch (error) {
       const errorResponse: BroadcastFailure = {
-        status: "error",
-        code: "500",
-        description: error.message || "Internal Server Error",
-      };
-      return txs.map(() => errorResponse);
+        status: 'error',
+        code: '500',
+        description: typeof error.message === 'string' ? error.message : 'Internal Server Error'
+      }
+      return txs.map(() => errorResponse)
     }
   }
 }
 
 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,12 +1,12 @@
-import { Broadcaster } from "../Broadcaster";
-import ARC, { ArcConfig } from "./ARC";
+import { Broadcaster } from '../Broadcaster.js'
+import ARC, { ArcConfig } from './ARC.js'
 
 export function defaultBroadcaster(
   isTestnet: boolean = false,
   config: ArcConfig = {}
 ): Broadcaster {
   return new ARC(
-    isTestnet ? "https://arc-test.taal.com" : "https://arc.taal.com",
+    isTestnet ? 'https://arc-test.taal.com' : 'https://arc.taal.com',
     config
-  );
+  )
 }

package/src/transaction/broadcasters/WhatsOnChainBroadcaster.ts

@@ -1,19 +1,19 @@
 import {
   BroadcastResponse,
   BroadcastFailure,
-  Broadcaster,
-} from "../Broadcaster";
-import Transaction from "../Transaction";
-import { HttpClient } from "../http/HttpClient";
-import { defaultHttpClient } from "../http/DefaultHttpClient";
+  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;
+  readonly network: string
+  private readonly URL: string
+  private readonly httpClient: HttpClient
 
   /**
    * Constructs an instance of the WhatsOnChain broadcaster.
@@ -22,12 +22,12 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
    * @param {HttpClient} httpClient - The HTTP client used to make requests to the API.
    */
   constructor(
-    network: "main" | "test" | "stn" = "main",
+    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;
+    this.network = network
+    this.URL = `https://api.whatsonchain.com/v1/bsv/${network}/tx/raw`
+    this.httpClient = httpClient
   }
 
   /**
@@ -39,45 +39,45 @@ export default class WhatsOnChainBroadcaster implements Broadcaster {
   async broadcast(
     tx: Transaction
   ): Promise<BroadcastResponse | BroadcastFailure> {
-    const rawTx = tx.toHex();
+    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
-      );
+      )
       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",
+        status: 'error',
+        code: '500',
         description:
-          typeof error.message === "string"
+          typeof error.message === 'string'
             ? error.message
-            : "Internal Server Error",
-      };
+            : 'Internal Server Error'
+      }
     }
   }
 }