@bsv/sdk 1.0.32 → 1.0.33

package/src/script/Script.ts

@@ -21,7 +21,7 @@ export default class Script {
    * @example
    * const script = Script.fromASM("OP_DUP OP_HASH160 abcd... OP_EQUALVERIFY OP_CHECKSIG")
    */
-  static fromASM(asm: string): Script {
+  static fromASM (asm: string): Script {
     const chunks: ScriptChunk[] = []
     const tokens = asm.split(' ')
     let i = 0
@@ -100,7 +100,7 @@ export default class Script {
    * @example
    * const script = Script.fromHex("76a9...");
    */
-  static fromHex(hex: string): Script {
+  static fromHex (hex: string): Script {
     if (hex.length === 0) return Script.fromBinary([])
     if (hex.length % 2 !== 0) throw new Error('There is an uneven number of characters in the string which suggests it is not hex encoded.')
     if (!/^[0-9a-fA-F]+$/.test(hex)) throw new Error('Some elements in this string are not hex encoded.')
@@ -115,7 +115,7 @@ export default class Script {
    * @example
    * const script = Script.fromBinary([0x76, 0xa9, ...])
    */
-  static fromBinary(bin: number[]): Script {
+  static fromBinary (bin: number[]): Script {
     bin = [...bin]
     const chunks: ScriptChunk[] = []
 
@@ -179,7 +179,7 @@ export default class Script {
    * Constructs a new Script object.
    * @param chunks=[] - An array of script chunks to directly initialize the script.
    */
-  constructor(chunks: ScriptChunk[] = []) {
+  constructor (chunks: ScriptChunk[] = []) {
     this.chunks = chunks
   }
 
@@ -188,7 +188,7 @@ export default class Script {
    * Serializes the script to an ASM formatted string.
    * @returns The script in ASM string format.
    */
-  toASM(): string {
+  toASM (): string {
     let str = ''
     for (let i = 0; i < this.chunks.length; i++) {
       const chunk = this.chunks[i]
@@ -203,7 +203,7 @@ export default class Script {
    * Serializes the script to a hexadecimal string.
    * @returns The script in hexadecimal format.
    */
-  toHex(): string {
+  toHex (): string {
     return encode(this.toBinary(), 'hex') as string
   }
 
@@ -212,7 +212,7 @@ export default class Script {
    * Serializes the script to a binary array.
    * @returns The script in binary array format.
    */
-  toBinary(): number[] {
+  toBinary (): number[] {
     const writer = new Writer()
 
     for (let i = 0; i < this.chunks.length; i++) {
@@ -244,7 +244,7 @@ export default class Script {
    * @param script - The script to append.
    * @returns This script instance for chaining.
    */
-  writeScript(script: Script): Script {
+  writeScript (script: Script): Script {
     this.chunks = this.chunks.concat(script.chunks)
     return this
   }
@@ -255,7 +255,7 @@ export default class Script {
    * @param op - The opcode to append.
    * @returns This script instance for chaining.
    */
-  writeOpCode(op: number): Script {
+  writeOpCode (op: number): Script {
     this.chunks.push({ op })
     return this
   }
@@ -267,7 +267,7 @@ export default class Script {
    * @param op - The opcode to set.
    * @returns This script instance for chaining.
    */
-  setChunkOpCode(i: number, op: number): Script {
+  setChunkOpCode (i: number, op: number): Script {
     this.chunks[i] = { op }
     return this
   }
@@ -278,7 +278,7 @@ export default class Script {
   * @param bn - The BigNumber to append.
   * @returns This script instance for chaining.
    */
-  writeBn(bn: BigNumber): Script {
+  writeBn (bn: BigNumber): Script {
     if (bn.cmpn(0) === OP.OP_0) {
       this.chunks.push({
         op: OP.OP_0
@@ -306,7 +306,7 @@ export default class Script {
    * @returns This script instance for chaining.
    * @throws {Error} Throws an error if the data is too large to be pushed.
    */
-  writeBin(bin: number[]): Script {
+  writeBin (bin: number[]): Script {
     let op
     if (bin.length > 0 && bin.length < OP.OP_PUSHDATA1) {
       op = bin.length
@@ -334,7 +334,7 @@ export default class Script {
    * @param num - The number to append.
    * @returns This script instance for chaining.
    */
-  writeNumber(num: number): Script {
+  writeNumber (num: number): Script {
     this.writeBn(new BigNumber(num))
     return this
   }
@@ -344,7 +344,7 @@ export default class Script {
    * Removes all OP_CODESEPARATOR opcodes from the script.
    * @returns This script instance for chaining.
    */
-  removeCodeseparators(): Script {
+  removeCodeseparators (): Script {
     const chunks = []
     for (let i = 0; i < this.chunks.length; i++) {
       if (this.chunks[i].op !== OP.OP_CODESEPARATOR) {
@@ -362,7 +362,7 @@ export default class Script {
    *
    * @returns This script instance for chaining.
    */
-  findAndDelete(script: Script): Script {
+  findAndDelete (script: Script): Script {
     const buf = script.toHex()
     for (let i = 0; i < this.chunks.length; i++) {
       const script2 = new Script([this.chunks[i]])
@@ -379,7 +379,7 @@ export default class Script {
    * Checks if the script contains only push data operations.
    * @returns True if the script is push-only, otherwise false.
    */
-  isPushOnly(): boolean {
+  isPushOnly (): boolean {
     for (let i = 0; i < this.chunks.length; i++) {
       const chunk = this.chunks[i]
       const opCodeNum = chunk.op
@@ -395,7 +395,7 @@ export default class Script {
    * Determines if the script is a locking script.
    * @returns True if the script is a locking script, otherwise false.
    */
-  isLockingScript(): boolean {
+  isLockingScript (): boolean {
     throw new Error('Not implemented')
   }
 
@@ -404,7 +404,7 @@ export default class Script {
    * Determines if the script is an unlocking script.
    * @returns True if the script is an unlocking script, otherwise false.
    */
-  isUnlockingScript(): boolean {
+  isUnlockingScript (): boolean {
     throw new Error('Not implemented')
   }
 
@@ -415,7 +415,7 @@ export default class Script {
    * @param chunk - The script chunk.
    * @returns The string representation of the chunk.
    */
-  private _chunkToString(chunk: ScriptChunk): string {
+  private _chunkToString (chunk: ScriptChunk): string {
     const op = chunk.op
     let str = ''
     if (typeof chunk.data === 'undefined') {

package/src/transaction/MerklePath.ts

@@ -39,11 +39,11 @@ export default class MerklePath {
    * @param {string} hex - The hexadecimal string representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromHex(hex: string): MerklePath {
+  static fromHex (hex: string): MerklePath {
     return MerklePath.fromBinary(toArray(hex, 'hex'))
   }
 
-  static fromReader(reader: Reader): MerklePath {
+  static fromReader (reader: Reader): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
     const path = Array(treeHeight).fill(0).map(() => ([]))
@@ -82,12 +82,12 @@ export default class MerklePath {
    * @param {number[]} bump - The binary array representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromBinary(bump: number[]): MerklePath {
+  static fromBinary (bump: number[]): MerklePath {
     const reader = new Reader(bump)
     return MerklePath.fromReader(reader)
   }
 
-  constructor(blockHeight: number, path: Array<Array<{
+  constructor (blockHeight: number, path: Array<Array<{
     offset: number
     hash?: string
     txid?: boolean
@@ -135,7 +135,7 @@ export default class MerklePath {
    *
    * @returns {number[]} - The binary array representation of the Merkle Path.
    */
-  toBinary(): number[] {
+  toBinary (): number[] {
     const writer = new Writer()
     writer.writeVarIntNum(this.blockHeight)
     const treeHeight = this.path.length
@@ -166,7 +166,7 @@ export default class MerklePath {
    *
    * @returns {string} - The hexadecimal string representation of the Merkle Path.
    */
-  toHex(): string {
+  toHex (): string {
     return toHex(this.toBinary())
   }
 
@@ -177,7 +177,7 @@ export default class MerklePath {
    * @returns {string} - The computed Merkle root as a hexadecimal string.
    * @throws {Error} - If the transaction ID is not part of the Merkle Path.
    */
-  computeRoot(txid?: string): string {
+  computeRoot (txid?: string): string {
     if (typeof txid !== 'string') {
       txid = this.path[0].find(leaf => Boolean(leaf?.hash)).hash
     }
@@ -216,7 +216,7 @@ export default class MerklePath {
    * @param {ChainTracker} chainTracker - The ChainTracker instance used to verify the Merkle root.
    * @returns {boolean} - True if the transaction ID is valid within the Merkle Path at the specified block height.
    */
-  async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> {
+  async verify (txid: string, chainTracker: ChainTracker): Promise<boolean> {
     const root = this.computeRoot(txid)
     // Use the chain tracker to determine whether this is a valid merkle root at the given block height
     return await chainTracker.isValidRootForHeight(root, this.blockHeight)
@@ -228,7 +228,7 @@ export default class MerklePath {
    * @param {MerklePath} other - Another MerklePath to combine with this path.
    * @throws {Error} - If the paths have different block heights or roots.
    */
-  combine(other: MerklePath): void {
+  combine (other: MerklePath): void {
     if (this.blockHeight !== other.blockHeight) {
       throw new Error('You cannot combine paths which do not have the same block height.')
     }

package/src/transaction/Transaction.ts

@@ -125,25 +125,23 @@ export default class Transaction {
    * any application seeking to validate data in output scripts must store the entire transaction as well.
    * Since the transaction data includes the output script data, saving a second copy of potentially
    * large scripts can bloat application storage requirements.
-   * 
+   *
    * This function efficiently parses binary transaction data to determine the offsets and lengths of each script.
    * This supports the efficient retreival of script data from transaction data.
-   * 
+   *
    * @param bin binary transaction data
    * @returns {
    *   inputs: { vin: number, offset: number, length: number }[]
    *   outputs: { vout: number, offset: number, length: number }[]
    * }
    */
-  static parseScriptOffsets(bin: number[])
-  : {
-    inputs: { vin: number, offset: number, length: number }[]
-    outputs: { vout: number, offset: number, length: number }[]
-  }
-  {
+  static parseScriptOffsets (bin: number[]): {
+    inputs: Array<{ vin: number, offset: number, length: number }>
+    outputs: Array<{ vout: number, offset: number, length: number }>
+  } {
     const br = new Reader(bin)
-    const inputs: { vin: number, offset: number, length: number }[] = []
-    const outputs: { vout: number, offset: number, length: number }[] = []
+    const inputs: Array<{ vin: number, offset: number, length: number }> = []
+    const outputs: Array<{ vout: number, offset: number, length: number }> = []
 
     br.pos += 4 // version
     const inputsLength = br.readVarIntNum()

package/src/transaction/broadcasters/ARC.ts

@@ -1,5 +1,7 @@
 import { BroadcastResponse, BroadcastFailure, Broadcaster } from '../Broadcaster.js'
 import Transaction from '../Transaction.js'
+import {HttpClient} from "./HttpClient.js";
+import defaultHttpClient from "./DefaultHttpClient.js";
 
 /**
  * Represents an ARC transaction broadcaster.
@@ -7,16 +9,19 @@ import Transaction from '../Transaction.js'
 export default class ARC implements Broadcaster {
   URL: string
   apiKey: string
+  private httpClient: HttpClient;
 
   /**
    * 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) {
+  constructor (URL: string, apiKey: string, httpClient: HttpClient = defaultHttpClient()) {
     this.URL = URL
     this.apiKey = apiKey
+    this.httpClient = httpClient
   }
 
   /**
@@ -48,23 +53,8 @@ export default class ARC implements Broadcaster {
     }
 
     try {
-      let response
-      let data: any = {}
-
-      if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
-        // Use fetch in a browser environment
-        response = await window.fetch(`${this.URL}/v1/tx`, requestOptions)
-        data = await response.json()
-      } else if (typeof require !== 'undefined') {
-        // Use Node.js https module
-        // eslint-disable-next-line
-        const https = require('https')
-        response = await this.nodeFetch(https, requestOptions)
-        data = JSON.parse(response)
-      } else {
-        throw new Error('No method available to perform HTTP request')
-      }
-
+      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) {
         return {
           status: 'success',
@@ -88,28 +78,4 @@ export default class ARC implements Broadcaster {
       }
     }
   }
-
-  /** Helper function for Node.js HTTPS requests */
-  private async nodeFetch (https, requestOptions): Promise<any> {
-    return await new Promise((resolve, reject) => {
-      const req = https.request(`${this.URL}/v1/tx`, 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()
-    })
-  }
 }

package/src/transaction/broadcasters/DefaultHttpClient.ts

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

package/src/transaction/broadcasters/HttpClient.ts

@@ -0,0 +1,34 @@
+/**
+ * An interface for HTTP client used by ARC to make HTTP requests.
+ */
+export interface HttpClient {
+    /**
+     * Makes a request to the server.
+     * @param url The URL to make the request to.
+     * @param options The request configuration.
+     */
+    fetch(url: string, options: HttpClientRequestOptions): Promise<HttpClientResponse>
+}
+
+/**
+ * An interface for configuration of the request to be passed to the fetch method.
+ */
+export interface HttpClientRequestOptions {
+    /** A string to set request's method. */
+    method?: string;
+    /** An object literal set request's headers. */
+    headers?: Record<string, string>;
+    /** An object or null to set request's body. */
+    body?: string | null;
+}
+
+/**
+ * An interface for the response returned by the fetch method.
+ */
+export interface HttpClientResponse {
+    /** The status code of the response. */
+    statusCode?: number;
+    /** A flag indicating whether the request ends with success status or not. */
+    ok?: boolean;
+    json(): Promise<any>;
+}

package/src/transaction/broadcasters/NodejsHttpClient.ts

@@ -0,0 +1,55 @@
+import {HttpClient, HttpClientRequestOptions, HttpClientResponse} from "./HttpClient.js";
+
+/** Node.js Https module interface limited to options needed by ts-sdk */
+export interface HttpsNodejs {
+    request(url: string, options: HttpClientRequestOptions, callback: (res: any) => void): NodejsHttpClientRequest;
+}
+
+/** Nodejs result of the Node.js https.request call limited to options needed by ts-sdk */
+export interface NodejsHttpClientRequest {
+    write(chunk: string): void;
+
+    end(): void;
+
+    on(event: string, callback: (data: any) => void): void;
+
+    end(): void;
+}
+
+/**
+ * Adapter for Node.js Https module to be used as HttpClient
+ */
+export class NodejsHttpClient implements HttpClient {
+    constructor(private https: HttpsNodejs) {
+    }
+
+    async fetch(url: string, requestOptions: HttpClientRequestOptions): Promise<HttpClientResponse> {
+        return await new Promise((resolve, reject) => {
+            const req = this.https.request(url, requestOptions, res => {
+                let data = ''
+                res.on('data', (chunk: string) => {
+                    data += chunk
+                })
+                res.on('end', () => {
+                    resolve({
+                        ok: res.statusCode >= 200 && res.statusCode <= 299,
+                        statusCode: res.statusCode,
+                        async json() {
+                            return JSON.parse(data)
+                        }
+                    })
+                })
+            })
+
+            req.on('error', error => {
+                reject(error)
+            })
+
+            if (!!requestOptions.body) {
+                req.write(requestOptions.body)
+            }
+            req.end()
+        })
+    }
+}
+

package/src/transaction/broadcasters/__tests/ARC.test.ts

@@ -1,5 +1,6 @@
 import ARC from '../../../../dist/cjs/src/transaction/broadcasters/ARC.js'
 import Transaction from '../../../../dist/cjs/src/transaction/Transaction.js'
+import {NodejsHttpClient} from "../NodejsHttpClient";
 
 // Mock Transaction
 jest.mock('../../Transaction', () => {
@@ -15,26 +16,24 @@ jest.mock('../../Transaction', () => {
 describe('ARC Broadcaster', () => {
   const URL = 'https://example.com'
   const apiKey = 'test_api_key'
-  let broadcaster: ARC
+  const successResponse = {
+    txid: 'mocked_txid',
+    txStatus: 'success',
+    extraInfo: 'received'
+  }
+
   let transaction: Transaction
 
   beforeEach(() => {
-    broadcaster = new ARC(URL, apiKey)
     transaction = new Transaction()
   })
 
   it('should broadcast successfully using window.fetch', async () => {
     // Mocking window.fetch
-    const mockFetch = jest.fn().mockResolvedValue({
-      ok: true,
-      json: async () => await Promise.resolve({
-        txid: 'mocked_txid',
-        txStatus: 'success',
-        extraInfo: 'received'
-      })
-    })
+    const mockFetch = mockedFetch(successResponse)
     global.window = { fetch: mockFetch } as any
 
+    const broadcaster = new ARC(URL, apiKey)
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -47,29 +46,39 @@ describe('ARC Broadcaster', () => {
 
   it('should broadcast successfully using Node.js https', async () => {
     // Mocking Node.js https module
-    jest.mock('https', () => ({
-      request: (url, options, callback) => {
-        // eslint-disable-next-line
-        callback({
-          statusCode: 200,
-          on: (event, handler) => {
-            if (event === 'data') handler(JSON.stringify({
-              txid: 'mocked_txid',
-              txStatus: 'success',
-              extraInfo: 'received'
-            }))
-            if (event === 'end') handler()
-          }
-        })
-        return {
-          on: jest.fn(),
-          write: jest.fn(),
-          end: jest.fn()
-        }
-      }
-    }))
-
+    mockedHttps(successResponse)
     delete global.window
+
+    const broadcaster = new ARC(URL, apiKey)
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should broadcast successfully using provided fetch', async () => {
+
+    const mockFetch = mockedFetch(successResponse)
+
+    const broadcaster = new ARC(URL, apiKey, { fetch: mockFetch })
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should broadcast successfully using provided https', async () => {
+
+    const mockHttps = mockedHttps(successResponse)
+    const broadcaster = new ARC(URL, apiKey, new NodejsHttpClient(mockHttps))
+
     const response = await broadcaster.broadcast(transaction)
 
     expect(response).toEqual({
@@ -83,6 +92,7 @@ describe('ARC Broadcaster', () => {
     const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
     global.window = { fetch: mockFetch } as any
 
+    const broadcaster = new ARC(URL, apiKey)
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -94,15 +104,13 @@ describe('ARC Broadcaster', () => {
   })
 
   it('should handle non-200 responses', async () => {
-    const mockFetch = jest.fn().mockResolvedValue({
-      ok: false,
-      json: async () => await Promise.resolve({
-        status: '400',
-        detail: 'Bad request'
-      })
+    const mockFetch = mockedFetch({
+      status: '400',
+      detail: 'Bad request'
     })
     global.window = { fetch: mockFetch } as any
 
+    const broadcaster = new ARC(URL, apiKey)
     const response = await broadcaster.broadcast(transaction)
 
     expect(mockFetch).toHaveBeenCalled()
@@ -112,4 +120,34 @@ describe('ARC Broadcaster', () => {
       description: 'Bad request'
     })
   })
+
+  function mockedFetch(response) {
+    return jest.fn().mockResolvedValue({
+      ok: response.status === '200',
+      json: async () => response
+    });
+  }
+
+  function mockedHttps(response) {
+    const https = {
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: 200,
+          on: (event, handler) => {
+            if (event === 'data') handler(JSON.stringify(response))
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+    jest.mock('https', () => https)
+    return https
+  }
 })
+

package/src/transaction/broadcasters/index.ts

@@ -1 +1,5 @@
 export { default as ARC } from './ARC.js'
+export type { HttpClient, HttpClientResponse, HttpClientRequestOptions } from './HttpClient.js'
+export { default as defaultHttpClient } from './DefaultHttpClient.js'
+export { NodejsHttpClient } from './NodejsHttpClient.js'
+export type { HttpsNodejs, NodejsHttpClientRequest } from './NodejsHttpClient.js'