@exodus/bitcoin-api 4.1.4 → 4.1.6

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.1.6](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.5...@exodus/bitcoin-api@4.1.6) (2025-10-16)
+
+**Note:** Version bump only for package @exodus/bitcoin-api
+
+
+
+
+
+## [4.1.5](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.4...@exodus/bitcoin-api@4.1.5) (2025-10-16)
+
+**Note:** Version bump only for package @exodus/bitcoin-api
+
+
+
+
+
 ## [4.1.4](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.3...@exodus/bitcoin-api@4.1.4) (2025-10-15)
 
 **Note:** Version bump only for package @exodus/bitcoin-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "4.1.4",
+  "version": "4.1.6",
   "description": "Bitcoin transaction and fee monitors, RPC with the blockchain node, other networking code.",
   "type": "module",
   "main": "src/index.js",
@@ -60,5 +60,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "0efd644cc413c308688b43c8563b172b3a80e3fa"
+  "gitHead": "f193d5effadc719b3fb4ba7d32fc46c0979f258a"
 }

package/src/tx-create/create-tx.js

@@ -10,6 +10,255 @@ import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data.js'
 import { getUsableUtxos, getUtxos } from '../utxos-utils.js'
 import { createInputs, createOutput, getBlockHeight, getNonWitnessTxs } from './tx-create-utils.js'
 
+// Helper to shuffle arrays for randomized input/output ordering
+const shuffle = (list) => {
+  return lodash.shuffle(list)
+}
+
+function validateTransactionParams({ assetClientInterface, asset, toAddress, bumpTxId }) {
+  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${asset.name}`)
+  assert(
+    toAddress || bumpTxId,
+    'should not be called without either a receiving toAddress or to bump a tx'
+  )
+}
+
+async function prepareTransactionContext({
+  asset,
+  assetName,
+  walletAccount,
+  multipleAddressesEnabled,
+  assetClientInterface,
+  accountState,
+  insightClient,
+  feeData,
+  feePerKB,
+  isExchange,
+  isRbfAllowed,
+}) {
+  const updatedFeeData = { ...feeData, feePerKB: feePerKB ?? feeData.feePerKB }
+
+  const blockHeight = await getBlockHeight({ assetName, insightClient })
+
+  const rbfEnabled = updatedFeeData.rbfEnabled && !isExchange && isRbfAllowed
+
+  const changeAddress = multipleAddressesEnabled
+    ? await assetClientInterface.getNextChangeAddress({ assetName, walletAccount })
+    : await assetClientInterface.getReceiveAddressObject({ assetName, walletAccount })
+
+  const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
+
+  const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
+
+  const usableUtxos = getUsableUtxos({
+    asset,
+    utxos: getUtxos({ accountState, asset }),
+    feeData: updatedFeeData,
+    txSet,
+    unconfirmedTxAncestor,
+  })
+
+  return {
+    updatedFeeData,
+    blockHeight,
+    rbfEnabled,
+    changeAddress,
+    txSet,
+    unconfirmedTxAncestor,
+    usableUtxos,
+  }
+}
+
+// Process and normalize addresses
+function processAddress({ asset, toAddress }) {
+  let processedAddress = toAddress
+
+  if (asset.address.toLegacyAddress) {
+    processedAddress = asset.address.toLegacyAddress(toAddress)
+  }
+
+  if (asset.name === 'digibyte' && asset.address.isP2SH2(processedAddress)) {
+    processedAddress = asset.address.P2SH2ToP2SH(processedAddress)
+  }
+
+  const useCashAddress = asset.address.isCashAddress?.(toAddress)
+
+  return { processedAddress, useCashAddress }
+}
+
+// Determine strategy for transaction bumping (RBF vs CPFP)
+function determineBumpStrategy({ bumpTxId, replaceableTxs, usableUtxos }) {
+  if (!bumpTxId) {
+    return { replaceableTxs, utxosToBump: undefined }
+  }
+
+  // Check if we can use RBF (Replace-By-Fee)
+  const bumpTx = replaceableTxs.find(({ txId }) => txId === bumpTxId)
+
+  if (bumpTx) {
+    // Use RBF: replace the transaction directly
+    return { replaceableTxs: [bumpTx], utxosToBump: undefined }
+  }
+
+  // Otherwise try CPFP (Child-Pays-For-Parent) by spending the transaction's outputs
+  const utxosToBump = usableUtxos.getTxIdUtxos(bumpTxId)
+  if (utxosToBump.size === 0) {
+    throw new Error(`Cannot bump transaction ${bumpTxId}`)
+  }
+
+  return { replaceableTxs: [], utxosToBump }
+}
+
+// Prepare parameters for UTXO selection
+function prepareUtxoSelectionParams({
+  bumpTxId,
+  asset,
+  amount,
+  replaceableTxs,
+  processedAddress,
+  changeAddressType,
+  updatedFeeData,
+  rbfEnabled,
+  feePerKB,
+  customFee,
+  isSendAll,
+}) {
+  const sendAmount = bumpTxId ? asset.currency.ZERO : amount
+
+  const receiveAddress = bumpTxId
+    ? replaceableTxs.length > 0
+      ? null
+      : changeAddressType
+    : processedAddress
+
+  const feeRate = customFee || updatedFeeData.feePerKB
+  const resolvedIsSendAll = !rbfEnabled && feePerKB ? false : isSendAll
+
+  return {
+    sendAmount,
+    receiveAddress,
+    feeRate,
+    resolvedIsSendAll,
+  }
+}
+
+// Process RBF replacement transaction
+function processReplacementTransaction({ replaceTx, asset }) {
+  if (!replaceTx) return { replaceTx: undefined, replaceTxInputUtxos: undefined }
+
+  const clonedTx = replaceTx.clone()
+  const updatedTx = clonedTx.update({ data: { ...clonedTx.data } })
+
+  updatedTx.data.sent = updatedTx.data.sent.map((to) => ({
+    ...to,
+    amount: serializeCurrency(to.amount, asset.currency),
+  }))
+
+  const replaceTxInputUtxos = UtxoCollection.fromJSON(updatedTx.data.inputs, {
+    currency: asset.currency,
+  })
+
+  return { replaceTx: updatedTx, replaceTxInputUtxos }
+}
+
+// Create transaction outputs
+function createTransactionOutputs({
+  replaceTx,
+  processedAddress,
+  sendAmount,
+  asset,
+  selectedUtxos,
+  fee,
+  changeAddress,
+}) {
+  const assetName = asset.name
+  let outputs = []
+  let sendOutput
+
+  // Add existing outputs from replacement transaction
+  if (replaceTx) {
+    outputs = replaceTx.data.sent.map(({ address, amount }) =>
+      createOutput(assetName, address, parseCurrency(amount, asset.currency))
+    )
+  }
+
+  // Add send output if we have a destination address
+  if (processedAddress) {
+    sendOutput = createOutput(assetName, processedAddress, sendAmount)
+    outputs.push(sendOutput)
+  }
+
+  // Calculate total amount
+  const totalAmount = replaceTx
+    ? replaceTx.data.sent.reduce(
+        (total, { amount }) => total.add(parseCurrency(amount, asset.currency)),
+        sendAmount
+      )
+    : sendAmount
+
+  // Handle change output
+  const { changeOutput, adjustedFee, changeAddressKeypath, ourAddress } = createChangeOutput({
+    selectedUtxos,
+    totalAmount,
+    fee,
+    replaceTx,
+    changeAddress,
+    asset,
+  })
+
+  if (changeOutput) {
+    outputs.push(changeOutput)
+  }
+
+  return {
+    outputs: replaceTx ? outputs : shuffle(outputs),
+    sendOutput,
+    changeOutput,
+    totalAmount,
+    adjustedFee,
+    changeAddressKeypath,
+    ourAddress,
+  }
+}
+
+// Create change output if needed
+function createChangeOutput({ selectedUtxos, totalAmount, fee, replaceTx, changeAddress, asset }) {
+  const change = selectedUtxos.value.sub(totalAmount).sub(fee)
+  const dust = getChangeDustValue(asset)
+
+  // Process change address
+  let ourAddress = replaceTx?.data?.changeAddress || changeAddress
+  if (asset.address.toLegacyAddress) {
+    const legacyAddress = asset.address.toLegacyAddress(ourAddress.address)
+    ourAddress = Address.create(legacyAddress, ourAddress.meta)
+  }
+
+  // Create change output if above dust threshold
+  if (change.gte(dust)) {
+    const changeOutput = createOutput(
+      asset.name,
+      ourAddress.address ?? ourAddress.toString(),
+      change
+    )
+
+    // Return the keypath for hardware wallet change detection
+    return {
+      changeOutput,
+      adjustedFee: fee,
+      changeAddressKeypath: ourAddress.meta.path,
+      ourAddress,
+    }
+  }
+
+  // Add dust to fee if not enough for change output
+  return {
+    changeOutput: undefined,
+    adjustedFee: fee.add(change),
+    changeAddressKeypath: undefined,
+    ourAddress,
+  }
+}
+
 async function createUnsignedTx({
   inputs,
   outputs,
@@ -51,8 +300,6 @@ const transferHandler = {
     walletAccount,
     toAddress,
     amount,
-    blockHeight: providedBlockHeight,
-    rbfEnabled: providedRbfEnabled,
     multipleAddressesEnabled,
     feePerKB,
     customFee,
@@ -70,99 +317,72 @@ const transferHandler = {
     changeAddressType,
   }) => {
     const assetName = asset.name
-    const updatedFeeData = { ...feeData, feePerKB: feePerKB ?? feeData.feePerKB }
     const insightClient = asset.baseAsset.insightClient
 
-    const blockHeight = providedBlockHeight || (await getBlockHeight({ assetName, insightClient }))
-
-    const rbfEnabled =
-      providedRbfEnabled || (updatedFeeData.rbfEnabled && !isExchange && isRbfAllowed)
-
-    const shuffle = (list) => {
-      // Using full lodash.shuffle notation so it can be mocked with spyOn in tests
-      return lodash.shuffle(list)
-    }
+    validateTransactionParams({ assetClientInterface, asset, toAddress, bumpTxId })
 
-    assert(
+    const context = await prepareTransactionContext({
+      asset,
+      assetName,
+      walletAccount,
+      multipleAddressesEnabled,
       assetClientInterface,
-      `assetClientInterface must be supplied in sendTx for ${asset.name}`
-    )
-    assert(
-      toAddress || bumpTxId,
-      'should not be called without either a receiving toAddress or to bump a tx'
-    )
+      accountState,
+      insightClient,
+      feeData,
+      feePerKB,
+      isExchange,
+      isRbfAllowed,
+    })
 
-    const useCashAddress = asset.address.isCashAddress?.(toAddress)
+    const { processedAddress, useCashAddress } = processAddress({ asset, toAddress })
 
-    const changeAddress = multipleAddressesEnabled
-      ? await assetClientInterface.getNextChangeAddress({ assetName, walletAccount })
-      : await assetClientInterface.getReceiveAddressObject({ assetName, walletAccount })
+    // Get replaceable transactions
+    let replaceableTxs = findUnconfirmedSentRbfTxs(context.txSet)
 
-    const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    // Determine bumping strategy (RBF or CPFP)
+    const { replaceableTxs: updatedReplaceableTxs, utxosToBump } = determineBumpStrategy({
+      bumpTxId,
+      replaceableTxs,
+      usableUtxos: context.usableUtxos,
+    })
+    replaceableTxs = updatedReplaceableTxs
 
-    const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
-    const usableUtxos = getUsableUtxos({
+    const utxoParams = prepareUtxoSelectionParams({
+      bumpTxId,
       asset,
-      utxos: getUtxos({ accountState, asset }),
-      feeData: updatedFeeData,
-      txSet,
-      unconfirmedTxAncestor,
+      amount,
+      replaceableTxs,
+      processedAddress,
+      changeAddressType,
+      updatedFeeData: context.updatedFeeData,
+      rbfEnabled: context.rbfEnabled,
+      feePerKB,
+      customFee,
+      isSendAll,
     })
 
-    let replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
-
-    let processedAddress = toAddress
-    if (asset.address.toLegacyAddress) {
-      processedAddress = asset.address.toLegacyAddress(toAddress)
-    }
-
-    if (assetName === 'digibyte' && asset.address.isP2SH2(processedAddress)) {
-      processedAddress = asset.address.P2SH2ToP2SH(processedAddress)
-    }
-
-    let utxosToBump
-    if (bumpTxId) {
-      const bumpTx = replaceableTxs.find(({ txId }) => txId === bumpTxId)
-      if (bumpTx) {
-        replaceableTxs = [bumpTx]
-      } else {
-        utxosToBump = usableUtxos.getTxIdUtxos(bumpTxId)
-        if (utxosToBump.size === 0) {
-          throw new Error(`Cannot bump transaction ${bumpTxId}`)
-        }
-
-        replaceableTxs = []
-      }
-    }
-
-    const sendAmount = bumpTxId ? asset.currency.ZERO : amount
-    const receiveAddress = bumpTxId
-      ? replaceableTxs.length > 0
-        ? null
-        : changeAddressType
-      : processedAddress
-    const feeRate = updatedFeeData.feePerKB
-    const resolvedIsSendAll = !rbfEnabled && feePerKB ? false : isSendAll
-
     let { selectedUtxos, fee, replaceTx } = selectUtxos({
       asset,
-      usableUtxos,
+      usableUtxos: context.usableUtxos,
       replaceableTxs,
-      amount: sendAmount,
-      feeRate: customFee || feeRate,
-      receiveAddress,
-      isSendAll: resolvedIsSendAll,
+      amount: utxoParams.sendAmount,
+      feeRate: utxoParams.feeRate,
+      receiveAddress: utxoParams.receiveAddress,
+      isSendAll: utxoParams.resolvedIsSendAll,
       getFeeEstimator: (asset, { feePerKB, ...options }) =>
         getFeeEstimator(asset, feePerKB, options),
       mustSpendUtxos: utxosToBump,
       allowUnconfirmedRbfEnabledUtxos,
-      unconfirmedTxAncestor,
+      unconfirmedTxAncestor: context.unconfirmedTxAncestor,
       utxosDescendingOrder,
       taprootInputWitnessSize,
       changeAddressType,
     })
 
-    if (!selectedUtxos && !replaceTx) throw new Error('Not enough funds.')
+    if (!selectedUtxos && !replaceTx) {
+      throw new Error('Not enough funds.')
+    }
 
     // When bumping a tx, we can either replace the tx with RBF or spend its selected change.
     // If there is no selected UTXO or the tx to replace is not the tx we want to bump,
@@ -173,70 +393,52 @@ const transferHandler = {
       throw new Error(`Unable to bump ${bumpTxId}`)
     }
 
-    if (replaceTx) {
-      replaceTx = replaceTx.clone()
-      replaceTx = replaceTx.update({ data: { ...replaceTx.data } })
-      replaceTx.data.sent = replaceTx.data.sent.map((to) => {
-        return { ...to, amount: serializeCurrency(to.amount, asset.currency) }
-      })
-      selectedUtxos = selectedUtxos.union(
-        UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
-      )
+    const { replaceTx: processedReplaceTx, replaceTxInputUtxos } = processReplacementTransaction({
+      replaceTx,
+      asset,
+    })
+
+    if (replaceTxInputUtxos) {
+      selectedUtxos = selectedUtxos.union(replaceTxInputUtxos)
     }
 
     const addressPathsMap = selectedUtxos.getAddressPathsMap()
 
-    // Inputs and Outputs
-    const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), rbfEnabled))
-    let outputs = replaceTx
-      ? replaceTx.data.sent.map(({ address, amount }) =>
-          createOutput(assetName, address, parseCurrency(amount, asset.currency))
-        )
-      : []
-
-    // Send output
-    let sendOutput
-    if (processedAddress) {
-      sendOutput = createOutput(assetName, processedAddress, sendAmount)
-      outputs.push(sendOutput)
-    }
+    // Create inputs
+    const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), context.rbfEnabled))
 
-    const totalAmount = replaceTx
-      ? replaceTx.data.sent.reduce(
-          (total, { amount }) => total.add(parseCurrency(amount, asset.currency)),
-          sendAmount
-        )
-      : sendAmount
-
-    const change = selectedUtxos.value.sub(totalAmount).sub(fee)
-    const dust = getChangeDustValue(asset)
-    let ourAddress = replaceTx?.data?.changeAddress || changeAddress
-    if (asset.address.toLegacyAddress) {
-      const legacyAddress = asset.address.toLegacyAddress(ourAddress.address)
-      ourAddress = Address.create(legacyAddress, ourAddress.meta)
-    }
+    // Create outputs
+    const {
+      outputs,
+      sendOutput,
+      changeOutput,
+      totalAmount,
+      adjustedFee,
+      changeAddressKeypath,
+      ourAddress,
+    } = createTransactionOutputs({
+      replaceTx: processedReplaceTx,
+      processedAddress,
+      sendAmount: utxoParams.sendAmount,
+      asset,
+      selectedUtxos,
+      fee,
+      changeAddress: context.changeAddress,
+    })
 
-    // Change Output
-    let changeOutput
-    if (change.gte(dust)) {
-      changeOutput = createOutput(assetName, ourAddress.address ?? ourAddress.toString(), change)
-      // Add the keypath of change address to support Trezor detect the change output.
-      // Output is change and does not need approval from user which shows the strange address that user never seen.
-      addressPathsMap[changeAddress] = ourAddress.meta.path
-      outputs.push(changeOutput)
-    } else {
-      // If we don't have enough for a change output, then all remaining dust is just added to fee
-      fee = fee.add(change)
+    // Add the keypath of change address to support Trezor detect the change output.
+    // Output is change and does not need approval from user which shows the strange address that user never seen.
+    if (changeAddressKeypath) {
+      addressPathsMap[context.changeAddress] = changeAddressKeypath
     }
 
-    outputs = replaceTx ? outputs : shuffle(outputs)
-
+    // Create unsigned transaction
     const unsignedTx = await createUnsignedTx({
       inputs,
       outputs,
       useCashAddress,
       addressPathsMap,
-      blockHeight,
+      blockHeight: context.blockHeight,
       asset,
       selectedUtxos,
       insightClient,
@@ -244,20 +446,22 @@ const transferHandler = {
 
     return {
       unsignedTx,
-      fee,
+      fee: adjustedFee,
       metadata: {
         amount,
-        change,
+        change: selectedUtxos.value.sub(totalAmount).sub(adjustedFee),
         totalAmount,
         address: processedAddress,
         ourAddress,
-        receiveAddress,
-        sendAmount,
-        usableUtxos,
+        receiveAddress: utxoParams.receiveAddress,
+        sendAmount: utxoParams.sendAmount,
+        usableUtxos: context.usableUtxos,
         selectedUtxos,
-        replaceTx,
+        replaceTx: processedReplaceTx,
         sendOutput,
         changeOutput,
+        blockHeight: context.blockHeight,
+        rbfEnabled: context.rbfEnabled,
       },
     }
   },
@@ -277,8 +481,6 @@ export const createTxFactory =
     type,
     toAddress,
     amount,
-    blockHeight,
-    rbfEnabled,
     multipleAddressesEnabled,
     feePerKB,
     customFee,
@@ -302,8 +504,6 @@ export const createTxFactory =
       walletAccount,
       toAddress,
       amount,
-      blockHeight,
-      rbfEnabled,
       multipleAddressesEnabled,
       feePerKB,
       customFee,

package/src/tx-send/index.js

@@ -2,7 +2,6 @@ import * as defaultBitcoinjsLib from '@exodus/bitcoinjs'
 import assert from 'minimalistic-assert'
 
 import { createTxFactory } from '../tx-create/create-tx.js'
-import { getBlockHeight } from '../tx-create/tx-create-utils.js'
 import { broadcastTransaction } from './broadcast-tx.js'
 import { updateAccountState, updateTransactionLog } from './update-state.js'
 
@@ -104,11 +103,9 @@ const getPrepareSendTransaction = async ({
   amount,
   asset,
   assetClientInterface,
-  blockHeight,
   changeAddressType,
   getFeeEstimator,
   options,
-  rbfEnabled,
   utxosDescendingOrder,
   walletAccount,
 }) => {
@@ -120,15 +117,17 @@ const getPrepareSendTransaction = async ({
     changeAddressType,
   })
 
+  // Set default values for options
+  const { isRbfAllowed = true, ...restOptions } = options || Object.create(null)
+
   return createTx({
     asset,
     walletAccount,
     type: 'transfer',
     toAddress: address,
     amount,
-    blockHeight,
-    rbfEnabled,
-    ...options,
+    isRbfAllowed,
+    ...restOptions,
   })
 }
 
@@ -145,17 +144,10 @@ export const createAndBroadcastTXFactory =
   }) =>
   async ({ asset, walletAccount, address, amount, options }) => {
     // Prepare transaction
-    const { bumpTxId, isExchange, isRbfAllowed = true } = options
+    const { bumpTxId } = options
 
     const assetName = asset.name
-    const feeData = await assetClientInterface.getFeeConfig({ assetName })
     const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
-    const insightClient = asset.baseAsset.insightClient
-
-    const rbfEnabled = feeData.rbfEnabled && !isExchange && isRbfAllowed
-
-    // blockHeight
-    const blockHeight = await getBlockHeight({ assetName, insightClient })
 
     const transactionDescriptor = await getPrepareSendTransaction({
       address,
@@ -163,17 +155,23 @@ export const createAndBroadcastTXFactory =
       amount,
       asset,
       assetClientInterface,
-      blockHeight,
       changeAddressType,
       getFeeEstimator,
       options,
-      rbfEnabled,
       utxosDescendingOrder,
       walletAccount,
     })
 
     const { unsignedTx, fee, metadata } = transactionDescriptor
-    const { sendAmount, usableUtxos, replaceTx, sendOutput, changeOutput } = metadata
+    const {
+      sendAmount,
+      usableUtxos,
+      replaceTx,
+      sendOutput,
+      changeOutput,
+      blockHeight,
+      rbfEnabled,
+    } = metadata
 
     const outputs = unsignedTx.txData.outputs