x402-bch-axios 2.1.0 → 2.2.0

package/index.js

@@ -164,34 +164,183 @@ export async function createPaymentHeader (
   return JSON.stringify(paymentHeader)
 }
 
-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
+// Send the payment using bch.fullstack.cash. In this case, we can use bch-js to execute
+// the payment in a more optimized way.
+// Assumption: A UTXO that is equal to or larger than paymentAmountSats is not a SLP token UTXO.
+async function sendPaymentFullstack (signer, paymentRequirements, bchServerConfig = {}) {
+  try {
+    const { apiType, bchServerURL, bearerToken } = bchServerConfig
+
+    // Private key in WIF format.
+    const wif = signer.wif
+    const payToAddr = paymentRequirements.payTo
+
+    // Support both v1 (minAmountRequired) and v2 (amount) field names
+    const amountRequired = paymentRequirements.amount || paymentRequirements.minAmountRequired
+    const paymentAmountSats = signer.paymentAmountSats || amountRequired
+
+    // Get bch-js
+    const bchWallet = new dependencies.BCHWallet(signer.wif, {
+      interface: apiType,
+      restURL: bchServerURL,
+      bearerToken
+    })
+    await bchWallet.walletInfoPromise
+    const bchjs = bchWallet.bchjs
+
+    // Generate the bitcoincash: address from the private key.
+    const ecPair = bchjs.ECPair.fromWIF(wif)
+    const payFromAddr = bchjs.ECPair.toCashAddress(ecPair)
+    // console.log(`payFromAddr: ${payFromAddr}`)
+
+    // console.log('bchjs.restURL: ', bchjs.restURL)
+
+    // Get the UTXOs controlled by the private key.
+    let utxos = []
+    let utxoData
+    try {
+      utxoData = await bchjs.Electrumx.utxo(payFromAddr)
+    } catch (err) {
+      throw new Error(`Error retrieving UTXOs for address ${payFromAddr}: ${err.message}`)
+    }
+    if (utxoData.utxos && Array.isArray(utxoData.utxos)) {
+      utxos = utxoData.utxos
+    }
 
-  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
+    // Filter out UTXOs that are equal to or greater than the paymentAmountSats
+    utxos = utxos.filter(utxo => utxo.value >= paymentAmountSats)
+    // console.log(`UTXOs available for payment: ${JSON.stringify(utxos, null, 2)}`)
+
+    // Choose the first UTXO that is big enough to pay for the transaction.
+    const utxo = utxos[0]
+
+    // instance of transaction builder
+    const transactionBuilder = new bchjs.TransactionBuilder()
+
+    // Essential variables of a transaction.
+    const satoshisToSend = paymentAmountSats
+    const originalAmount = utxo.value
+    const vout = utxo.tx_pos
+    const txid = utxo.tx_hash
+
+    // add input with txid and index of vout
+    transactionBuilder.addInput(txid, vout)
+
+    // get byte count to calculate fee. paying 1.2 sat/byte
+    const byteCount = bchjs.BitcoinCash.getByteCount({ P2PKH: 1 }, { P2PKH: 2 })
+    // console.log(`Transaction byte count: ${byteCount}`)
+    const satoshisPerByte = 1.2
+    const txFee = Math.floor(satoshisPerByte * byteCount)
+    // console.log(`Transaction fee: ${txFee}`)
+
+    // amount to send back to the sending address.
+    // It's the original amount - 1 sat/byte for tx size
+    const remainder = originalAmount - satoshisToSend - txFee
+
+    if (remainder < 0) {
+      throw new Error('Not enough BCH to complete transaction!')
     }
-  ]
 
-  const txid = await retryQueue.addToQueue(bchWallet.send.bind(bchWallet), receivers)
+    // add output w/ address and amount to send
+    transactionBuilder.addOutput(payToAddr, satoshisToSend)
+    transactionBuilder.addOutput(payFromAddr, remainder)
+
+    // Sign the transaction with the HD node.
+    let redeemScript
+    transactionBuilder.sign(
+      0,
+      ecPair,
+      redeemScript,
+      transactionBuilder.hashTypes.SIGHASH_ALL,
+      originalAmount
+    )
+
+    // build tx
+    const tx = transactionBuilder.build()
+    // output rawhex
+    const hex = tx.toHex()
+    // console.log(`TX hex: ${hex}`);
+    console.log(' ')
+
+    // Broadcast transation to the network
+    const txid2 = await bchjs.RawTransactions.sendRawTransaction([hex])
+    // console.log(`Transaction ID: ${txid2}`)
+
+    return {
+      txid: txid2,
+      vout: 0,
+      satsSent: paymentAmountSats
+    }
+  } catch (err) {
+    console.error('Error in x402-bch-axios/sendPaymentFullstack(): ', err)
+    throw err
+  }
+}
 
-  return {
-    txid,
-    vout: 0,
-    satsSent: paymentAmountSats
+async function sendPaymentGeneric (signer, paymentRequirements, bchServerConfig = {}) {
+  try {
+    const { apiType, bchServerURL, bearerToken } = 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,
+      bearerToken
+    })
+    // 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(sendWithRetry, receivers)
+
+    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
+  }
+}
+
+// Route the payment to the appropriate function based on the BCH server URL.
+async function sendPayment (signer, paymentRequirements, bchServerConfig = {}) {
+  const { bchServerURL } = bchServerConfig
+  if (bchServerURL.includes('bch.fullstack.cash')) {
+    // If the BCH server URL is a Fullstack server, use an optimized payment function.
+    return sendPaymentFullstack(signer, paymentRequirements, bchServerConfig)
+  } else {
+    return sendPaymentGeneric(signer, paymentRequirements, bchServerConfig)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402-bch-axios",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "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

@@ -506,4 +506,687 @@ 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 route to sendPaymentGeneric when URL is not fullstack', 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',
+        bearerToken: undefined
+      })
+      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 route to sendPaymentFullstack when URL contains bch.fullstack.cash', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://bch.fullstack.cash/v5/'
+      }
+
+      const mockEcPair = { ecpair: true }
+      const mockUtxos = [{
+        tx_hash: 'utxo-txid',
+        tx_pos: 1,
+        value: 5000
+      }]
+
+      const mockTransactionBuilder = {
+        addInput: sandbox.stub(),
+        addOutput: sandbox.stub(),
+        sign: sandbox.stub(),
+        build: sandbox.stub().returns({
+          toHex: sandbox.stub().returns('raw-hex')
+        }),
+        hashTypes: {
+          SIGHASH_ALL: 1
+        }
+      }
+
+      const mockBchjs = {
+        ECPair: {
+          fromWIF: sandbox.stub().returns(mockEcPair),
+          toCashAddress: sandbox.stub().returns('bitcoincash:qptest')
+        },
+        Electrumx: {
+          utxo: sandbox.stub().resolves({ utxos: mockUtxos })
+        },
+        TransactionBuilder: sandbox.stub().returns(mockTransactionBuilder),
+        BitcoinCash: {
+          getByteCount: sandbox.stub().returns(250)
+        },
+        RawTransactions: {
+          sendRawTransaction: sandbox.stub().resolves('tx123')
+        }
+      }
+
+      const mockBchWallet = {
+        walletInfoPromise: Promise.resolve(),
+        bchjs: mockBchjs
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub
+      })
+
+      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://bch.fullstack.cash/v5/',
+        bearerToken: undefined
+      })
+      assert.isTrue(mockBchjs.ECPair.fromWIF.calledOnce)
+      assert.isTrue(mockBchjs.Electrumx.utxo.calledOnce)
+      assert.isTrue(mockBchjs.TransactionBuilder.calledOnce)
+      assert.isTrue(mockTransactionBuilder.addInput.calledOnce)
+      assert.isTrue(mockTransactionBuilder.addOutput.calledTwice)
+      assert.isTrue(mockTransactionBuilder.sign.calledOnce)
+      assert.isTrue(mockBchjs.RawTransactions.sendRawTransaction.calledOnce)
+      assert.deepEqual(mockBchjs.RawTransactions.sendRawTransaction.firstCall.args[0], ['raw-hex'])
+
+      __resetDependencies()
+    })
+
+    it('should throw "Insufficient balance" error when sendWithRetry returns null', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      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 bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      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, bchServerConfig)
+        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 bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      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, bchServerConfig)
+
+      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 bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      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, bchServerConfig)
+
+      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 bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      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, bchServerConfig)
+        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()
+    })
+
+    it('should support v1 minAmountRequired field in sendPaymentGeneric', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      delete paymentRequirements.amount
+      paymentRequirements.minAmountRequired = 2500
+      const bchServerConfig = {
+        bchServerURL: 'https://api.example.com'
+      }
+
+      const mockBchWallet = {
+        initialize: sandbox.stub().resolves(),
+        send: sandbox.stub().resolves('tx-v1')
+      }
+
+      const mockRetryQueue = {
+        addToQueue: sandbox.stub().resolves('tx-v1')
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+      const RetryQueueStub = sandbox.stub().returns(mockRetryQueue)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub,
+        RetryQueue: RetryQueueStub
+      })
+
+      await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+
+      const receivers = mockRetryQueue.addToQueue.firstCall.args[1]
+      // Should use paymentAmountSats from signer (2000) when available, not minAmountRequired
+      assert.equal(receivers[0].amountSat, 2000)
+
+      __resetDependencies()
+    })
+
+    it('should handle UTXO retrieval errors in sendPaymentFullstack', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://bch.fullstack.cash/v5/'
+      }
+
+      const mockEcPair = { ecpair: true }
+      const mockBchjs = {
+        ECPair: {
+          fromWIF: sandbox.stub().returns(mockEcPair),
+          toCashAddress: sandbox.stub().returns('bitcoincash:qptest')
+        },
+        Electrumx: {
+          utxo: sandbox.stub().rejects(new Error('Network error'))
+        }
+      }
+
+      const mockBchWallet = {
+        walletInfoPromise: Promise.resolve(),
+        bchjs: mockBchjs
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+        assert.fail('Expected error to be thrown')
+      } catch (err) {
+        assert.match(err.message, /Error retrieving UTXOs/)
+        assert.match(err.message, /Network error/)
+      }
+
+      __resetDependencies()
+    })
+
+    it('should throw error when insufficient balance in sendPaymentFullstack', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://bch.fullstack.cash/v5/'
+      }
+
+      const mockEcPair = { ecpair: true }
+      const mockUtxos = [{
+        tx_hash: 'utxo-txid',
+        tx_pos: 1,
+        value: 1000 // Less than paymentAmountSats (2000)
+      }]
+
+      const mockBchjs = {
+        ECPair: {
+          fromWIF: sandbox.stub().returns(mockEcPair),
+          toCashAddress: sandbox.stub().returns('bitcoincash:qptest')
+        },
+        Electrumx: {
+          utxo: sandbox.stub().resolves({ utxos: mockUtxos })
+        }
+      }
+
+      const mockBchWallet = {
+        walletInfoPromise: Promise.resolve(),
+        bchjs: mockBchjs
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+        assert.fail('Expected error to be thrown')
+      } catch (err) {
+        // Should fail because utxos[0] is undefined after filtering
+        assert.isDefined(err)
+      }
+
+      __resetDependencies()
+    })
+
+    it('should handle transaction building errors in sendPaymentFullstack', async () => {
+      const signer = createSignerStub()
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://bch.fullstack.cash/v5/'
+      }
+
+      const mockEcPair = { ecpair: true }
+      const mockUtxos = [{
+        tx_hash: 'utxo-txid',
+        tx_pos: 1,
+        value: 5000
+      }]
+
+      const mockTransactionBuilder = {
+        addInput: sandbox.stub(),
+        addOutput: sandbox.stub(),
+        sign: sandbox.stub(),
+        build: sandbox.stub().throws(new Error('Build failed')),
+        hashTypes: {
+          SIGHASH_ALL: 1
+        }
+      }
+
+      const mockBchjs = {
+        ECPair: {
+          fromWIF: sandbox.stub().returns(mockEcPair),
+          toCashAddress: sandbox.stub().returns('bitcoincash:qptest')
+        },
+        Electrumx: {
+          utxo: sandbox.stub().resolves({ utxos: mockUtxos })
+        },
+        TransactionBuilder: sandbox.stub().returns(mockTransactionBuilder),
+        BitcoinCash: {
+          getByteCount: sandbox.stub().returns(250)
+        }
+      }
+
+      const mockBchWallet = {
+        walletInfoPromise: Promise.resolve(),
+        bchjs: mockBchjs
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+        assert.fail('Expected error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Build failed')
+      }
+
+      __resetDependencies()
+    })
+
+    it('should throw error when remainder is negative in sendPaymentFullstack', async () => {
+      const signer = createSignerStub()
+      signer.paymentAmountSats = 10000 // Large amount
+      const paymentRequirements = createPaymentRequirementsStub()
+      const bchServerConfig = {
+        apiType: 'rest-api',
+        bchServerURL: 'https://bch.fullstack.cash/v5/'
+      }
+
+      const mockEcPair = { ecpair: true }
+      // UTXO value must be >= paymentAmountSats (10000) to pass filter
+      // But remainder = value - paymentAmountSats - txFee must be negative
+      // With txFee = 1.2 * 250 = 300, we need value < 10300
+      // So use value = 10200: remainder = 10200 - 10000 - 300 = -100 < 0
+      const mockUtxos = [{
+        tx_hash: 'utxo-txid',
+        tx_pos: 1,
+        value: 10200 // >= paymentAmountSats but insufficient after fee
+      }]
+
+      const mockTransactionBuilder = {
+        addInput: sandbox.stub(),
+        addOutput: sandbox.stub(),
+        sign: sandbox.stub(),
+        hashTypes: {
+          SIGHASH_ALL: 1
+        }
+      }
+
+      const mockBchjs = {
+        ECPair: {
+          fromWIF: sandbox.stub().returns(mockEcPair),
+          toCashAddress: sandbox.stub().returns('bitcoincash:qptest')
+        },
+        Electrumx: {
+          utxo: sandbox.stub().resolves({ utxos: mockUtxos })
+        },
+        TransactionBuilder: sandbox.stub().returns(mockTransactionBuilder),
+        BitcoinCash: {
+          getByteCount: sandbox.stub().returns(250)
+        }
+      }
+
+      const mockBchWallet = {
+        walletInfoPromise: Promise.resolve(),
+        bchjs: mockBchjs
+      }
+
+      const BCHWalletStub = sandbox.stub().returns(mockBchWallet)
+
+      __setDependencies({
+        BCHWallet: BCHWalletStub
+      })
+
+      try {
+        await __internals.sendPayment(signer, paymentRequirements, bchServerConfig)
+        assert.fail('Expected error to be thrown')
+      } catch (err) {
+        assert.equal(err.message, 'Not enough BCH to complete transaction!')
+      }
+
+      __resetDependencies()
+    })
+  })
 })