x402-bch-axios 1.1.0 → 1.1.2

package/README.md

@@ -36,7 +36,8 @@ const api = withPaymentInterceptor(
   }
 )
 
-const response = await api.get('/premium-endpoint')
+// Get data from an endpoint that requires 402 payment for access.
+const response = await api.get('/weather')
 console.log(response.data)
 ```
 

package/index.js

@@ -15,6 +15,20 @@
 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,
@@ -29,7 +43,7 @@ const currentUtxo = {
  * @returns {{ ecpair: any, address: string, wif: string, paymentAmountSats: number, signMessage: (message: string) => string }}
  */
 export function createSigner (privateKeyWIF, paymentAmountSats) {
-  const wallet = new BCHWallet()
+  const wallet = new dependencies.BCHWallet()
   const bchjs = wallet.bchjs
 
   const ecpair = bchjs.ECPair.fromWIF(privateKeyWIF)
@@ -83,9 +97,6 @@ export async function createPaymentHeader (
   txid = null,
   vout = null
 ) {
-  const wallet = new BCHWallet()
-  await wallet.walletInfoPromise
-
   const authorization = {
     from: signer.address,
     to: paymentRequirements.payTo,
@@ -115,13 +126,15 @@ async function sendPayment (signer, paymentRequirements, bchServerConfig = {}) {
   const { apiType, bchServerURL } = bchServerConfig
   const paymentAmountSats = signer.paymentAmountSats || paymentRequirements.minAmountRequired
 
-  const bchWallet = new BCHWallet(signer.wif, {
+  const bchWallet = new dependencies.BCHWallet(signer.wif, {
     interface: apiType,
     restURL: bchServerURL
   })
+  // console.log(`sendPayment() - interface: ${apiType}, restURL: ${bchServerURL}, wif: ${signer.wif}, payTo: ${paymentRequirements.payTo}, paymentAmountSats: ${paymentAmountSats}`)
+  console.log(`Sending ${paymentAmountSats} for x402 API payment to ${paymentRequirements.payTo}`)
   await bchWallet.initialize()
 
-  const retryQueue = new RetryQueue()
+  const retryQueue = new dependencies.RetryQueue()
   const receivers = [
     {
       address: paymentRequirements.payTo,
@@ -195,7 +208,11 @@ export function withPaymentInterceptor (
         let satsLeft = null
 
         if (!currentUtxo.txid || currentUtxo.satsLeft < cost) {
-          const payment = await sendPayment(signer, paymentRequirements, bchServerConfig)
+          const payment = await internals.sendPayment(
+            signer,
+            paymentRequirements,
+            bchServerConfig
+          )
           txid = payment.txid
           vout = payment.vout
           satsLeft = payment.satsSent - cost
@@ -231,3 +248,23 @@ export function withPaymentInterceptor (
 
   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,6 +1,6 @@
 {
   "name": "x402-bch-axios",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Axios wrapper for x402 payment protocol with Bitcoin Cash (BCH) support.",
   "main": "index.js",
   "type": "module",
@@ -25,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": "7.0.2"
   },
   "devDependencies": {
     "c8": "10.1.3",

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/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')
-    })
-  })
-})