x402-bch-axios 2.0.0 → 2.1.1

package/index.js

@@ -123,13 +123,16 @@ export async function createPaymentHeader (
   // Support both v1 (minAmountRequired) and v2 (amount) field names
   const amountRequired = paymentRequirements.amount || paymentRequirements.minAmountRequired
 
+  // Check if this is "check my tab" mode (txid === "*")
+  const isCheckMyTabMode = txid === '*'
+
   const authorization = {
     from: signer.address,
     to: paymentRequirements.payTo,
     value: amountRequired,
-    txid,
-    vout,
-    amount: signer.paymentAmountSats
+    txid: isCheckMyTabMode ? '*' : txid,
+    vout: isCheckMyTabMode ? null : vout,
+    amount: isCheckMyTabMode ? null : signer.paymentAmountSats
   }
 
   const messageToSign = JSON.stringify(authorization)
@@ -162,33 +165,57 @@ export async function createPaymentHeader (
 }
 
 async function sendPayment (signer, paymentRequirements, bchServerConfig = {}) {
-  const { apiType, bchServerURL } = bchServerConfig
-  // Support both v1 (minAmountRequired) and v2 (amount) field names
-  const amountRequired = paymentRequirements.amount || paymentRequirements.minAmountRequired
-  const paymentAmountSats = signer.paymentAmountSats || amountRequired
+  try {
+    const { apiType, bchServerURL } = bchServerConfig
+    // Support both v1 (minAmountRequired) and v2 (amount) field names
+    const amountRequired = paymentRequirements.amount || paymentRequirements.minAmountRequired
+    const paymentAmountSats = signer.paymentAmountSats || amountRequired
+
+    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 dependencies.RetryQueue()
+    const receivers = [
+      {
+        address: paymentRequirements.payTo,
+        amountSat: paymentAmountSats
+      }
+    ]
 
-  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 dependencies.RetryQueue()
-  const receivers = [
-    {
-      address: paymentRequirements.payTo,
-      amountSat: paymentAmountSats
+    // Wrap send function to detect "Insufficient balance" errors
+    const sendWithRetry = async (receivers) => {
+      try {
+        return await bchWallet.send(receivers)
+      } catch (error) {
+        // Check if error message contains "Insufficient balance"
+        if (error.message && error.message.includes('Insufficient balance')) {
+          return null
+        }
+
+        // Re-throw other errors normally (will be retried)
+        throw error
+      }
     }
-  ]
 
-  const txid = await retryQueue.addToQueue(bchWallet.send.bind(bchWallet), receivers)
+    const txid = await retryQueue.addToQueue(sendWithRetry, receivers)
 
-  return {
-    txid,
-    vout: 0,
-    satsSent: paymentAmountSats
+    if (txid === null) {
+      throw new Error('Insufficient balance')
+    }
+
+    return {
+      txid,
+      vout: 0,
+      satsSent: paymentAmountSats
+    }
+  } catch (err) {
+    console.error('Error in x402-bch-axios/sendPayment(): ', err.message)
+    throw err
   }
 }
 
@@ -232,10 +259,17 @@ export function withPaymentInterceptor (
           return Promise.reject(new Error('Missing axios request configuration'))
         }
 
+        // Prevent infinite loops
         if (originalConfig.__is402Retry) {
           return Promise.reject(error)
         }
 
+        // If this is a "check my tab" retry that failed, fall back to UTXO generation
+        if (originalConfig.__is402CheckMyTab) {
+          // Clear the flag and proceed with UTXO generation
+          originalConfig.__is402CheckMyTab = false
+        }
+
         // Parse payment requirements - v2 can come from header, v1 from body
         let paymentRequired = null
         let x402Version = 1
@@ -277,6 +311,45 @@ export function withPaymentInterceptor (
         // Convert to number for calculations (v2 uses strings, v1 uses numbers)
         const cost = Number(paymentRequirements.amount || paymentRequirements.minAmountRequired)
 
+        // Try "check my tab" mode first if no UTXO is tracked
+        if (!currentUtxo.txid && !originalConfig.__is402CheckMyTab) {
+          // Attempt "check my tab" mode
+          const checkMyTabHeader = await createPaymentHeader(
+            signer,
+            paymentRequirements,
+            x402Version || 2,
+            '*', // txid = "*" for check my tab mode
+            null, // vout = null for check my tab mode
+            resource,
+            extensions
+          )
+
+          originalConfig.__is402CheckMyTab = true
+          originalConfig.__is402Retry = true
+          originalConfig.headers['PAYMENT-SIGNATURE'] = checkMyTabHeader
+          originalConfig.headers['Access-Control-Expose-Headers'] = 'PAYMENT-RESPONSE'
+
+          try {
+            const checkMyTabResponse = await axiosInstance.request(originalConfig)
+            // "Check my tab" succeeded - return response and continue using check my tab mode
+            // Don't update currentUtxo since we're using check my tab mode
+            return checkMyTabResponse
+          } catch (checkMyTabError) {
+            // "Check my tab" failed - check if it's a 402 error
+            if (checkMyTabError.response && checkMyTabError.response.status === 402) {
+              // 402 error from "check my tab" - fall back to UTXO generation
+              // Reset flags and continue with standard flow
+              originalConfig.__is402CheckMyTab = false
+              originalConfig.__is402Retry = false
+              // Continue to UTXO generation logic below
+            } else {
+              // Non-402 error (network error, etc.) - reject it
+              return Promise.reject(checkMyTabError)
+            }
+          }
+        }
+
+        // Standard mode: use existing UTXO or generate new one
         let txid = null
         let vout = null
         let satsLeft = null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402-bch-axios",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Axios wrapper for x402 payment protocol with Bitcoin Cash (BCH) support.",
   "main": "index.js",
   "type": "module",
@@ -26,7 +26,7 @@
   "repository": "x402-bch/x402-bch-axios",
   "dependencies": {
     "@chris.troutner/retry-queue": "1.0.11",
-    "minimal-slp-wallet": "7.0.2"
+    "minimal-slp-wallet": "7.0.5"
   },
   "devDependencies": {
     "c8": "10.1.3",

package/test/unit/index-unit.js

@@ -315,7 +315,12 @@ describe('#index.js', () => {
         .resolves({ txid: 'tx123', vout: 0, satsSent: 2000 })
       __internals.sendPayment = sendPaymentStub
 
-      axiosInstance.request.resolves({ data: 'ok' })
+      // First call (check my tab) returns 402, second call (with UTXO) succeeds
+      axiosInstance.request
+        .onFirstCall()
+        .rejects(create402Error())
+        .onSecondCall()
+        .resolves({ data: 'ok' })
 
       withPaymentInterceptor(axiosInstance, signer)
 
@@ -326,9 +331,10 @@ describe('#index.js', () => {
 
       assert.deepEqual(response, { data: 'ok' })
       assert.isTrue(sendPaymentStub.calledOnce)
-      assert.isTrue(axiosInstance.request.calledOnce)
+      assert.isTrue(axiosInstance.request.calledTwice)
 
-      const updatedConfig = axiosInstance.request.firstCall.args[0]
+      // Check the second call (with UTXO) - first call was check my tab
+      const updatedConfig = axiosInstance.request.secondCall.args[0]
       assert.isTrue(updatedConfig.__is402Retry)
       assert.property(updatedConfig.headers, 'PAYMENT-SIGNATURE')
       assert.propertyVal(
@@ -382,7 +388,22 @@ describe('#index.js', () => {
         .resolves({ txid: 'tx123', vout: 0, satsSent: 2000 })
       __internals.sendPayment = sendPaymentStub
 
-      axiosInstance.request.resolves({ data: 'ok' })
+      // First call (check my tab) returns 402, second call (with UTXO) succeeds
+      axiosInstance.request
+        .onFirstCall()
+        .rejects({
+          response: {
+            status: 402,
+            headers: {},
+            data: {
+              x402Version: 2,
+              accepts: [cloneDeep(basePaymentRequirements)]
+            }
+          },
+          config: { headers: {} }
+        })
+        .onSecondCall()
+        .resolves({ data: 'ok' })
 
       withPaymentInterceptor(axiosInstance, signer)
 
@@ -414,9 +435,10 @@ describe('#index.js', () => {
 
       assert.deepEqual(response, { data: 'ok' })
       assert.isTrue(sendPaymentStub.calledOnce)
-      assert.isTrue(axiosInstance.request.calledOnce)
+      assert.isTrue(axiosInstance.request.calledTwice)
 
-      const updatedConfig = axiosInstance.request.firstCall.args[0]
+      // Check the second call (with UTXO) - first call was check my tab
+      const updatedConfig = axiosInstance.request.secondCall.args[0]
       const headerPayload = JSON.parse(updatedConfig.headers['PAYMENT-SIGNATURE'])
       assert.equal(headerPayload.x402Version, 2)
       assert.deepEqual(headerPayload.resource, baseResource)
@@ -432,7 +454,27 @@ describe('#index.js', () => {
         .resolves({ txid: 'tx123', vout: 0, satsSent: 2000 })
       __internals.sendPayment = sendPaymentStub
 
-      axiosInstance.request.resolves({ data: 'ok' })
+      // First call (check my tab) returns 402, second call (with UTXO) succeeds
+      axiosInstance.request
+        .onFirstCall()
+        .rejects({
+          response: {
+            status: 402,
+            headers: {},
+            data: {
+              x402Version: 1,
+              accepts: [{
+                network: 'bch',
+                scheme: 'utxo',
+                payTo: 'bitcoincash:qprecv',
+                minAmountRequired: 1500
+              }]
+            }
+          },
+          config: { headers: {} }
+        })
+        .onSecondCall()
+        .resolves({ data: 'ok' })
 
       withPaymentInterceptor(axiosInstance, signer)
 
@@ -464,4 +506,343 @@ describe('#index.js', () => {
       assert.isTrue(sendPaymentStub.calledOnce)
     })
   })
+
+  describe('#sendPayment', () => {
+    function createSignerStub () {
+      return {
+        wif: 'test-wif',
+        paymentAmountSats: 2000,
+        address: 'bitcoincash:qptest'
+      }
+    }
+
+    function createPaymentRequirementsStub () {
+      return {
+        payTo: 'bitcoincash:qprecv',
+        amount: '1500',
+        scheme: 'utxo',
+        network: 'bip122:000000000000000000651ef99cb9fcbe'
+      }
+    }
+
+    it('should successfully send payment and return txid, vout, and satsSent', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://api.example.com'
+      }
+
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().resolves('tx123')
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves('tx123')
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      const result = await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+
+      assert.deepEqual(result, {
+        txid: 'tx123',
+        vout: 0,
+        satsSent: 2000
+      })
+
+      assert.isTrue(BCHWalletStub.calledOnce)
+      assert.deepEqual(BCHWalletStub.firstCall.args[0], 'test-wif')
+      assert.deepEqual(BCHWalletStub.firstCall.args[1], {
+        interface: 'rest-api',
+        restURL: 'https://api.example.com'
+      })
+      assert.isTrue(mockBchWallet.initialize.calledOnce)
+      assert.isTrue(RetryQueueStub.calledOnce)
+      assert.isTrue(mockRetryQueue.addToQueue.calledOnce)
+
+      // Verify sendWithRetry was called with receivers
+      const sendWithRetry = mockRetryQueue.addToQueue.firstCall.args[0]
+      const receivers = mockRetryQueue.addToQueue.firstCall.args[1]
+      assert.isFunction(sendWithRetry)
+      assert.deepEqual(receivers, [{
+        address: 'bitcoincash:qprecv',
+        amountSat: 2000
+      }])
+
+      __resetDependencies()
+    })
+
+    it('should throw "Insufficient balance" error when sendWithRetry returns null', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {}
+
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().rejects(new Error('Insufficient balance'))
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves(null) // sendWithRetry returns null for insufficient balance
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+        assert.fail('Expected "Insufficient balance" error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Insufficient balance')
+      }
+
+      // Verify sendWithRetry was called and handled the error
+      assert.isTrue(mockRetryQueue.addToQueue.calledOnce)
+      const sendWithRetry = mockRetryQueue.addToQueue.firstCall.args[0]
+
+      // Test sendWithRetry directly to verify it returns null for insufficient balance
+      try {
+        const result = await sendWithRetry([{ address: 'test', amountSat: 1000 }])
+        assert.strictEqual(result, null)
+      } catch (err) {
+        assert.fail('sendWithRetry should return null, not throw')
+      }
+
+      __resetDependencies()
+    })
+
+    it('should handle "Insufficient balance" error in sendWithRetry wrapper', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+
+      const insufficientBalanceError = new Error('Insufficient balance')
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().rejects(insufficientBalanceError)
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().callsFake(async (fn, args) => {
+          // Simulate what RetryQueue does - call the function
+          return await fn(args)
+        })
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements)
+        assert.fail('Expected "Insufficient balance" error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Insufficient balance')
+      }
+
+      // Verify that sendWithRetry was called and returned null
+      assert.isTrue(mockRetryQueue.addToQueue.calledOnce)
+      const sendWithRetry = mockRetryQueue.addToQueue.firstCall.args[0]
+      const receivers = mockRetryQueue.addToQueue.firstCall.args[1]
+
+      // Call sendWithRetry directly to verify it returns null
+      const result = await sendWithRetry(receivers)
+      assert.strictEqual(result, null)
+
+      __resetDependencies()
+    })
+
+    it('should re-throw other errors from sendWithRetry for retry queue to handle', async () => {
+      const networkError = new Error('Network timeout')
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().rejects(networkError)
+      }
+
+      // RetryQueue should eventually succeed after retries
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves('tx456')
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      // Test sendWithRetry directly to verify it re-throws non-insufficient-balance errors
+      const receivers = [{ address: 'test', amountSat: 1000 }]
+
+      // Extract sendWithRetry by simulating what happens in sendPayment
+      const sendWithRetry = async (receivers) => {
+        try {
+          return await mockBchWallet.send(receivers)
+        } catch (error) {
+          if (error.message && error.message.includes('Insufficient balance')) {
+            return null
+          }
+          throw error
+        }
+      }
+
+      // Verify that sendWithRetry re-throws non-insufficient-balance errors
+      try {
+        await sendWithRetry(receivers)
+        assert.fail('Expected network error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Network timeout')
+      }
+
+      // Verify that send was called
+      assert.isTrue(mockBchWallet.send.calledOnce)
+
+      __resetDependencies()
+    })
+
+    it('should use paymentAmountSats from signer when available', async () => {
+      const signer = createSignerStub()
+      signer.paymentAmountSats = 5000
+      const paymentRequirements = createPaymentRequirementsStub()
+
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().resolves('tx789')
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves('tx789')
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      await __internals.sendPayment(signer, paymentRequirements)
+
+      const receivers = mockRetryQueue.addToQueue.firstCall.args[1]
+      assert.equal(receivers[0].amountSat, 5000)
+
+      __resetDependencies()
+    })
+
+    it('should use amountRequired from paymentRequirements when signer.paymentAmountSats is not set', async () => {
+      const signer = createSignerStub()
+      delete signer.paymentAmountSats
+      const paymentRequirements = createPaymentRequirementsStub()
+      paymentRequirements.amount = '3000'
+
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().resolves('tx999')
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves('tx999')
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      await __internals.sendPayment(signer, paymentRequirements)
+
+      const receivers = mockRetryQueue.addToQueue.firstCall.args[1]
+      assert.equal(receivers[0].amountSat, '3000')
+
+      __resetDependencies()
+    })
+
+    it('should only match "Insufficient balance" error message (case-sensitive)', async () => {
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().rejects(new Error('INSUFFICIENT BALANCE'))
+      }
+
+      // Test sendWithRetry directly
+      const sendWithRetry = async (receivers) => {
+        try {
+          return await mockBchWallet.send(receivers)
+        } catch (error) {
+          if (error.message && error.message.includes('Insufficient balance')) {
+            return null
+          }
+          throw error
+        }
+      }
+
+      const receivers = [{ address: 'test', amountSat: 1000 }]
+
+      // This should NOT return null because the error message doesn't match (case-sensitive check)
+      // The includes() method is case-sensitive, so 'INSUFFICIENT BALANCE' won't match 'Insufficient balance'
+      try {
+        const result = await sendWithRetry(receivers)
+        // If it returns null, that's unexpected
+        if (result === null) {
+          assert.fail('Should not return null for case-mismatched error message')
+        }
+      } catch (err) {
+        // Expected - error should be re-thrown because it doesn't match
+        assert.equal(err.message, 'INSUFFICIENT BALANCE')
+      }
+
+      __resetDependencies()
+    })
+
+    it('should propagate errors from wallet initialization', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+
+      const initError = new Error('Failed to initialize wallet')
+      const mockBchWallet = {
+        initialize: sandbox.stub().rejects(initError),
+        send: sandbox.stub()
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub()
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements)
+        assert.fail('Expected initialization error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Failed to initialize wallet')
+      }
+
+      assert.isTrue(mockBchWallet.initialize.calledOnce)
+      assert.isTrue(RetryQueueStub.notCalled)
+
+      __resetDependencies()
+    })
+  })
 })