@bsv/sdk 1.3.12 → 1.3.13

package/src/transaction/chaintrackers/__tests/WhatsOnChainChainTracker.test.ts

@@ -1,162 +1,198 @@
-import { NodejsHttpClient } from '../../../../dist/cjs/src/transaction/http/NodejsHttpClient.js'
-import WhatsOnChain from '../../../../dist/cjs/src/transaction/chaintrackers/WhatsOnChain.js'
-import { FetchHttpClient } from '../../../../dist/cjs/src/transaction/http/FetchHttpClient.js'
+import { NodejsHttpClient } from "../../../transaction/http/NodejsHttpClient";
+import WhatsOnChain from "../../../transaction/chaintrackers/WhatsOnChain";
+import { FetchHttpClient } from "../../../transaction/http/FetchHttpClient";
 
-describe('WhatsOnChain ChainTracker', () => {
-  const network = 'main'
-  const height = 123456
-  const merkleroot = 'mocked_merkleroot'
+describe("WhatsOnChain ChainTracker", () => {
+  const network = "main";
+  const height = 123456;
+  const merkleroot = "mocked_merkleroot";
 
   const successResponse = {
     status: 200,
     data: {
-      merkleroot
-    }
-  }
+      merkleroot,
+    },
+  };
 
-  it('should verify merkleroot successfully using window.fetch', async () => {
+  it("should verify merkleroot successfully using window.fetch", async () => {
     // Mocking window.fetch
-    const mockFetch = mockedFetch(successResponse)
-    global.window = { fetch: mockFetch } as any
+    const mockFetch = mockedFetch(successResponse);
+    global.window = { fetch: mockFetch } as any;
 
-    const chainTracker = new WhatsOnChain(network)
-    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+    const chainTracker = new WhatsOnChain(network);
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    );
 
-    expect(mockFetch).toHaveBeenCalled()
-    expect(response).toEqual(true)
-  })
+    expect(mockFetch).toHaveBeenCalled();
+    expect(response).toEqual(true);
+  });
 
-  it('should verify merkleroot successfully using Node.js https', async () => {
+  it("should verify merkleroot successfully using Node.js https", async () => {
     // Mocking Node.js https module
-    mockedHttps(successResponse)
-    if (global.window) global.window = {} as any
-
-    const chainTracker = new WhatsOnChain(network)
-    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
-
-    expect(response).toEqual(true)
-  })
-
-  it('should verify merkleroot successfully using provided window.fetch', async () => {
-    const mockFetch = mockedFetch(successResponse)
-
-    const chainTracker = new WhatsOnChain(network, { httpClient: new FetchHttpClient(mockFetch) })
-    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
-
-    expect(mockFetch).toHaveBeenCalled()
-    expect(response).toEqual(true)
-  })
-
-  it('should verify merkleroot successfully using provided Node.js https', async () => {
-    const mockHttps = mockedHttps(successResponse)
-
-    const chainTracker = new WhatsOnChain(network, { httpClient: new NodejsHttpClient(mockHttps) })
-    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
-
-    expect(response).toEqual(true)
-  })
-
-  it('should respond with invalid root for height when block for height is not found', async () => {
+    mockedHttps(successResponse);
+    if (global.window) global.window = {} as any;
+
+    const chainTracker = new WhatsOnChain(network);
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    );
+
+    expect(response).toEqual(true);
+  });
+
+  it("should verify merkleroot successfully using provided window.fetch", async () => {
+    const mockFetch = mockedFetch(successResponse);
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch),
+    });
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    );
+
+    expect(mockFetch).toHaveBeenCalled();
+    expect(response).toEqual(true);
+  });
+
+  it("should verify merkleroot successfully using provided Node.js https", async () => {
+    const mockHttps = mockedHttps(successResponse);
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new NodejsHttpClient(mockHttps),
+    });
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    );
+
+    expect(response).toEqual(true);
+  });
+
+  it("should respond with invalid root for height when block for height is not found", async () => {
     const mockFetch = mockedFetch({
       status: 404,
-      data: 'not found'
-    })
+      data: "not found",
+    });
 
-    const chainTracker = new WhatsOnChain(network, { httpClient: new FetchHttpClient(mockFetch) })
-    const response = await chainTracker.isValidRootForHeight(merkleroot, height)
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch),
+    });
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    );
 
-    expect(response).toEqual(false)
-  })
+    expect(response).toEqual(false);
+  });
 
-  it('should handle network errors', async () => {
-    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+  it("should handle network errors", async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error("Network error"));
 
-    const chainTracker = new WhatsOnChain(network, { httpClient: new FetchHttpClient(mockFetch) })
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch),
+    });
 
-    await expect(chainTracker.isValidRootForHeight(merkleroot, height)).rejects.toThrow('Network error')
-  })
+    await expect(
+      chainTracker.isValidRootForHeight(merkleroot, height)
+    ).rejects.toThrow("Network error");
+  });
 
-  it('should throw error when received error response', async () => {
+  it("should throw error when received error response", async () => {
     const mockFetch = mockedFetch({
       status: 401,
-      data: { error: 'Unauthorized' }
-    })
+      data: { error: "Unauthorized" },
+    });
 
-    const chainTracker = new WhatsOnChain(network, { httpClient: new FetchHttpClient(mockFetch) })
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch),
+    });
 
-    await expect(chainTracker.isValidRootForHeight(merkleroot, height)).rejects.toThrow(/Failed to verify merkleroot for height \d+ because of an error: .*/)
-  })
+    await expect(
+      chainTracker.isValidRootForHeight(merkleroot, height)
+    ).rejects.toThrow(
+      /Failed to verify merkleroot for height \d+ because of an error: .*/
+    );
+  });
 
-  it('should return the current height', async () => {
+  it("should return the current height", async () => {
     const mockFetch = mockedFetch({
       status: 200,
       data: [
         {
-          hash: '00000000000000000af9958a79fd4dbac1b04a553cc00c80e108718561ccb5a5',
+          hash: "00000000000000000af9958a79fd4dbac1b04a553cc00c80e108718561ccb5a5",
           confirmations: 1,
           size: 29605652,
           height: 875904,
           version: 704643072,
-          versionHex: '2a000000',
-          merkleroot: '8af5a2d4325ec30e30103b1f365c303d4b49d11e42d26b0d7e9b6866724392e9',
+          versionHex: "2a000000",
+          merkleroot:
+            "8af5a2d4325ec30e30103b1f365c303d4b49d11e42d26b0d7e9b6866724392e9",
           time: 1734667612,
           mediantime: 1734663717,
           nonce: 157007350,
-          bits: '180f2b74',
+          bits: "180f2b74",
           difficulty: 72479484799.59058,
-          chainwork: '00000000000000000000000000000000000000000160c2f41c8793b90f4500dd',
-          previousblockhash: '00000000000000000128f312a7c62ef5f9a91a3f845a4464d10cfbaaecd233a0',
-          nextblockhash: '',
+          chainwork:
+            "00000000000000000000000000000000000000000160c2f41c8793b90f4500dd",
+          previousblockhash:
+            "00000000000000000128f312a7c62ef5f9a91a3f845a4464d10cfbaaecd233a0",
+          nextblockhash: "",
           nTx: 0,
-          num_tx: 167567
-        }
-      ]
-    })
+          num_tx: 167567,
+        },
+      ],
+    });
 
-    const chainTracker = new WhatsOnChain(network, { httpClient: new FetchHttpClient(mockFetch) })
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch),
+    });
 
-    await expect(await chainTracker.currentHeight()).toBe(875904)
-  })
+    await expect(await chainTracker.currentHeight()).toBe(875904);
+  });
 
-  function mockedFetch (response) {
+  function mockedFetch(response) {
     return jest.fn().mockResolvedValue({
       ok: response.status === 200,
       status: response.status,
-      statusText: response.status === 200 ? 'OK' : 'Bad request',
+      statusText: response.status === 200 ? "OK" : "Bad request",
       headers: {
-        get (key: string) {
-          if (key === 'Content-Type') {
-            return 'application/json'
+        get(key: string) {
+          if (key === "Content-Type") {
+            return "application/json";
           }
-        }
+        },
       },
-      json: async () => response.data
-    })
+      json: async () => response.data,
+    });
   }
 
-  function mockedHttps (response) {
+  function mockedHttps(response) {
     const https = {
       request: (url, options, callback) => {
         // eslint-disable-next-line
         callback({
           statusCode: response.status,
-          statusMessage: response.status == 200 ? 'OK' : 'Bad request',
+          statusMessage: response.status == 200 ? "OK" : "Bad request",
           headers: {
-            'content-type': 'application/json'
+            "content-type": "application/json",
           },
           on: (event, handler) => {
-            if (event === 'data') handler(JSON.stringify(response.data))
-            if (event === 'end') handler()
-          }
-        })
+            if (event === "data") handler(JSON.stringify(response.data));
+            if (event === "end") handler();
+          },
+        });
         return {
           on: jest.fn(),
           write: jest.fn(),
-          end: jest.fn()
-        }
-      }
-    }
-    jest.mock('https', () => https)
-    return https
+          end: jest.fn(),
+        };
+      },
+    };
+    jest.mock("https", () => https);
+    return https;
   }
-})
+});

package/src/transaction/chaintrackers/index.ts

@@ -1,3 +1,3 @@
-export { default as WhatsOnChain } from './WhatsOnChain.js'
-export type { WhatsOnChainConfig } from './WhatsOnChain.js'
-export { defaultChainTracker } from './DefaultChainTracker.js'
+export { default as WhatsOnChain } from "./WhatsOnChain";
+export type { WhatsOnChainConfig } from "./WhatsOnChain";
+export { defaultChainTracker } from "./DefaultChainTracker";

package/src/transaction/fee-models/SatoshisPerKilobyte.ts

@@ -1,6 +1,6 @@
-import FeeModel from '../FeeModel.js'
-import Transaction from '../Transaction.js'
-import BigNumber from '../../primitives/BigNumber.js'
+import FeeModel from "../FeeModel";
+import Transaction from "../Transaction";
+import BigNumber from "../../primitives/BigNumber";
 
 /**
  * Represents the "satoshis per kilobyte" transaction fee model.
@@ -10,15 +10,15 @@ export default class SatoshisPerKilobyte implements FeeModel {
    * @property
    * Denotes the number of satoshis paid per kilobyte of transaction size.
    */
-  value: number
+  value: number;
 
   /**
    * Constructs an instance of the sat/kb fee model.
    *
    * @param {number} value - The number of satoshis per kilobyte to charge as a fee.
    */
-  constructor (value: number) {
-    this.value = value
+  constructor(value: number) {
+    this.value = value;
   }
 
   /**
@@ -27,45 +27,50 @@ export default class SatoshisPerKilobyte implements FeeModel {
    * @param tx The transaction for which a fee is to be computed.
    * @returns The fee in satoshis for the transaction, as a BigNumber.
    */
-  async computeFee (tx: Transaction): Promise<number> {
+  async computeFee(tx: Transaction): Promise<number> {
     const getVarIntSize = (i: number): number => {
       if (i > 2 ** 32) {
-        return 9
+        return 9;
       } else if (i > 2 ** 16) {
-        return 5
+        return 5;
       } else if (i > 253) {
-        return 3
+        return 3;
       } else {
-        return 1
+        return 1;
       }
-    }
+    };
     // Compute the (potentially estimated) size of the transaction
-    let size = 4 // version
-    size += getVarIntSize(tx.inputs.length) // number of inputs
+    let size = 4; // version
+    size += getVarIntSize(tx.inputs.length); // number of inputs
     for (let i = 0; i < tx.inputs.length; i++) {
-      const input = tx.inputs[i]
-      size += 40 // txid, output index, sequence number
-      let scriptLength: number
-      if (typeof input.unlockingScript === 'object') {
-        scriptLength = input.unlockingScript.toBinary().length
-      } else if (typeof input.unlockingScriptTemplate === 'object') {
-        scriptLength = await input.unlockingScriptTemplate.estimateLength(tx, i)
+      const input = tx.inputs[i];
+      size += 40; // txid, output index, sequence number
+      let scriptLength: number;
+      if (typeof input.unlockingScript === "object") {
+        scriptLength = input.unlockingScript.toBinary().length;
+      } else if (typeof input.unlockingScriptTemplate === "object") {
+        scriptLength = await input.unlockingScriptTemplate.estimateLength(
+          tx,
+          i
+        );
       } else {
-        throw new Error('All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation.')
+        throw new Error(
+          "All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation."
+        );
       }
-      size += getVarIntSize(scriptLength) // unlocking script length
-      size += scriptLength // unlocking script
+      size += getVarIntSize(scriptLength); // unlocking script length
+      size += scriptLength; // unlocking script
     }
-    size += getVarIntSize(tx.outputs.length) // number of outputs
+    size += getVarIntSize(tx.outputs.length); // number of outputs
     for (const out of tx.outputs) {
-      size += 8 // satoshis
-      const length = out.lockingScript.toBinary().length
-      size += getVarIntSize(length) // script length
-      size += length // script
+      size += 8; // satoshis
+      const length = out.lockingScript.toBinary().length;
+      size += getVarIntSize(length); // script length
+      size += length; // script
     }
-    size += 4 // lock time
+    size += 4; // lock time
     // We'll use Math.ceil to ensure the miners get the extra satoshi.
-    const fee = Math.ceil((size / 1000) * this.value)
-    return fee
+    const fee = Math.ceil((size / 1000) * this.value);
+    return fee;
   }
 }

package/src/transaction/fee-models/index.ts

@@ -1 +1 @@
-export { default as SatoshisPerKilobyte } from './SatoshisPerKilobyte.js'
+export { default as SatoshisPerKilobyte } from "./SatoshisPerKilobyte";

package/src/transaction/http/DefaultHttpClient.ts

@@ -1,32 +1,32 @@
-import { HttpClient, HttpClientResponse } from './HttpClient.js'
-import { NodejsHttpClient } from './NodejsHttpClient.js'
-import { FetchHttpClient } from './FetchHttpClient.js'
+import { HttpClient, HttpClientResponse } from "./HttpClient";
+import { NodejsHttpClient } from "./NodejsHttpClient";
+import { FetchHttpClient } from "./FetchHttpClient";
 
 /**
  * Returns a default HttpClient implementation based on the environment that it is run on.
  * 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
+ * If running in a Node environment, it falls back to using the Node `https` module
  */
-export function defaultHttpClient (): HttpClient {
+export function defaultHttpClient(): HttpClient {
   const noHttpClient: HttpClient = {
-    async request (..._): Promise<HttpClientResponse> {
-      throw new Error('No method available to perform HTTP request')
-    }
-  }
+    async request(..._): Promise<HttpClientResponse> {
+      throw new Error("No method available to perform HTTP request");
+    },
+  };
 
-  if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+  if (typeof window !== "undefined" && typeof window.fetch === "function") {
     // Use fetch in a browser environment
-    return new FetchHttpClient(window.fetch.bind(window))
-  } else if (typeof require !== 'undefined') {
-    // Use Node.js https module
+    return new FetchHttpClient(window.fetch.bind(window));
+  } else if (typeof require !== "undefined") {
+    // Use Node https module
     // eslint-disable-next-line
     try {
-      const https = require('https')
-      return new NodejsHttpClient(https)
+      const https = require("https");
+      return new NodejsHttpClient(https);
     } catch (e) {
-      return noHttpClient
+      return noHttpClient;
     }
   } else {
-    return noHttpClient
+    return noHttpClient;
   }
 }

package/src/transaction/http/FetchHttpClient.ts

@@ -1,11 +1,15 @@
-import { HttpClient, HttpClientRequestOptions, HttpClientResponse } from './HttpClient.js'
+import {
+  HttpClient,
+  HttpClientRequestOptions,
+  HttpClientResponse
+} from './HttpClient'
 
 /** fetch function interface limited to options needed by ts-sdk */
 /**
-   * Makes a request to the server.
-   * @param url The URL to make the request to.
-   * @param options The request configuration.
-   */
+ * Makes a request to the server.
+ * @param url The URL to make the request to.
+ * @param options The request configuration.
+ */
 export type Fetch = (url: string, options: FetchOptions) => Promise<Response>
 
 /**
@@ -22,12 +26,15 @@ export interface FetchOptions {
 }
 
 /**
- * Adapter for Node.js Https module to be used as HttpClient
+ * Adapter for Node Https module to be used as HttpClient
  */
 export class FetchHttpClient implements HttpClient {
-  constructor (private readonly fetch: Fetch) {}
+  constructor(private readonly fetch: Fetch) {}
 
-  async request<D>(url: string, options: HttpClientRequestOptions): Promise<HttpClientResponse<D>> {
+  async request<D>(
+    url: string,
+    options: HttpClientRequestOptions
+  ): Promise<HttpClientResponse<D>> {
     const fetchOptions: FetchOptions = {
       method: options.method,
       headers: options.headers,
@@ -36,7 +43,9 @@ export class FetchHttpClient implements HttpClient {
 
     const res = await this.fetch(url, fetchOptions)
     const mediaType = res.headers.get('Content-Type')
-    const data = mediaType.startsWith('application/json') ? await res.json() : await res.text()
+    const data = mediaType.startsWith('application/json')
+      ? await res.json()
+      : await res.text()
 
     return {
       ok: res.ok,

package/src/transaction/http/HttpClient.ts

@@ -3,11 +3,14 @@
  */
 export interface HttpClient {
   /**
-     * Makes a request to the server.
-     * @param url The URL to make the request to.
-     * @param options The request configuration.
-     */
-  request: <T = any, D = any>(url: string, options: HttpClientRequestOptions<D>) => Promise<HttpClientResponse<T>>
+   * Makes a request to the server.
+   * @param url The URL to make the request to.
+   * @param options The request configuration.
+   */
+  request: <T = any, D = any>(
+    url: string,
+    options: HttpClientRequestOptions<D>
+  ) => Promise<HttpClientResponse<T>>;
 }
 
 /**
@@ -15,30 +18,32 @@ export interface HttpClient {
  */
 export interface HttpClientRequestOptions<Data = any> {
   /** A string to set request's method. */
-  method?: string
+  method?: string;
   /** An object literal set request's headers. */
-  headers?: Record<string, string>
+  headers?: Record<string, string>;
   /** An object or null to set request's body. */
-  data?: Data
+  data?: Data;
 }
 
 /**
  * An interface for the response returned by the request method.
  */
-export type HttpClientResponse<T = any> = {
-  data: T
-  /** The status code of the response. */
-  status: number
-  /** The status text of the response. */
-  statusText: string
-  /** A flag indicating whether the request ends with success status or not. */
-  ok: true
-} | {
-  data: any
-  /** The status code of the response. */
-  status: number
-  /** The status text of the response. */
-  statusText: string
-  /** A flag indicating whether the request ends with success status or not. */
-  ok: false
-}
+export type HttpClientResponse<T = any> =
+  | {
+      data: T;
+      /** The status code of the response. */
+      status: number;
+      /** The status text of the response. */
+      statusText: string;
+      /** A flag indicating whether the request ends with success status or not. */
+      ok: true;
+    }
+  | {
+      data: any;
+      /** The status code of the response. */
+      status: number;
+      /** The status text of the response. */
+      statusText: string;
+      /** A flag indicating whether the request ends with success status or not. */
+      ok: false;
+    };