@exodus/bitcoin-api 4.1.3 → 4.1.5

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.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
+
+
+
+
+
 ## [4.1.3](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.1...@exodus/bitcoin-api@4.1.3) (2025-10-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "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": "48e0d08e2fe044fb98d2fb16fc790f642a3c1eb2"
+  "gitHead": "d6f680d217f82d3b165372a7bc728899b719a398"
 }

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 }))
+    validateTransactionParams({ assetClientInterface, asset, toAddress, bumpTxId })
 
-    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)
-    }
-
-    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,90 +393,76 @@ 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,
     })
 
     return {
-      amount,
-      change,
-      totalAmount,
-      address: processedAddress,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      replaceTx,
-      sendOutput,
-      changeOutput,
       unsignedTx,
+      fee: adjustedFee,
+      metadata: {
+        amount,
+        change: selectedUtxos.value.sub(totalAmount).sub(adjustedFee),
+        totalAmount,
+        address: processedAddress,
+        ourAddress,
+        receiveAddress: utxoParams.receiveAddress,
+        sendAmount: utxoParams.sendAmount,
+        usableUtxos: context.usableUtxos,
+        selectedUtxos,
+        replaceTx: processedReplaceTx,
+        sendOutput,
+        changeOutput,
+        blockHeight: context.blockHeight,
+        rbfEnabled: context.rbfEnabled,
+      },
     }
   },
 }
@@ -275,8 +481,6 @@ export const createTxFactory =
     type,
     toAddress,
     amount,
-    blockHeight,
-    rbfEnabled,
     multipleAddressesEnabled,
     feePerKB,
     customFee,
@@ -300,8 +504,6 @@ export const createTxFactory =
       walletAccount,
       toAddress,
       amount,
-      blockHeight,
-      rbfEnabled,
       multipleAddressesEnabled,
       feePerKB,
       customFee,

package/src/tx-send/broadcast-tx.js

@@ -0,0 +1,48 @@
+import { retry } from '@exodus/simple-retry'
+
+/**
+ * Broadcast a signed transaction to the Bitcoin network with retry logic
+ * @param {Object} params
+ * @param {Object} params.asset - The asset object
+ * @param {Buffer} params.rawTx - The raw signed transaction
+ * @returns {Promise<void>}
+ * @throws {Error} With finalError=true for non-retryable errors
+ */
+export async function broadcastTransaction({ asset, rawTx }) {
+  const broadcastTxWithRetry = retry(
+    async (rawTxHex) => {
+      try {
+        return await asset.api.broadcastTx(rawTxHex)
+      } catch (e) {
+        // Mark certain errors as final (non-retryable)
+        if (
+          /missing inputs/i.test(e.message) ||
+          /absurdly-high-fee/.test(e.message) ||
+          /too-long-mempool-chain/.test(e.message) ||
+          /txn-mempool-conflict/.test(e.message) ||
+          /tx-size/.test(e.message) ||
+          /txn-already-in-mempool/.test(e.message)
+        ) {
+          e.finalError = true
+        }
+
+        throw e
+      }
+    },
+    { delayTimesMs: ['10s'] }
+  )
+
+  const rawTxHex = rawTx.toString('hex')
+
+  try {
+    await broadcastTxWithRetry(rawTxHex)
+  } catch (err) {
+    if (err.message.includes('txn-already-in-mempool')) {
+      // Not an error, transaction is already broadcast
+      console.log('Transaction is already in the mempool.')
+      return
+    }
+
+    throw err
+  }
+}

package/src/tx-send/index.js

@@ -1,11 +1,9 @@
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs'
-import { Address } from '@exodus/models'
-import { retry } from '@exodus/simple-retry'
 import assert from 'minimalistic-assert'
 
-import { serializeCurrency } from '../fee/fee-utils.js'
 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'
 
 const getSize = (tx) => {
   if (typeof tx.size === 'number') return tx.size
@@ -105,11 +103,9 @@ const getPrepareSendTransaction = async ({
   amount,
   asset,
   assetClientInterface,
-  blockHeight,
   changeAddressType,
   getFeeEstimator,
   options,
-  rbfEnabled,
   utxosDescendingOrder,
   walletAccount,
 }) => {
@@ -121,15 +117,17 @@ const getPrepareSendTransaction = async ({
     changeAddressType,
   })
 
+  // Set default values for options
+  const { isRbfAllowed = true, ...restOptions } = options || {}
+
   return createTx({
     asset,
     walletAccount,
     type: 'transfer',
     toAddress: address,
     amount,
-    blockHeight,
-    rbfEnabled,
-    ...options,
+    isRbfAllowed,
+    ...restOptions,
   })
 }
 
@@ -146,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,
@@ -164,31 +155,27 @@ export const createAndBroadcastTXFactory =
       amount,
       asset,
       assetClientInterface,
-      blockHeight,
       changeAddressType,
       getFeeEstimator,
       options,
-      rbfEnabled,
       utxosDescendingOrder,
       walletAccount,
     })
+
+    const { unsignedTx, fee, metadata } = transactionDescriptor
     const {
-      change,
-      totalAmount,
-      ourAddress,
-      receiveAddress,
       sendAmount,
-      fee,
       usableUtxos,
-      selectedUtxos,
       replaceTx,
       sendOutput,
       changeOutput,
-      unsignedTx,
-    } = transactionDescriptor
+      blockHeight,
+      rbfEnabled,
+    } = metadata
+
     const outputs = unsignedTx.txData.outputs
 
-    address = transactionDescriptor.address
+    address = metadata.address
 
     // Sign transaction
     const { rawTx, txId, tx } = await signTransaction({
@@ -199,44 +186,18 @@ export const createAndBroadcastTXFactory =
     })
 
     // Broadcast transaction
-    const broadcastTxWithRetry = retry(
-      async (rawTx) => {
-        try {
-          return await asset.api.broadcastTx(rawTx)
-        } catch (e) {
-          if (
-            /missing inputs/i.test(e.message) ||
-            /absurdly-high-fee/.test(e.message) ||
-            /too-long-mempool-chain/.test(e.message) ||
-            /txn-mempool-conflict/.test(e.message) ||
-            /tx-size/.test(e.message) ||
-            /txn-already-in-mempool/.test(e.message)
-          ) {
-            e.finalError = true
-          }
-
-          throw e
-        }
-      },
-      { delayTimesMs: ['10s'] }
-    )
-
     try {
-      await broadcastTxWithRetry(rawTx.toString('hex'))
+      await broadcastTransaction({ asset, rawTx })
     } catch (err) {
-      if (err.message.includes('txn-already-in-mempool')) {
-        // It's not an error, we must ignore it.
-        console.log('Transaction is already in the mempool.')
-      } else if (/insight broadcast http error.*missing inputs/i.test(err.message)) {
+      if (/insight broadcast http error.*missing inputs/i.test(err.message)) {
         err.txInfo = JSON.stringify({
           amount: sendAmount.toDefaultString({ unit: true }),
-          fee: ((fee && fee.toDefaultString({ unit: true })) || 0).toString(), // todo why does 0 not have a unit? Is default unit ok here?
+          fee: ((fee && fee.toDefaultString({ unit: true })) || 0).toString(),
           allUtxos: usableUtxos.toJSON(),
         })
-        throw err
-      } else {
-        throw err
       }
+
+      throw err
     }
 
     function findUtxoIndex(output) {
@@ -256,114 +217,35 @@ export const createAndBroadcastTXFactory =
     const changeUtxoIndex = findUtxoIndex(changeOutput)
     const sendUtxoIndex = findUtxoIndex(sendOutput)
 
-    const { script, size } = getSizeAndChangeScript({ assetName, tx, rawTx, changeUtxoIndex, txId })
-
-    const knownBalanceUtxoIds = accountState.knownBalanceUtxoIds || []
-    let remainingUtxos = usableUtxos.difference(selectedUtxos)
-    if (changeUtxoIndex !== -1) {
-      const address = Address.create(ourAddress.address, ourAddress.meta)
-      const changeUtxo = {
-        txId,
-        address,
-        vout: changeUtxoIndex,
-        script,
-        value: change,
-        confirmations: 0,
-        rbfEnabled,
-      }
-
-      knownBalanceUtxoIds.push(`${changeUtxo.txId}:${changeUtxo.vout}`.toLowerCase())
-      remainingUtxos = remainingUtxos.addUtxo(changeUtxo)
-    }
-
-    if (replaceTx) {
-      remainingUtxos = remainingUtxos.difference(remainingUtxos.getTxIdUtxos(replaceTx.txId))
-    }
-
-    await assetClientInterface.updateAccountState({
-      assetName,
-      walletAccount,
-      newData: {
-        utxos: remainingUtxos,
-        knownBalanceUtxoIds,
-      },
-    })
-
-    const config = await assetClientInterface.getAssetConfig?.({
+    const { size } = await updateAccountState({
+      assetClientInterface,
       assetName,
       walletAccount,
+      accountState,
+      txId,
+      metadata,
+      tx,
+      rawTx,
+      changeUtxoIndex,
+      getSizeAndChangeScript,
+      rbfEnabled,
     })
-    const walletAddressObjects = await assetClientInterface.getReceiveAddresses({
-      walletAccount,
-      assetName,
-      multiAddressMode: config?.multiAddressMode ?? true,
-    })
-    // There are two cases of bumping, replacing or chaining a self-send.
-    // If we have a bumpTxId, but we aren't replacing, then it is a self-send.
-    const selfSend = bumpTxId
-      ? !replaceTx
-      : walletAddressObjects.some((receiveAddress) => String(receiveAddress) === String(address))
-
-    const displayReceiveAddress = asset.address.displayAddress?.(receiveAddress) || receiveAddress
-
-    const receivers = bumpTxId
-      ? replaceTx
-        ? replaceTx.data.sent
-        : []
-      : replaceTx
-        ? [
-            ...replaceTx.data.sent,
-            { address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) },
-          ]
-        : [{ address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) }]
 
-    const calculateCoinAmount = () => {
-      if (selfSend) {
-        return asset.currency.ZERO
-      }
-
-      return totalAmount.abs().negate()
-    }
-
-    const coinAmount = calculateCoinAmount()
-
-    await assetClientInterface.updateTxLogAndNotify({
-      assetName: asset.name,
+    await updateTransactionLog({
+      asset,
+      assetClientInterface,
       walletAccount,
-      txs: [
-        {
-          txId,
-          confirmations: 0,
-          coinAmount,
-          coinName: asset.name,
-          feeAmount: fee,
-          feeCoinName: assetName,
-          selfSend,
-          data: {
-            sent: selfSend ? [] : receivers,
-            rbfEnabled,
-            feePerKB: size ? fee.div(size / 1000).toBaseNumber() : undefined,
-            changeAddress: changeOutput ? ourAddress : undefined,
-            blockHeight,
-            blocksSeen: 0,
-            inputs: selectedUtxos.toJSON(),
-            replacedTxId: replaceTx ? replaceTx.txId : undefined,
-          },
-        },
-      ],
+      txId,
+      fee,
+      metadata,
+      address,
+      amount,
+      bumpTxId,
+      size,
+      blockHeight,
+      rbfEnabled,
     })
 
-    // If we are replacing the tx, add the replacedBy info to the previous tx to update UI
-    // Also, clone the personal note and attach it to the new tx so it is not lost
-    if (replaceTx) {
-      replaceTx.data.replacedBy = txId
-      await assetClientInterface.updateTxLogAndNotify({
-        assetName,
-        walletAccount,
-        txs: [replaceTx],
-      })
-    }
-
     return {
       txId,
       sendUtxoIndex,

package/src/tx-send/update-state.js

@@ -0,0 +1,188 @@
+import { Address } from '@exodus/models'
+
+import { serializeCurrency } from '../fee/fee-utils.js'
+
+/**
+ * Update account state after transaction is broadcast
+ * @param {Object} params
+ * @param {Object} params.assetClientInterface - Asset client interface
+ * @param {string} params.assetName - Name of the asset
+ * @param {Object} params.walletAccount - Wallet account
+ * @param {Object} params.accountState - Current account state
+ * @param {string} params.txId - Transaction ID
+ * @param {Object} params.metadata - Transaction metadata
+ * @param {Object} params.tx - Signed transaction object
+ * @param {Buffer} params.rawTx - Raw transaction
+ * @param {number} params.changeUtxoIndex - Index of change output
+ * @param {Object} params.changeOutput - Change output details
+ * @param {Object} params.getSizeAndChangeScript - Function to get size and script
+ * @param {boolean} params.rbfEnabled - Whether RBF is enabled
+ */
+export async function updateAccountState({
+  assetClientInterface,
+  assetName,
+  walletAccount,
+  accountState,
+  txId,
+  metadata,
+  tx,
+  rawTx,
+  changeUtxoIndex,
+  getSizeAndChangeScript,
+  rbfEnabled,
+}) {
+  const { usableUtxos, selectedUtxos, replaceTx, change, ourAddress } = metadata
+
+  // Get change script and size
+  const { script, size } = getSizeAndChangeScript({
+    assetName,
+    tx,
+    rawTx,
+    changeUtxoIndex,
+    txId,
+  })
+
+  // Update remaining UTXOs
+  const knownBalanceUtxoIds = accountState.knownBalanceUtxoIds || []
+  let remainingUtxos = usableUtxos.difference(selectedUtxos)
+
+  // Add change UTXO if present
+  if (changeUtxoIndex !== -1 && ourAddress) {
+    const address = Address.create(ourAddress.address || ourAddress, ourAddress.meta || {})
+    const changeUtxo = {
+      txId,
+      address,
+      vout: changeUtxoIndex,
+      script,
+      value: change,
+      confirmations: 0,
+      rbfEnabled,
+    }
+
+    knownBalanceUtxoIds.push(`${changeUtxo.txId}:${changeUtxo.vout}`.toLowerCase())
+    remainingUtxos = remainingUtxos.addUtxo(changeUtxo)
+  }
+
+  // Remove replaced transaction UTXOs if present
+  if (replaceTx) {
+    remainingUtxos = remainingUtxos.difference(remainingUtxos.getTxIdUtxos(replaceTx.txId))
+  }
+
+  // Update account state
+  await assetClientInterface.updateAccountState({
+    assetName,
+    walletAccount,
+    newData: {
+      utxos: remainingUtxos,
+      knownBalanceUtxoIds,
+    },
+  })
+
+  return { size }
+}
+
+/**
+ * Update transaction log with new transaction
+ * @param {Object} params
+ * @param {Object} params.asset - Asset object
+ * @param {Object} params.assetClientInterface - Asset client interface
+ * @param {Object} params.walletAccount - Wallet account
+ * @param {string} params.txId - Transaction ID
+ * @param {Object} params.fee - Transaction fee
+ * @param {Object} params.metadata - Transaction metadata
+ * @param {string} params.address - Recipient address
+ * @param {Object} params.amount - Transaction amount (for regular sends)
+ * @param {string} params.bumpTxId - ID of transaction being bumped (if applicable)
+ * @param {number} params.size - Transaction size
+ * @param {number} params.blockHeight - Block height
+ * @param {boolean} params.rbfEnabled - Whether RBF is enabled
+ */
+export async function updateTransactionLog({
+  asset,
+  assetClientInterface,
+  walletAccount,
+  txId,
+  fee,
+  metadata,
+  address,
+  amount,
+  bumpTxId,
+  size,
+  blockHeight,
+  rbfEnabled,
+}) {
+  const { totalAmount, selectedUtxos, replaceTx, changeOutput, ourAddress } = metadata
+  const assetName = asset.name
+
+  // Check if this is a self-send
+  const config = await assetClientInterface.getAssetConfig?.({
+    assetName,
+    walletAccount,
+  })
+
+  const walletAddressObjects = await assetClientInterface.getReceiveAddresses({
+    walletAccount,
+    assetName,
+    multiAddressMode: config?.multiAddressMode ?? true,
+  })
+
+  // There are two cases of bumping, replacing or chaining a self-send.
+  // If we have a bumpTxId, but we aren't replacing, then it is a self-send.
+  const selfSend = bumpTxId
+    ? !replaceTx
+    : walletAddressObjects.some((receiveAddress) => String(receiveAddress) === String(address))
+
+  const displayReceiveAddress = asset.address.displayAddress?.(address) || address
+
+  // Build receivers list
+  const receivers = bumpTxId
+    ? replaceTx
+      ? replaceTx.data.sent
+      : []
+    : replaceTx
+      ? [
+          ...replaceTx.data.sent,
+          { address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) },
+        ]
+      : [{ address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) }]
+
+  // Calculate coin amount
+  const coinAmount = selfSend ? asset.currency.ZERO : totalAmount.abs().negate()
+
+  // Update transaction log
+  await assetClientInterface.updateTxLogAndNotify({
+    assetName,
+    walletAccount,
+    txs: [
+      {
+        txId,
+        confirmations: 0,
+        coinAmount,
+        coinName: asset.name,
+        feeAmount: fee,
+        feeCoinName: assetName,
+        selfSend,
+        data: {
+          sent: selfSend ? [] : receivers,
+          rbfEnabled,
+          feePerKB: size ? fee.div(size / 1000).toBaseNumber() : undefined,
+          changeAddress: changeOutput ? ourAddress : undefined,
+          blockHeight,
+          blocksSeen: 0,
+          inputs: selectedUtxos.toJSON(),
+          replacedTxId: replaceTx ? replaceTx.txId : undefined,
+        },
+      },
+    ],
+  })
+
+  // If replacing a transaction, update the old one
+  if (replaceTx) {
+    replaceTx.data.replacedBy = txId
+    await assetClientInterface.updateTxLogAndNotify({
+      assetName,
+      walletAccount,
+      txs: [replaceTx],
+    })
+  }
+}