@bsv/sdk 1.3.13 → 1.3.15

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

@@ -1,198 +1,198 @@
-import { NodejsHttpClient } from "../../../transaction/http/NodejsHttpClient";
-import WhatsOnChain from "../../../transaction/chaintrackers/WhatsOnChain";
-import { FetchHttpClient } from "../../../transaction/http/FetchHttpClient";
+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 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;
+    mockedHttps(successResponse)
+    if (typeof global.window !== 'undefined') global.window = {} as any
 
-    const chainTracker = new WhatsOnChain(network);
+    const chainTracker = new WhatsOnChain(network)
     const response = await chainTracker.isValidRootForHeight(
       merkleroot,
       height
-    );
+    )
 
-    expect(response).toEqual(true);
-  });
+    expect(response).toEqual(true)
+  })
 
-  it("should verify merkleroot successfully using provided window.fetch", async () => {
-    const mockFetch = mockedFetch(successResponse);
+  it('should verify merkleroot successfully using provided window.fetch', async () => {
+    const mockFetch = mockedFetch(successResponse)
 
     const chainTracker = new WhatsOnChain(network, {
-      httpClient: new FetchHttpClient(mockFetch),
-    });
+      httpClient: new FetchHttpClient(mockFetch)
+    })
     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 provided Node.js https", async () => {
-    const mockHttps = mockedHttps(successResponse);
+  it('should verify merkleroot successfully using provided Node.js https', async () => {
+    const mockHttps = mockedHttps(successResponse)
 
     const chainTracker = new WhatsOnChain(network, {
-      httpClient: new NodejsHttpClient(mockHttps),
-    });
+      httpClient: new NodejsHttpClient(mockHttps)
+    })
     const response = await chainTracker.isValidRootForHeight(
       merkleroot,
       height
-    );
+    )
 
-    expect(response).toEqual(true);
-  });
+    expect(response).toEqual(true)
+  })
 
-  it("should respond with invalid root for height when block for height is not found", async () => {
+  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),
-    });
+      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),
-    });
+      httpClient: new FetchHttpClient(mockFetch)
+    })
 
     await expect(
       chainTracker.isValidRootForHeight(merkleroot, height)
-    ).rejects.toThrow("Network error");
-  });
+    ).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),
-    });
+      httpClient: new FetchHttpClient(mockFetch)
+    })
 
     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",
+          versionHex: '2a000000',
           merkleroot:
-            "8af5a2d4325ec30e30103b1f365c303d4b49d11e42d26b0d7e9b6866724392e9",
+            '8af5a2d4325ec30e30103b1f365c303d4b49d11e42d26b0d7e9b6866724392e9',
           time: 1734667612,
           mediantime: 1734663717,
           nonce: 157007350,
-          bits: "180f2b74",
+          bits: '180f2b74',
           difficulty: 72479484799.59058,
           chainwork:
-            "00000000000000000000000000000000000000000160c2f41c8793b90f4500dd",
+            '00000000000000000000000000000000000000000160c2f41c8793b90f4500dd',
           previousblockhash:
-            "00000000000000000128f312a7c62ef5f9a91a3f845a4464d10cfbaaecd233a0",
-          nextblockhash: "",
+            '00000000000000000128f312a7c62ef5f9a91a3f845a4464d10cfbaaecd233a0',
+          nextblockhash: '',
           nTx: 0,
-          num_tx: 167567,
-        },
-      ],
-    });
+          num_tx: 167567
+        }
+      ]
+    })
 
     const chainTracker = new WhatsOnChain(network, {
-      httpClient: new FetchHttpClient(mockFetch),
-    });
+      httpClient: new FetchHttpClient(mockFetch)
+    })
 
-    await expect(await chainTracker.currentHeight()).toBe(875904);
-  });
+    await expect(await chainTracker.currentHeight()).toBe(875904)
+  })
 
-  function mockedFetch(response) {
+  function mockedFetch (response: { status: number, data: any }): jest.Mock<any, any, any> {
     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: { status: number, data: any }): { request: (url: string, options: any, callback: (res: any) => void) => any } {
     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";
-export type { WhatsOnChainConfig } from "./WhatsOnChain";
-export { defaultChainTracker } from "./DefaultChainTracker";
+export { default as WhatsOnChain } from './WhatsOnChain.js'
+export type { WhatsOnChainConfig } from './WhatsOnChain.js'
+export { defaultChainTracker } from './DefaultChainTracker.js'

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

@@ -1,6 +1,5 @@
-import FeeModel from "../FeeModel";
-import Transaction from "../Transaction";
-import BigNumber from "../../primitives/BigNumber";
+import FeeModel from '../FeeModel.js'
+import Transaction from '../Transaction.js'
 
 /**
  * Represents the "satoshis per kilobyte" transaction fee model.
@@ -10,7 +9,7 @@ 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.
@@ -18,7 +17,7 @@ export default class SatoshisPerKilobyte implements FeeModel {
    * @param {number} value - The number of satoshis per kilobyte to charge as a fee.
    */
   constructor(value: number) {
-    this.value = value;
+    this.value = value
   }
 
   /**
@@ -30,47 +29,47 @@ export default class SatoshisPerKilobyte implements FeeModel {
   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") {
+      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."
-        );
+          '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";
+export { default as SatoshisPerKilobyte } from './SatoshisPerKilobyte.js'

package/src/transaction/http/DefaultHttpClient.ts

@@ -1,6 +1,6 @@
-import { HttpClient, HttpClientResponse } from "./HttpClient";
-import { NodejsHttpClient } from "./NodejsHttpClient";
-import { FetchHttpClient } from "./FetchHttpClient";
+import { HttpClient, HttpClientResponse } from './HttpClient.js'
+import { NodejsHttpClient } from './NodejsHttpClient.js'
+import { FetchHttpClient } from './FetchHttpClient.js'
 
 /**
  * Returns a default HttpClient implementation based on the environment that it is run on.
@@ -10,23 +10,24 @@ import { FetchHttpClient } from "./FetchHttpClient";
 export function defaultHttpClient(): HttpClient {
   const noHttpClient: HttpClient = {
     async request(..._): Promise<HttpClientResponse> {
-      throw new Error("No method available to perform HTTP request");
-    },
-  };
+      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") {
+    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);
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      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

@@ -2,7 +2,7 @@ import {
   HttpClient,
   HttpClientRequestOptions,
   HttpClientResponse
-} from './HttpClient'
+} from './HttpClient.js'
 
 /** fetch function interface limited to options needed by ts-sdk */
 /**
@@ -29,7 +29,7 @@ export interface FetchOptions {
  * 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,
@@ -43,7 +43,7 @@ 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')
+    const data = mediaType?.startsWith('application/json') ?? false
       ? await res.json()
       : await res.text()
 

package/src/transaction/http/HttpClient.ts

@@ -10,7 +10,7 @@ export interface HttpClient {
   request: <T = any, D = any>(
     url: string,
     options: HttpClientRequestOptions<D>
-  ) => Promise<HttpClientResponse<T>>;
+  ) => Promise<HttpClientResponse<T>>
 }
 
 /**
@@ -18,11 +18,11 @@ 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
 }
 
 /**
@@ -30,20 +30,20 @@ export interface HttpClientRequestOptions<Data = any> {
  */
 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: 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;
-    };
+    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
+  }

package/src/transaction/http/NodejsHttpClient.ts

@@ -1,8 +1,8 @@
 import {
   HttpClient,
   HttpClientRequestOptions,
-  HttpClientResponse,
-} from "./HttpClient";
+  HttpClientResponse
+} from './HttpClient.js'
 
 /** Node Https module interface limited to options needed by ts-sdk */
 export interface HttpsNodejs {
@@ -10,23 +10,23 @@ export interface HttpsNodejs {
     url: string,
     options: HttpClientRequestOptions,
     callback: (res: any) => void
-  ) => NodejsHttpClientRequest;
+  ) => NodejsHttpClientRequest
 }
 
 /** Nodejs result of the Node https.request call limited to options needed by ts-sdk */
 export interface NodejsHttpClientRequest {
-  write: (chunk: string) => void;
+  write: (chunk: string) => void
 
-  on: (event: string, callback: (data: any) => void) => void;
+  on: (event: string, callback: (data: any) => void) => void
 
-  end: (() => void) & (() => void);
+  end: (() => void) & (() => void)
 }
 
 /**
  * Adapter for Node Https module to be used as HttpClient
  */
 export class NodejsHttpClient implements HttpClient {
-  constructor(private readonly https: HttpsNodejs) {}
+  constructor(private readonly https: HttpsNodejs) { }
 
   async request(
     url: string,
@@ -34,34 +34,34 @@ export class NodejsHttpClient implements HttpClient {
   ): Promise<HttpClientResponse> {
     return await new Promise((resolve, reject) => {
       const req = this.https.request(url, requestOptions, (res) => {
-        let body = "";
-        res.on("data", (chunk: string) => {
-          body += chunk;
-        });
-        res.on("end", () => {
-          const ok = res.statusCode >= 200 && res.statusCode <= 299;
-          const mediaType = res.headers["content-type"];
+        let body = ''
+        res.on('data', (chunk: string) => {
+          body += chunk
+        })
+        res.on('end', () => {
+          const ok = res.statusCode >= 200 && res.statusCode <= 299
+          const mediaType = res.headers['content-type']
           const data =
-            body && mediaType.startsWith("application/json")
+            body !== '' && typeof mediaType === 'string' && mediaType.startsWith('application/json')
               ? JSON.parse(body)
-              : body;
+              : body
           resolve({
             status: res.statusCode,
             statusText: res.statusMessage,
             ok,
-            data,
-          });
-        });
-      });
+            data
+          })
+        })
+      })
 
-      req.on("error", (error) => {
-        reject(error);
-      });
+      req.on('error', (error) => {
+        reject(error)
+      })
 
-      if (requestOptions.data) {
-        req.write(JSON.stringify(requestOptions.data));
+      if (requestOptions.data !== null && requestOptions.data !== undefined) {
+        req.write(JSON.stringify(requestOptions.data))
       }
-      req.end();
-    });
+      req.end()
+    })
   }
 }

package/src/transaction/http/index.ts

@@ -1,10 +1,10 @@
 export type {
   HttpClient,
   HttpClientResponse,
-  HttpClientRequestOptions,
-} from "./HttpClient";
-export { defaultHttpClient } from "./DefaultHttpClient";
-export { NodejsHttpClient } from "./NodejsHttpClient";
-export { FetchHttpClient } from "./FetchHttpClient";
-export type { Fetch, FetchOptions } from "./FetchHttpClient";
-export type { HttpsNodejs, NodejsHttpClientRequest } from "./NodejsHttpClient";
+  HttpClientRequestOptions
+} from './HttpClient.js'
+export { defaultHttpClient } from './DefaultHttpClient.js'
+export { NodejsHttpClient } from './NodejsHttpClient.js'
+export { FetchHttpClient } from './FetchHttpClient.js'
+export type { Fetch, FetchOptions } from './FetchHttpClient.js'
+export type { HttpsNodejs, NodejsHttpClientRequest } from './NodejsHttpClient.js'