@exodus/bitcoin-api 4.1.2 → 4.1.4

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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)
+
+
+### Bug Fixes
+
+
+* fix: remove isBip70 from bitcoin libs (#6660)
+
+* fix: remove unused bitcoin.api.prepareSendTx (#6662)
+
+
+
 ## [4.1.2](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.1...@exodus/bitcoin-api@4.1.2) (2025-10-09)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "4.1.2",
+  "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": "6237b0d98791ed9e6290260947068d2600bf8270"
+  "gitHead": "0efd644cc413c308688b43c8563b172b3a80e3fa"
 }

package/src/fee/get-fee-resolver.js

@@ -2,13 +2,7 @@ import assert from 'minimalistic-assert'
 
 import { findUnconfirmedSentRbfTxs } from '../tx-utils.js'
 import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data.js'
-import {
-  getInscriptionIds,
-  getOrdinalsUtxos,
-  getTransferOrdinalsUtxos,
-  getUsableUtxos,
-  getUtxos,
-} from '../utxos-utils.js'
+import { getUsableUtxos, getUtxos } from '../utxos-utils.js'
 import { canBumpTx } from './can-bump-tx.js'
 import { getUtxosData } from './utxo-selector.js'
 
@@ -40,17 +34,9 @@ export class GetFeeResolver {
     amount,
     customFee,
     isSendAll,
-    nft, // sending one nft
     receiveAddress,
     taprootInputWitnessSize,
   }) => {
-    if (nft) {
-      assert(!amount, 'amount must not be provided when nft is provided!!!')
-      assert(!isSendAll, 'isSendAll must not be provided when nft is provided!!!')
-    }
-
-    const inscriptionIds = getInscriptionIds({ nft })
-
     const { fee, unspendableFee, extraFeeData } = this.#getUtxosData({
       asset,
       accountState,
@@ -60,7 +46,6 @@ export class GetFeeResolver {
       amount,
       customFee,
       isSendAll,
-      inscriptionIds,
       taprootInputWitnessSize,
     })
     return { fee, unspendableFee, extraFeeData }
@@ -75,7 +60,6 @@ export class GetFeeResolver {
     amount,
     customFee,
     isSendAll,
-    inscriptionIds,
     taprootInputWitnessSize,
   }) => {
     assert(asset, 'asset must be provided')
@@ -87,12 +71,6 @@ export class GetFeeResolver {
     const utxos = getUtxos({ accountState, asset })
     const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
 
-    const ordinalsUtxos = getOrdinalsUtxos({ accountState, asset })
-
-    const transferOrdinalsUtxos = inscriptionIds
-      ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos })
-      : undefined
-
     const usableUtxos = getUsableUtxos({
       asset,
       utxos,
@@ -110,8 +88,6 @@ export class GetFeeResolver {
       amount,
       feeRate: feePerKB,
       receiveAddress,
-      transferOrdinalsUtxos,
-      inscriptionIds,
       isSendAll,
       getFeeEstimator: this.#getFeeEstimator,
       allowUnconfirmedRbfEnabledUtxos: this.#allowUnconfirmedRbfEnabledUtxos,

package/src/fee/utxo-selector.js

@@ -11,11 +11,7 @@ const { sortBy } = lodash
 
 const MIN_RELAY_FEE = 1000
 
-const getBestReceiveAddresses = ({ asset, receiveAddress, inscriptionIds }) => {
-  if (inscriptionIds) {
-    return receiveAddress || 'P2TR'
-  }
-
+const getBestReceiveAddresses = ({ asset, receiveAddress }) => {
   if (receiveAddress === null) {
     return null
   }
@@ -38,20 +34,15 @@ export const selectUtxos = ({
   mustSpendUtxos,
   allowUnconfirmedRbfEnabledUtxos,
   unconfirmedTxAncestor,
-  inscriptionIds, // for each inscription transfer, we need to calculate one more input and one more output
-  transferOrdinalsUtxos, // to calculate the size of the input
   taprootInputWitnessSize,
   changeAddressType = 'P2PKH',
 }) => {
   const resolvedReceiveAddresses = getBestReceiveAddresses({
     asset,
     receiveAddress,
-    inscriptionIds,
   })
 
-  if (inscriptionIds) {
-    receiveAddresses.push(...inscriptionIds.map(() => resolvedReceiveAddresses))
-  } else if (receiveAddresses.length === 0) {
+  if (receiveAddresses.length === 0) {
     receiveAddresses.push(resolvedReceiveAddresses)
   }
 
@@ -66,7 +57,6 @@ export const selectUtxos = ({
   // We can only replace for a sendAll if only 1 replaceable tx and no unconfirmed utxos
   const confirmedUtxosArray = getConfirmedUtxos({ asset, utxos: usableUtxos }).toArray()
   const canReplace =
-    !inscriptionIds &&
     !mustSpendUtxos &&
     !disableReplacement &&
     replaceableTxs &&
@@ -86,7 +76,6 @@ export const selectUtxos = ({
       }
 
       const replaceFeeEstimator = getFeeEstimator(asset, { feePerKB, unconfirmedTxAncestor })
-      // how to avoid replace tx inputs when inputs are ordinals? !!!!
       const inputs = UtxoCollection.fromJSON(tx.data.inputs, { currency })
       const outputs = isSendAll
         ? tx.data.sent.map(({ address }) => address)
@@ -211,15 +200,10 @@ export const selectUtxos = ({
     selectedUtxosValue = selectedUtxosValue.add(newUtxo.value)
   }
 
-  let selectedUtxos = (transferOrdinalsUtxos || UtxoCollection.createEmpty({ currency })).union(
-    UtxoCollection.fromArray(selectedUtxosArray, { currency })
-  ) // extremelly important, orden must be kept!!! ordinals utxos go first!!!
+  let selectedUtxos = UtxoCollection.fromArray(selectedUtxosArray, { currency })
 
   // start figuring out fees
-  const outputs =
-    amount.isZero && !inscriptionIds
-      ? [changeAddressType]
-      : [...receiveAddresses, changeAddressType]
+  const outputs = amount.isZero ? [changeAddressType] : [...receiveAddresses, changeAddressType]
 
   let fee = feeEstimator({ inputs: selectedUtxos, outputs, taprootInputWitnessSize })
 
@@ -259,8 +243,6 @@ export const getUtxosData = ({
   disableReplacement,
   mustSpendUtxos,
   allowUnconfirmedRbfEnabledUtxos,
-  inscriptionIds,
-  transferOrdinalsUtxos,
   unconfirmedTxAncestor,
   utxosDescendingOrder,
   taprootInputWitnessSize,
@@ -283,8 +265,6 @@ export const getUtxosData = ({
     mustSpendUtxos,
     allowUnconfirmedRbfEnabledUtxos,
     unconfirmedTxAncestor,
-    inscriptionIds,
-    transferOrdinalsUtxos,
     utxosDescendingOrder,
     taprootInputWitnessSize,
     changeAddressType,

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

@@ -7,13 +7,7 @@ import { parseCurrency, serializeCurrency } from '../fee/fee-utils.js'
 import { selectUtxos } from '../fee/utxo-selector.js'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils.js'
 import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data.js'
-import {
-  getInscriptionIds,
-  getOrdinalsUtxos,
-  getTransferOrdinalsUtxos,
-  getUsableUtxos,
-  getUtxos,
-} from '../utxos-utils.js'
+import { getUsableUtxos, getUtxos } from '../utxos-utils.js'
 import { createInputs, createOutput, getBlockHeight, getNonWitnessTxs } from './tx-create-utils.js'
 
 async function createUnsignedTx({
@@ -64,13 +58,11 @@ const transferHandler = {
     customFee,
     isSendAll,
     bumpTxId,
-    nft,
     isExchange,
     isRbfAllowed,
     taprootInputWitnessSize,
     accountState,
     feeData,
-    ordinalsEnabled,
     getFeeEstimator,
     allowUnconfirmedRbfEnabledUtxos,
     utxosDescendingOrder,
@@ -84,18 +76,11 @@ const transferHandler = {
     const blockHeight = providedBlockHeight || (await getBlockHeight({ assetName, insightClient }))
 
     const rbfEnabled =
-      providedRbfEnabled || (updatedFeeData.rbfEnabled && !isExchange && isRbfAllowed && !nft)
-
-    const inscriptionIds = getInscriptionIds({ nft })
-
-    assert(
-      ordinalsEnabled || !inscriptionIds,
-      'inscriptions cannot be sent when ordinalsEnabled=false '
-    )
+      providedRbfEnabled || (updatedFeeData.rbfEnabled && !isExchange && isRbfAllowed)
 
     const shuffle = (list) => {
       // Using full lodash.shuffle notation so it can be mocked with spyOn in tests
-      return inscriptionIds ? list : lodash.shuffle(list) // don't shuffle when sending ordinal!!!!
+      return lodash.shuffle(list)
     }
 
     assert(
@@ -107,11 +92,6 @@ const transferHandler = {
       'should not be called without either a receiving toAddress or to bump a tx'
     )
 
-    if (inscriptionIds) {
-      assert(!bumpTxId, 'only inscriptionIds or bumpTxId must be provided')
-      assert(toAddress, 'toAddress must be provided when sending ordinals')
-    }
-
     const useCashAddress = asset.address.isCashAddress?.(toAddress)
 
     const changeAddress = multipleAddressesEnabled
@@ -120,11 +100,6 @@ const transferHandler = {
 
     const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
 
-    const currentOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
-    const transferOrdinalsUtxos = inscriptionIds
-      ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos: currentOrdinalsUtxos })
-      : undefined
-
     const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
     const usableUtxos = getUsableUtxos({
       asset,
@@ -160,14 +135,14 @@ const transferHandler = {
       }
     }
 
-    const sendAmount = bumpTxId || transferOrdinalsUtxos ? asset.currency.ZERO : amount
+    const sendAmount = bumpTxId ? asset.currency.ZERO : amount
     const receiveAddress = bumpTxId
       ? replaceableTxs.length > 0
         ? null
         : changeAddressType
       : processedAddress
     const feeRate = updatedFeeData.feePerKB
-    const resolvedIsSendAll = (!rbfEnabled && feePerKB) || transferOrdinalsUtxos ? false : isSendAll
+    const resolvedIsSendAll = !rbfEnabled && feePerKB ? false : isSendAll
 
     let { selectedUtxos, fee, replaceTx } = selectUtxos({
       asset,
@@ -182,8 +157,6 @@ const transferHandler = {
       mustSpendUtxos: utxosToBump,
       allowUnconfirmedRbfEnabledUtxos,
       unconfirmedTxAncestor,
-      inscriptionIds,
-      transferOrdinalsUtxos,
       utxosDescendingOrder,
       taprootInputWitnessSize,
       changeAddressType,
@@ -207,7 +180,6 @@ const transferHandler = {
         return { ...to, amount: serializeCurrency(to.amount, asset.currency) }
       })
       selectedUtxos = selectedUtxos.union(
-        // how to avoid replace tx inputs when inputs are ordinals? !!!!
         UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
       )
     }
@@ -225,16 +197,8 @@ const transferHandler = {
     // Send output
     let sendOutput
     if (processedAddress) {
-      if (transferOrdinalsUtxos) {
-        outputs.push(
-          ...transferOrdinalsUtxos
-            .toArray()
-            .map((ordinalUtxo) => createOutput(assetName, processedAddress, ordinalUtxo.value))
-        )
-      } else {
-        sendOutput = createOutput(assetName, processedAddress, sendAmount)
-        outputs.push(sendOutput)
-      }
+      sendOutput = createOutput(assetName, processedAddress, sendAmount)
+      outputs.push(sendOutput)
     }
 
     const totalAmount = replaceTx
@@ -244,10 +208,7 @@ const transferHandler = {
         )
       : sendAmount
 
-    const change = selectedUtxos.value
-      .sub(totalAmount)
-      .sub(transferOrdinalsUtxos?.value || asset.currency.ZERO)
-      .sub(fee)
+    const change = selectedUtxos.value.sub(totalAmount).sub(fee)
     const dust = getChangeDustValue(asset)
     let ourAddress = replaceTx?.data?.changeAddress || changeAddress
     if (asset.address.toLegacyAddress) {
@@ -282,30 +243,28 @@ const transferHandler = {
     })
 
     return {
-      amount,
-      change,
-      totalAmount,
-      currentOrdinalsUtxos,
-      inscriptionIds,
-      address: processedAddress,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      transferOrdinalsUtxos,
-      replaceTx,
-      sendOutput,
-      changeOutput,
       unsignedTx,
+      fee,
+      metadata: {
+        amount,
+        change,
+        totalAmount,
+        address: processedAddress,
+        ourAddress,
+        receiveAddress,
+        sendAmount,
+        usableUtxos,
+        selectedUtxos,
+        replaceTx,
+        sendOutput,
+        changeOutput,
+      },
     }
   },
 }
 
 export const createTxFactory =
   ({
-    ordinalsEnabled,
     getFeeEstimator,
     allowUnconfirmedRbfEnabledUtxos,
     utxosDescendingOrder,
@@ -325,7 +284,6 @@ export const createTxFactory =
     customFee,
     isSendAll,
     bumpTxId,
-    nft,
     isExchange,
     isRbfAllowed,
     taprootInputWitnessSize,
@@ -351,13 +309,11 @@ export const createTxFactory =
       customFee,
       isSendAll,
       bumpTxId,
-      nft,
       isExchange,
       isRbfAllowed,
       taprootInputWitnessSize,
       accountState,
       feeData,
-      ordinalsEnabled,
       getFeeEstimator,
       allowUnconfirmedRbfEnabledUtxos,
       utxosDescendingOrder,

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
@@ -109,13 +108,11 @@ const getPrepareSendTransaction = async ({
   changeAddressType,
   getFeeEstimator,
   options,
-  ordinalsEnabled,
   rbfEnabled,
   utxosDescendingOrder,
   walletAccount,
 }) => {
   const createTx = createTxFactory({
-    ordinalsEnabled,
     getFeeEstimator,
     allowUnconfirmedRbfEnabledUtxos,
     utxosDescendingOrder,
@@ -142,21 +139,20 @@ export const createAndBroadcastTXFactory =
     getFeeEstimator,
     getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
     allowUnconfirmedRbfEnabledUtxos,
-    ordinalsEnabled = false,
     utxosDescendingOrder,
     assetClientInterface,
     changeAddressType,
   }) =>
   async ({ asset, walletAccount, address, amount, options }) => {
     // Prepare transaction
-    const { bumpTxId, nft, isExchange, isRbfAllowed = true } = options
+    const { bumpTxId, isExchange, isRbfAllowed = true } = 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 && !nft
+    const rbfEnabled = feeData.rbfEnabled && !isExchange && isRbfAllowed
 
     // blockHeight
     const blockHeight = await getBlockHeight({ assetName, insightClient })
@@ -171,31 +167,17 @@ export const createAndBroadcastTXFactory =
       changeAddressType,
       getFeeEstimator,
       options,
-      ordinalsEnabled,
       rbfEnabled,
       utxosDescendingOrder,
       walletAccount,
     })
-    const {
-      change,
-      totalAmount,
-      currentOrdinalsUtxos,
-      inscriptionIds,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      transferOrdinalsUtxos,
-      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({
@@ -206,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) {
@@ -263,135 +219,35 @@ export const createAndBroadcastTXFactory =
     const changeUtxoIndex = findUtxoIndex(changeOutput)
     const sendUtxoIndex = findUtxoIndex(sendOutput)
 
-    const { script, size } = getSizeAndChangeScript({ assetName, tx, rawTx, changeUtxoIndex, txId })
-
-    // for ordinals, used to allow users spending change utxos even when unconfirmed and ordinals are unknown
-    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))
-    }
-
-    const remainingOrdinalsUtxos = transferOrdinalsUtxos
-      ? currentOrdinalsUtxos.difference(transferOrdinalsUtxos)
-      : currentOrdinalsUtxos
-
-    await assetClientInterface.updateAccountState({
-      assetName,
-      walletAccount,
-      newData: {
-        utxos: remainingUtxos,
-        ordinalsUtxos: remainingOrdinalsUtxos,
-        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
-      }
-
-      if (nft) {
-        return transferOrdinalsUtxos.value.abs().negate()
-      }
-
-      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,
-            nftId: nft ? `${assetName}:${nft.tokenId}` : undefined, // it allows BE to load the nft info while the nft is in transit
-            inscriptionsIndexed: ordinalsEnabled ? true : undefined,
-            sentInscriptions: inscriptionIds
-              ? inscriptionIds.map((inscriptionId) => {
-                  return {
-                    inscriptionId,
-                    offset: 0,
-                    value: 0,
-                  }
-                })
-              : 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],
+    })
+  }
+}