x402-bch-axios 1.0.0 → 1.1.1

package/README.md

@@ -1,7 +1,61 @@
 # x402-bch-axios
 
-This is a placeholder for what will become the x402-bch-axios library.
+JavaScript helpers for handling HTTP 402 responses against Bitcoin Cash powered
+x402 endpoints. This package ports the `withPaymentInterceptor` experience from
+the TypeScript `x402-axios` client and adapts it for BCH UTXO payments.
 
-# Licence
+## Installation
+
+```bash
+npm install x402-bch-axios minimal-slp-wallet axios
+```
+
+The library depends on `minimal-slp-wallet` and assumes you are using ESM
+(`type: module`) in your project.
+
+## Usage
+
+```javascript
+import axios from 'axios'
+import {
+  createSigner,
+  withPaymentInterceptor
+} from 'x402-bch-axios'
+
+const signer = createSigner(process.env.PRIVATE_KEY_WIF, 2000)
+
+const api = withPaymentInterceptor(
+  axios.create({ baseURL: 'https://example.com' }),
+  signer,
+  // Optional payment requirements selector; defaults to BCH utxo
+  undefined,
+  // Optional BCH wallet config matching minimal-slp-wallet expectations
+  {
+    apiType: 'consumer-api',
+    bchServerURL: 'https://free-bch.fullstack.cash'
+  }
+)
+
+// Get data from an endpoint that requires 402 payment for access.
+const response = await api.get('/weather')
+console.log(response.data)
+```
+
+## API
+
+- `createSigner(privateKeyWIF, paymentAmountSats)` — build a BCH signer used to
+  sign x402 payment payloads and control default spend amounts.
+- `withPaymentInterceptor(axiosInstance, signer, selector?, config?)` — attach
+  an interceptor that:
+  - waits for a 402 response,
+  - selects the BCH `utxo` payment requirement (or uses your selector),
+  - funds or reuses a tracked UTXO,
+  - replays the request with the `X-PAYMENT` header.
+- `selectPaymentRequirements(accepts)` — utility for filtering BCH
+  requirements.
+- `createPaymentHeader(...)` — exposed for advanced integrations that need
+  direct x402 payload handling.
+
+## Licence
 
 [MIT](LICENSE.md)

package/index.js

@@ -1,23 +1,268 @@
 /*
-  An npm JavaScript library for front end web apps. Implements a minimal
-  Bitcoin Cash wallet.
+  x402-bch-axios
+
+  A BCH-focused port of the x402 Axios interceptor. The API mirrors the
+  TypeScript `withPaymentInterceptor` experience but intentionally omits
+  multi-network support and config typings that are not relevant for BCH.
+
+  Differences from the TypeScript implementation:
+  - Only supports BCH `utxo` payment requirements and BCH signers.
+  - Accepts an optional BCH server config instead of the generic `X402Config`.
+  - Does not expose multi-network signer helpers or type exports.
 */
 
-/* eslint-disable no-async-promise-executor */
+// External dependencies
+import BCHWallet from 'minimal-slp-wallet'
+import RetryQueue from '@chris.troutner/retry-queue'
+
+const dependencies = {
+  BCHWallet,
+  RetryQueue
+}
+
+export function __setDependencies (overrides = {}) {
+  Object.assign(dependencies, overrides)
+}
+
+export function __resetDependencies () {
+  dependencies.BCHWallet = BCHWallet
+  dependencies.RetryQueue = RetryQueue
+}
+
+const currentUtxo = {
+  txid: null,
+  vout: null,
+  satsLeft: 0
+}
+
+/**
+ * Creates a BCH signer from a private key in WIF format.
+ *
+ * @param {string} privateKeyWIF - Private key in Wallet Import Format (WIF)
+ * @param {number} paymentAmountSats - Default spend amount for queued payments
+ * @returns {{ ecpair: any, address: string, wif: string, paymentAmountSats: number, signMessage: (message: string) => string }}
+ */
+export function createSigner (privateKeyWIF, paymentAmountSats) {
+  const wallet = new dependencies.BCHWallet()
+  const bchjs = wallet.bchjs
+
+  const ecpair = bchjs.ECPair.fromWIF(privateKeyWIF)
+  const address = bchjs.ECPair.toCashAddress(ecpair)
+
+  return {
+    ecpair,
+    address,
+    wif: privateKeyWIF,
+    paymentAmountSats,
+    signMessage (message) {
+      return bchjs.BitcoinCash.signMessageWithPrivKey(privateKeyWIF, message)
+    }
+  }
+}
+
+export const createBCHSigner = createSigner
+
+/**
+ * Selects BCH `utxo` payment requirements from a 402 accepts array.
+ *
+ * @param {Array} accepts - Array of payment requirements objects
+ * @returns {Object} First BCH `utxo` payment requirement
+ */
+export function selectPaymentRequirements (accepts = []) {
+  const bchRequirements = accepts.filter(req => {
+    return req?.network === 'bch' && req?.scheme === 'utxo'
+  })
+
+  if (bchRequirements.length === 0) {
+    throw new Error('No BCH payment requirements found in 402 response')
+  }
+
+  return bchRequirements[0]
+}
+
+/**
+ * Builds the X-PAYMENT header payload for BCH transfers.
+ *
+ * @param {ReturnType<typeof createSigner>} signer
+ * @param {Object} paymentRequirements
+ * @param {number} x402Version
+ * @param {string|null} txid
+ * @param {number|null} vout
+ * @returns {Promise<string>}
+ */
+export async function createPaymentHeader (
+  signer,
+  paymentRequirements,
+  x402Version = 1,
+  txid = null,
+  vout = null
+) {
+  const authorization = {
+    from: signer.address,
+    to: paymentRequirements.payTo,
+    value: paymentRequirements.minAmountRequired,
+    txid,
+    vout,
+    amount: signer.paymentAmountSats
+  }
+
+  const messageToSign = JSON.stringify(authorization)
+  const signature = signer.signMessage(messageToSign)
+
+  const paymentHeader = {
+    x402Version,
+    scheme: paymentRequirements.scheme || 'utxo',
+    network: paymentRequirements.network || 'bch',
+    payload: {
+      signature,
+      authorization
+    }
+  }
+
+  return JSON.stringify(paymentHeader)
+}
+
+async function sendPayment (signer, paymentRequirements, bchServerConfig = {}) {
+  const { apiType, bchServerURL } = bchServerConfig
+  const paymentAmountSats = signer.paymentAmountSats || paymentRequirements.minAmountRequired
+
+  const bchWallet = new dependencies.BCHWallet(signer.wif, {
+    interface: apiType,
+    restURL: bchServerURL
+  })
+  await bchWallet.initialize()
 
-// Global npm libraries
-import BCHJS from '@psf/bch-js'
+  const retryQueue = new dependencies.RetryQueue()
+  const receivers = [
+    {
+      address: paymentRequirements.payTo,
+      amountSat: paymentAmountSats
+    }
+  ]
 
-// Local libraries
-import Util from './lib/util.js'
-const util = new Util()
+  const txid = await retryQueue.addToQueue(bchWallet.send.bind(bchWallet), receivers)
 
-class BoilerplateLib {
-  constructor () {
-    // Encapsulate dependencies
-    this.bchjs = new BCHJS()
-    this.util = util
+  return {
+    txid,
+    vout: 0,
+    satsSent: paymentAmountSats
   }
 }
 
-export default BoilerplateLib
+/**
+ * Adds a payment interceptor to an axios instance.
+ *
+ * @param {import('axios').AxiosInstance} axiosInstance
+ * @param {ReturnType<typeof createSigner>} signer
+ * @param {Function|Object} paymentRequirementsSelectorOrConfig - Optional selector or BCH server config
+ * @param {Object} maybeConfig - Optional BCH server config when a selector is provided
+ * @returns {import('axios').AxiosInstance}
+ */
+export function withPaymentInterceptor (
+  axiosInstance,
+  signer,
+  paymentRequirementsSelectorOrConfig,
+  maybeConfig
+) {
+  let paymentRequirementsSelector = selectPaymentRequirements
+  let bchServerConfig = {}
+
+  if (typeof paymentRequirementsSelectorOrConfig === 'function') {
+    paymentRequirementsSelector = paymentRequirementsSelectorOrConfig
+    if (maybeConfig) {
+      bchServerConfig = maybeConfig
+    }
+  } else if (paymentRequirementsSelectorOrConfig) {
+    bchServerConfig = paymentRequirementsSelectorOrConfig
+  }
+
+  axiosInstance.interceptors.response.use(
+    response => response,
+    async error => {
+      if (!error.response || error.response.status !== 402) {
+        return Promise.reject(error)
+      }
+
+      try {
+        const originalConfig = error.config
+        if (!originalConfig || !originalConfig.headers) {
+          return Promise.reject(new Error('Missing axios request configuration'))
+        }
+
+        if (originalConfig.__is402Retry) {
+          return Promise.reject(error)
+        }
+
+        const { x402Version, accepts } = error.response.data || {}
+        if (!accepts || !Array.isArray(accepts) || accepts.length === 0) {
+          return Promise.reject(new Error('No payment requirements found in 402 response'))
+        }
+
+        const paymentRequirements = paymentRequirementsSelector(accepts)
+        const cost = paymentRequirements.minAmountRequired
+
+        let txid = null
+        let vout = null
+        let satsLeft = null
+
+        if (!currentUtxo.txid || currentUtxo.satsLeft < cost) {
+          const payment = await internals.sendPayment(
+            signer,
+            paymentRequirements,
+            bchServerConfig
+          )
+          txid = payment.txid
+          vout = payment.vout
+          satsLeft = payment.satsSent - cost
+        } else {
+          txid = currentUtxo.txid
+          vout = currentUtxo.vout
+          satsLeft = currentUtxo.satsLeft - cost
+        }
+
+        currentUtxo.txid = txid
+        currentUtxo.vout = vout
+        currentUtxo.satsLeft = satsLeft
+
+        const paymentHeader = await createPaymentHeader(
+          signer,
+          paymentRequirements,
+          x402Version || 1,
+          txid,
+          vout
+        )
+
+        originalConfig.__is402Retry = true
+        originalConfig.headers['X-PAYMENT'] = paymentHeader
+        originalConfig.headers['Access-Control-Expose-Headers'] = 'X-PAYMENT-RESPONSE'
+
+        const secondResponse = await axiosInstance.request(originalConfig)
+        return secondResponse
+      } catch (paymentError) {
+        return Promise.reject(paymentError)
+      }
+    }
+  )
+
+  return axiosInstance
+}
+
+const internals = {
+  dependencies,
+  currentUtxo,
+  sendPayment
+}
+
+export function __resetCurrentUtxo () {
+  currentUtxo.txid = null
+  currentUtxo.vout = null
+  currentUtxo.satsLeft = 0
+}
+
+export function __resetInternals () {
+  internals.sendPayment = sendPayment
+  __resetDependencies()
+  __resetCurrentUtxo()
+}
+
+export const __internals = internals

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "x402-bch-axios",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Axios wrapper for x402 payment protocol with Bitcoin Cash (BCH) support.",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "start": "node index.js",
     "test": "npm run lint && TEST=unit c8 mocha test/unit/",
-    "test:integration": "mocha --timeout 25000 test/integration/",
     "lint": "standard --env mocha --fix",
-    "docs": "./node_modules/.bin/apidoc -i src/ -o docs",
     "coverage": "c8 --reporter=html mocha test/unit/ --exit"
   },
   "keywords": [
@@ -27,8 +25,8 @@
   },
   "repository": "x402-bch/x402-bch-axios",
   "dependencies": {
-    "@psf/bch-js": "6.8.3",
-    "apidoc": "1.2.0"
+    "@chris.troutner/retry-queue": "1.0.11",
+    "minimal-slp-wallet": "6.1.0"
   },
   "devDependencies": {
     "c8": "10.1.3",
@@ -36,7 +34,7 @@
     "husky": "9.1.7",
     "lodash.clonedeep": "4.5.0",
     "mocha": "11.7.5",
-    "semantic-release": "25.0.2",
+    "semantic-release": "19.0.3",
     "sinon": "21.0.0",
     "standard": "17.1.2"
   },

package/test/unit/index-unit.js

@@ -0,0 +1,302 @@
+/*
+  Unit tests for the index.js BCH Axios interceptor.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+import sinon from 'sinon'
+import cloneDeep from 'lodash.clonedeep'
+
+// Unit under test
+import {
+  createSigner,
+  selectPaymentRequirements,
+  createPaymentHeader,
+  withPaymentInterceptor,
+  __setDependencies,
+  __resetDependencies,
+  __resetInternals,
+  __internals
+} from '../../index.js'
+
+describe('#index.js', () => {
+  let sandbox
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    __resetInternals()
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+    __resetInternals()
+  })
+
+  describe('#createSigner', () => {
+    it('should create a signer with derived address and signer method', () => {
+      const mockEcpair = { ecpair: true }
+      const fromWIFStub = sandbox.stub().returns(mockEcpair)
+      const toCashAddressStub = sandbox.stub().returns('bitcoincash:qptest')
+      const signMessageStub = sandbox.stub().returns('signed-message')
+
+      const walletStub = sandbox.stub().returns({
+        bchjs: {
+          ECPair: {
+            fromWIF: fromWIFStub,
+            toCashAddress: toCashAddressStub
+          },
+          BitcoinCash: {
+            signMessageWithPrivKey: signMessageStub
+          }
+        }
+      })
+
+      __setDependencies({ BCHWallet: walletStub })
+
+      const signer = createSigner('test-wif', 1500)
+
+      assert.isTrue(walletStub.calledOnce)
+      assert.strictEqual(fromWIFStub.firstCall.args[0], 'test-wif')
+      assert.strictEqual(toCashAddressStub.firstCall.args[0], mockEcpair)
+
+      assert.equal(signer.address, 'bitcoincash:qptest')
+      assert.equal(signer.paymentAmountSats, 1500)
+      assert.equal(signer.wif, 'test-wif')
+      assert.strictEqual(signer.ecpair, mockEcpair)
+
+      const signature = signer.signMessage('message-to-sign')
+      assert.equal(signature, 'signed-message')
+      assert.deepEqual(signMessageStub.firstCall.args, ['test-wif', 'message-to-sign'])
+
+      __resetDependencies()
+    })
+  })
+
+  describe('#selectPaymentRequirements', () => {
+    it('should select the first BCH utxo requirement', () => {
+      const accepts = [
+        { network: 'eth', scheme: 'account' },
+        { network: 'bch', scheme: 'utxo', payTo: 'addr1' },
+        { network: 'bch', scheme: 'account' }
+      ]
+
+      const req = selectPaymentRequirements(accepts)
+      assert.deepEqual(req, { network: 'bch', scheme: 'utxo', payTo: 'addr1' })
+    })
+
+    it('should throw if no BCH utxo requirement exists', () => {
+      assert.throws(
+        () => selectPaymentRequirements([{ network: 'btc', scheme: 'utxo' }]),
+        /No BCH payment requirements/
+      )
+    })
+  })
+
+  describe('#createPaymentHeader', () => {
+    it('should build a valid payment header payload', async () => {
+      const signer = {
+        address: 'bitcoincash:qptest',
+        paymentAmountSats: 2000,
+        signMessage: sandbox.stub().returns('mock-signature')
+      }
+
+      const paymentRequirements = {
+        payTo: 'bitcoincash:qprecv',
+        minAmountRequired: 1500,
+        scheme: 'utxo',
+        network: 'bch'
+      }
+
+      const header = await createPaymentHeader(
+        signer,
+        paymentRequirements,
+        2,
+        'tx123',
+        0
+      )
+
+      const parsed = JSON.parse(header)
+      assert.deepEqual(parsed, {
+        x402Version: 2,
+        scheme: 'utxo',
+        network: 'bch',
+        payload: {
+          signature: 'mock-signature',
+          authorization: {
+            from: 'bitcoincash:qptest',
+            to: 'bitcoincash:qprecv',
+            value: 1500,
+            txid: 'tx123',
+            vout: 0,
+            amount: 2000
+          }
+        }
+      })
+      assert.isTrue(signer.signMessage.calledOnce)
+    })
+  })
+
+  describe('#withPaymentInterceptor', () => {
+    function createAxiosInstance () {
+      return {
+        interceptors: {
+          response: {
+            use: sandbox.stub()
+          }
+        },
+        request: sandbox.stub()
+      }
+    }
+
+    function createSignerStub () {
+      return {
+        address: 'bitcoincash:qptest',
+        paymentAmountSats: 2000,
+        signMessage: sandbox.stub().returns('signature')
+      }
+    }
+
+    const basePaymentRequirements = {
+      network: 'bch',
+      scheme: 'utxo',
+      payTo: 'bitcoincash:qprecv',
+      minAmountRequired: 1500
+    }
+
+    function create402Error (overrides = {}) {
+      const defaultError = {
+        response: {
+          status: 402,
+          data: {
+            x402Version: 1,
+            accepts: [cloneDeep(basePaymentRequirements)]
+          }
+        },
+        config: {
+          headers: {}
+        }
+      }
+      return Object.assign(defaultError, overrides)
+    }
+
+    it('should rethrow non-402 errors', async () => {
+      const axiosInstance = createAxiosInstance()
+      const signer = createSignerStub()
+
+      withPaymentInterceptor(axiosInstance, signer)
+
+      const [, errorHandler] = axiosInstance.interceptors.response.use.firstCall.args
+      const non402Error = { response: { status: 400 } }
+
+      try {
+        await errorHandler(non402Error)
+        assert.fail('Expected rejection')
+      } catch (err) {
+        assert.strictEqual(err, non402Error)
+      }
+    })
+
+    it('should reject when axios config headers are missing', async () => {
+      const axiosInstance = createAxiosInstance()
+      const signer = createSignerStub()
+
+      withPaymentInterceptor(axiosInstance, signer)
+
+      const [, errorHandler] = axiosInstance.interceptors.response.use.firstCall.args
+      const error = create402Error({
+        config: {}
+      })
+
+      try {
+        await errorHandler(error)
+        assert.fail('Expected rejection')
+      } catch (err) {
+        assert.match(err.message, /Missing axios request configuration/)
+      }
+    })
+
+    it('should reject when no payment requirements are provided', async () => {
+      const axiosInstance = createAxiosInstance()
+      const signer = createSignerStub()
+
+      withPaymentInterceptor(axiosInstance, signer)
+
+      const [, errorHandler] = axiosInstance.interceptors.response.use.firstCall.args
+      const error = create402Error({
+        response: { status: 402, data: { accepts: [] } }
+      })
+
+      try {
+        await errorHandler(error)
+        assert.fail('Expected rejection')
+      } catch (err) {
+        assert.match(err.message, /No payment requirements/)
+      }
+    })
+
+    it('should send payment, attach headers, and retry request', async () => {
+      const axiosInstance = createAxiosInstance()
+      const signer = createSignerStub()
+      signer.signMessage.returns('signed')
+
+      const sendPaymentStub = sandbox
+        .stub()
+        .resolves({ txid: 'tx123', vout: 0, satsSent: 2000 })
+      __internals.sendPayment = sendPaymentStub
+
+      axiosInstance.request.resolves({ data: 'ok' })
+
+      withPaymentInterceptor(axiosInstance, signer)
+
+      const [, errorHandler] = axiosInstance.interceptors.response.use.firstCall.args
+      const error = create402Error()
+
+      const response = await errorHandler(error)
+
+      assert.deepEqual(response, { data: 'ok' })
+      assert.isTrue(sendPaymentStub.calledOnce)
+      assert.isTrue(axiosInstance.request.calledOnce)
+
+      const updatedConfig = axiosInstance.request.firstCall.args[0]
+      assert.isTrue(updatedConfig.__is402Retry)
+      assert.property(updatedConfig.headers, 'X-PAYMENT')
+      assert.propertyVal(
+        updatedConfig.headers,
+        'Access-Control-Expose-Headers',
+        'X-PAYMENT-RESPONSE'
+      )
+
+      const headerPayload = JSON.parse(updatedConfig.headers['X-PAYMENT'])
+      assert.equal(headerPayload.payload.authorization.txid, 'tx123')
+      assert.equal(__internals.currentUtxo.txid, 'tx123')
+      assert.equal(__internals.currentUtxo.satsLeft, 500)
+    })
+
+    it('should reuse cached utxo when sufficient balance remains', async () => {
+      const axiosInstance = createAxiosInstance()
+      const signer = createSignerStub()
+      signer.signMessage.returns('signed')
+
+      __internals.currentUtxo.txid = 'cached'
+      __internals.currentUtxo.vout = 1
+      __internals.currentUtxo.satsLeft = 2_000
+
+      const sendPaymentStub = sandbox.stub()
+      __internals.sendPayment = sendPaymentStub
+
+      axiosInstance.request.resolves({ status: 200 })
+
+      withPaymentInterceptor(axiosInstance, signer)
+
+      const [, errorHandler] = axiosInstance.interceptors.response.use.firstCall.args
+      const error = create402Error()
+
+      const result = await errorHandler(error)
+      assert.deepEqual(result, { status: 200 })
+
+      assert.isTrue(sendPaymentStub.notCalled)
+      assert.equal(__internals.currentUtxo.txid, 'cached')
+      assert.equal(__internals.currentUtxo.satsLeft, 500)
+    })
+  })
+})

package/apidoc.json

@@ -1,3 +0,0 @@
-{
-  "sampleUrl": null
-}

package/lib/util.js

@@ -1,46 +0,0 @@
-/*
-  An example of a typical utility library. Things to notice:
-  - This library is exported as a Class.
-  - External dependencies are embedded into the class 'this' object: this.bchjs
-*/
-
-'use strict'
-
-// Global npm libraries
-import BCHJS from '@psf/bch-js'
-
-class UtilLib {
-  constructor () {
-    // Encapsulate dependencies
-    this.bchjs = new BCHJS()
-
-    // Bind 'this' object to all class methods
-    this.getBchData = this.getBchData.bind(this)
-  }
-
-  async getBchData (addr) {
-    try {
-      // Validate Input
-      if (typeof addr !== 'string') throw new Error('Address must be a string')
-
-      const balance = await this.bchjs.Electrumx.balance(addr)
-
-      const utxos = await this.bchjs.Electrumx.utxo(addr)
-
-      const bchData = {
-        balance: balance.balance,
-        utxos: utxos.utxos
-      }
-      // console.log(`bchData: ${JSON.stringify(bchData, null, 2)}`)
-
-      return bchData
-    } catch (err) {
-      // Optional log to indicate the source of the error. This would normally
-      // be written with a logging app like Winston.
-      console.log('Error in util.js/getBalance()')
-      throw err
-    }
-  }
-}
-
-export default UtilLib

package/test/integration/util-integration.js

@@ -1,33 +0,0 @@
-/*
-  Integration tests for the util.js utility library.
-*/
-
-// npm libraries
-import chai from 'chai'
-
-// Unit under test
-import UtilLib from '../../lib/util.js'
-
-// Locally global variables.
-const assert = chai.assert
-const uut = new UtilLib()
-
-describe('#util.js', () => {
-  describe('#getBchData', () => {
-    it('should get BCH data on an address', async () => {
-      const addr = 'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
-
-      const bchData = await uut.getBchData(addr)
-
-      // Assert that top-level properties exist.
-      assert.property(bchData, 'balance')
-      assert.property(bchData, 'utxos')
-
-      // Assert essential UTXOs properties exist.
-      assert.isArray(bchData.utxos)
-      assert.property(bchData.utxos[0], 'tx_pos')
-      assert.property(bchData.utxos[0], 'tx_hash')
-      assert.property(bchData.utxos[0], 'value')
-    })
-  })
-})

package/test/unit/mocks/util-mocks.js

@@ -1,30 +0,0 @@
-/*
-  A mocking library for util.js unit tests.
-  A mocking library contains data to use in place of the data that would come
-  from an external dependency.
-*/
-
-'use strict'
-
-const mockBalance = {
-  success: true,
-  balance: {
-    confirmed: 1000,
-    unconfirmed: 0
-  }
-}
-
-const mockUtxos = {
-  success: true,
-  utxos: [
-    {
-      height: 601861,
-      tx_hash:
-        '6181c669614fa18039a19b23eb06806bfece1f7514ab457c3bb82a40fe171a6d',
-      tx_pos: 0,
-      value: 1000
-    }
-  ]
-}
-
-export default { mockBalance, mockUtxos }

package/test/unit/util-unit.js

@@ -1,69 +0,0 @@
-/*
-  Unit tests for the util.js utility library.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-import sinon from 'sinon'
-import cloneDeep from 'lodash.clonedeep'
-
-// Mocking data libraries.
-import mockDataLib from './mocks/util-mocks.js'
-
-// Unit under test
-import UtilLib from '../../lib/util.js'
-
-describe('#util.js', () => {
-  let sandbox
-  let mockData
-  let uut
-
-  beforeEach(() => {
-    // Restore the sandbox before each test.
-    sandbox = sinon.createSandbox()
-
-    // Clone the mock data.
-    mockData = cloneDeep(mockDataLib)
-
-    uut = new UtilLib()
-  })
-
-  afterEach(() => sandbox.restore())
-
-  describe('#getBchData', () => {
-    it('should throw error if address is not a string', async () => {
-      try {
-        const addr = 1234
-
-        await uut.getBchData(addr)
-
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Address must be a string')
-      }
-    })
-
-    it('should get BCH data on an address', async () => {
-      // Mock external dependencies.
-      sandbox
-        .stub(uut.bchjs.Electrumx, 'balance')
-        .resolves(mockData.mockBalance)
-      sandbox.stub(uut.bchjs.Electrumx, 'utxo').resolves(mockData.mockUtxos)
-
-      const addr = 'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
-
-      const bchData = await uut.getBchData(addr)
-      // console.log(`bchData: ${JSON.stringify(bchData, null, 2)}`)
-
-      // Assert that top-level properties exist.
-      assert.property(bchData, 'balance')
-      assert.property(bchData, 'utxos')
-
-      // Assert essential UTXOs properties exist.
-      assert.isArray(bchData.utxos)
-      assert.property(bchData.utxos[0], 'tx_pos')
-      assert.property(bchData.utxos[0], 'tx_hash')
-      assert.property(bchData.utxos[0], 'value')
-    })
-  })
-})