@exodus/bitcoin-api 4.1.3 → 4.1.4

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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.4",
   "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": "0efd644cc413c308688b43c8563b172b3a80e3fa"
 }

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

@@ -243,20 +243,22 @@ const transferHandler = {
     })
 
     return {
-      amount,
-      change,
-      totalAmount,
-      address: processedAddress,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      replaceTx,
-      sendOutput,
-      changeOutput,
       unsignedTx,
+      fee,
+      metadata: {
+        amount,
+        change,
+        totalAmount,
+        address: processedAddress,
+        ourAddress,
+        receiveAddress,
+        sendAmount,
+        usableUtxos,
+        selectedUtxos,
+        replaceTx,
+        sendOutput,
+        changeOutput,
+      },
     }
   },
 }

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,10 @@
 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
@@ -172,23 +171,13 @@ export const createAndBroadcastTXFactory =
       utxosDescendingOrder,
       walletAccount,
     })
-    const {
-      change,
-      totalAmount,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      replaceTx,
-      sendOutput,
-      changeOutput,
-      unsignedTx,
-    } = transactionDescriptor
+
+    const { unsignedTx, fee, metadata } = transactionDescriptor
+    const { sendAmount, usableUtxos, replaceTx, sendOutput, changeOutput } = metadata
+
     const outputs = unsignedTx.txData.outputs
 
-    address = transactionDescriptor.address
+    address = metadata.address
 
     // Sign transaction
     const { rawTx, txId, tx } = await signTransaction({
@@ -199,44 +188,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 +219,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],
+    })
+  }
+}