@exodus/bitcoin-api 2.9.1 → 2.9.3-hotfix

package/src/tx-send/index.js

@@ -24,7 +24,7 @@ import {
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
 import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data'
 
-const ASSETS_SUPPORTED_BIP_174 = [
+const ASSETS_SUPPORTED_BIP_174 = new Set([
   'bitcoin',
   'bitcoinregtest',
   'bitcointestnet',
@@ -34,7 +34,7 @@ const ASSETS_SUPPORTED_BIP_174 = [
   'digibyte',
   'qtumignition',
   'vertcoin', // is not available on mobile!
-]
+])
 
 const DUST_VALUES = {
   bitcoin: 6000,
@@ -43,23 +43,24 @@ const DUST_VALUES = {
   bitcoinsv: 5000,
   bcash: 6000,
   bgold: 6000,
-  litecoin: 60000,
+  litecoin: 60_000,
   dash: 5500,
-  dogecoin: 99999999,
-  decred: 70000,
-  digibyte: 60000,
+  dogecoin: 99_999_999,
+  decred: 70_000,
+  digibyte: 60_000,
   zcash: 1500,
-  qtumignition: 400000,
+  qtumignition: 400_000,
   ravencoin: 545,
-  lightningnetwork: 20000,
-  vertcoin: 20000,
+  lightningnetwork: 20_000,
+  vertcoin: 20_000,
 }
 
 export const getDustValue = (asset) => {
   const value = DUST_VALUES[asset.name]
   if (!value) {
-    return undefined
+    return
   }
+
   return asset.currency.baseUnit(value)
 }
 
@@ -67,16 +68,15 @@ export async function getNonWitnessTxs(asset, utxos, insightClient) {
   const rawTxs = []
 
   // BIP 174 (PSBT) requires full transaction for non-witness outputs
-  if (ASSETS_SUPPORTED_BIP_174.includes(asset.name)) {
-    const nonWitnessTxIds = utxos.txIds.filter(
-      (txId) =>
-        utxos
-          .getAddressesForTxId(txId)
-          .toAddressStrings()
-          .filter((a) => asset.address.isP2PKH(a) || asset.address.isP2SH(a)).length !== 0
+  if (ASSETS_SUPPORTED_BIP_174.has(asset.name)) {
+    const nonWitnessTxIds = utxos.txIds.filter((txId) =>
+      utxos
+        .getAddressesForTxId(txId)
+        .toAddressStrings()
+        .some((a) => asset.address.isP2PKH(a) || asset.address.isP2SH(a))
     )
 
-    if (nonWitnessTxIds.length) {
+    if (nonWitnessTxIds.length > 0) {
       for (const txId of nonWitnessTxIds) {
         // full transaction is required for non-witness outputs
         const rawData = await insightClient.fetchRawTx(txId)
@@ -93,471 +93,479 @@ const getSize = (tx) => {
   if (typeof tx.virtualSize === 'function') {
     return tx.virtualSize()
   }
+
   if (typeof tx.virtualSize === 'number') {
     return tx.virtualSize
   }
-  return undefined
 }
 
-export const getSizeAndChangeScriptFactory = ({ bitcoinjsLib = defaultBitcoinjsLib } = {}) => ({
-  assetName,
-  tx,
-  rawTx,
-  changeUtxoIndex,
-  txId,
-}) => {
-  assert(assetName, 'assetName is required')
-  assert(rawTx, 'rawTx is required')
-  assert(typeof changeUtxoIndex === 'number', 'changeUtxoIndex must be a number')
-
-  if (tx) {
-    return {
-      script: tx.outs?.[changeUtxoIndex]?.script.toString('hex'),
-      size: getSize(tx),
+export const getSizeAndChangeScriptFactory =
+  ({ bitcoinjsLib = defaultBitcoinjsLib } = {}) =>
+  ({ assetName, tx, rawTx, changeUtxoIndex, txId }) => {
+    assert(assetName, 'assetName is required')
+    assert(rawTx, 'rawTx is required')
+    assert(typeof changeUtxoIndex === 'number', 'changeUtxoIndex must be a number')
+
+    if (tx) {
+      return {
+        script: tx.outs?.[changeUtxoIndex]?.script.toString('hex'),
+        size: getSize(tx),
+      }
     }
-  }
-  // Trezor doesn't return tx!! we need to reparse it!
-  const parsedTx = bitcoinjsLib.Transaction.fromBuffer(Buffer.from(rawTx, 'hex'))
-  try {
-    return {
-      script: parsedTx.outs?.[changeUtxoIndex]?.script.toString('hex'),
-      size: getSize(parsedTx),
+
+    // Trezor doesn't return tx!! we need to reparse it!
+    const parsedTx = bitcoinjsLib.Transaction.fromBuffer(Buffer.from(rawTx, 'hex'))
+    try {
+      return {
+        script: parsedTx.outs?.[changeUtxoIndex]?.script.toString('hex'),
+        size: getSize(parsedTx),
+      }
+    } catch (e) {
+      console.warn(
+        `tx-send warning: ${assetName} cannot extract script and size from tx ${txId}. ${e}`
+      )
+      return {}
     }
-  } catch (e) {
-    console.warn(
-      `tx-send warning: ${assetName} cannot extract script and size from tx ${txId}. ${e}`
-    )
-    return {}
   }
-}
 
 // not ported from Exodus; but this demos signing / broadcasting
 // NOTE: this will be ripped out in the coming weeks
 
-export const createAndBroadcastTXFactory = ({
-  getFeeEstimator,
-  getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
-  allowUnconfirmedRbfEnabledUtxos,
-  ordinalsEnabled = false,
-}) => async (
-  { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
-  { assetClientInterface }
-) => {
-  const {
-    multipleAddressesEnabled,
-    feePerKB,
-    customFee,
-    isSendAll,
-    isExchange,
-    isBip70,
-    bumpTxId,
-    isRbfAllowed = true,
-    nft,
-    feeOpts,
-  } = options
-
-  const brc20 = options.brc20 || feeOpts?.brc20 // feeOpts is the only way I've found atm to pass brc20 param without changing the tx-send hydra module
-
-  const asset = maybeToken.baseAsset
-
-  const isToken = maybeToken.name !== asset.name
-
-  if (isToken) {
-    assert(brc20, 'brc20 is required when sending bitcoin token')
-  }
-
-  const amount = isToken ? asset.currency.ZERO : tokenAmount
-
-  const assetName = asset.name
-
-  const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
+export const createAndBroadcastTXFactory =
+  ({
+    getFeeEstimator,
+    getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
+    allowUnconfirmedRbfEnabledUtxos,
+    ordinalsEnabled = false,
+  }) =>
+  async (
+    { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
+    { assetClientInterface }
+  ) => {
+    const {
+      multipleAddressesEnabled,
+      feePerKB,
+      customFee,
+      isSendAll,
+      isExchange,
+      isBip70,
+      bumpTxId,
+      isRbfAllowed = true,
+      nft,
+      feeOpts,
+    } = options
+
+    const brc20 = options.brc20 || feeOpts?.brc20 // feeOpts is the only way I've found atm to pass brc20 param without changing the tx-send hydra module
+
+    const asset = maybeToken.baseAsset
+
+    const isToken = maybeToken.name !== asset.name
+
+    if (isToken) {
+      assert(brc20, 'brc20 is required when sending bitcoin token')
+    }
 
-  const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
+    const amount = isToken ? asset.currency.ZERO : tokenAmount
 
-  assert(
-    ordinalsEnabled || !inscriptionIds,
-    'inscriptions cannot be sent when ordinalsEnabled=false '
-  )
+    const assetName = asset.name
 
-  const shuffle = (list) => {
-    return inscriptionIds ? list : doShuffle(list) // don't shuffle when sending ordinal!!!!
-  }
+    const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
 
-  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${asset.name}`)
-  assert(
-    address || bumpTxId,
-    'should not be called without either a receiving address or to bump a tx'
-  )
+    const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
 
-  if (inscriptionIds) {
-    assert(!bumpTxId, 'only inscriptionIds or bumpTxId must be provided')
-    assert(address, 'address must be provided when sending ordinals')
-  }
-
-  const useCashAddress = asset.address.isCashAddress?.(address)
+    assert(
+      ordinalsEnabled || !inscriptionIds,
+      'inscriptions cannot be sent when ordinalsEnabled=false '
+    )
 
-  const changeAddress = multipleAddressesEnabled
-    ? await assetClientInterface.getNextChangeAddress({ assetName, walletAccount })
-    : await assetClientInterface.getReceiveAddressObject({ assetName, walletAccount })
+    const shuffle = (list) => {
+      return inscriptionIds ? list : doShuffle(list) // don't shuffle when sending ordinal!!!!
+    }
 
-  const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    assert(
+      assetClientInterface,
+      `assetClientInterface must be supplied in sendTx for ${asset.name}`
+    )
+    assert(
+      address || bumpTxId,
+      'should not be called without either a receiving address or to bump a tx'
+    )
 
-  const currentOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
-  const transferOrdinalsUtxos = inscriptionIds
-    ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos: currentOrdinalsUtxos })
-    : undefined
+    if (inscriptionIds) {
+      assert(!bumpTxId, 'only inscriptionIds or bumpTxId must be provided')
+      assert(address, 'address must be provided when sending ordinals')
+    }
 
-  const insightClient = asset.baseAsset.insightClient
-  const currency = asset.currency
-  const feeData = await assetClientInterface.getFeeConfig({ assetName })
-  const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
-  const usableUtxos = getUsableUtxos({
-    asset,
-    utxos: getUtxos({ accountState, asset }),
-    feeData,
-    txSet,
-    unconfirmedTxAncestor,
-  })
+    const useCashAddress = asset.address.isCashAddress?.(address)
+
+    const changeAddress = multipleAddressesEnabled
+      ? await assetClientInterface.getNextChangeAddress({ assetName, walletAccount })
+      : await assetClientInterface.getReceiveAddressObject({ assetName, walletAccount })
+
+    const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
+
+    const currentOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
+    const transferOrdinalsUtxos = inscriptionIds
+      ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos: currentOrdinalsUtxos })
+      : undefined
+
+    const insightClient = asset.baseAsset.insightClient
+    const currency = asset.currency
+    const feeData = await assetClientInterface.getFeeConfig({ assetName })
+    const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
+    const usableUtxos = getUsableUtxos({
+      asset,
+      utxos: getUtxos({ accountState, asset }),
+      feeData,
+      txSet,
+      unconfirmedTxAncestor,
+    })
 
-  let replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
+    let replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
 
-  if (asset.address.toLegacyAddress) {
-    address = asset.address.toLegacyAddress(address)
-  }
+    if (asset.address.toLegacyAddress) {
+      address = asset.address.toLegacyAddress(address)
+    }
 
-  if (assetName === 'digibyte') {
-    if (asset.address.isP2SH2(address)) {
+    if (assetName === 'digibyte' && asset.address.isP2SH2(address)) {
       address = asset.address.P2SH2ToP2SH(address)
     }
-  }
 
-  const rbfEnabled = feeData.rbfEnabled && !isExchange && !isBip70 && isRbfAllowed && !nft && !brc20
+    const rbfEnabled =
+      feeData.rbfEnabled && !isExchange && !isBip70 && isRbfAllowed && !nft && !brc20
+
+    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}`)
+        }
 
-  let utxosToBump
-  if (bumpTxId) {
-    const bumpTx = replaceableTxs.find(({ txId }) => txId === bumpTxId)
-    if (!bumpTx) {
-      utxosToBump = usableUtxos.getTxIdUtxos(bumpTxId)
-      if (utxosToBump.size === 0) {
-        throw new Error(`Cannot bump transaction ${bumpTxId}`)
+        replaceableTxs = []
       }
-      replaceableTxs = []
-    } else {
-      replaceableTxs = [bumpTx]
     }
-  }
 
-  const sendAmount = bumpTxId || transferOrdinalsUtxos ? asset.currency.ZERO : amount.toDefault()
-  const receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
-  const feeRate = feeData.feePerKB
-  const resolvedIsSendAll = (!rbfEnabled && feePerKB) || transferOrdinalsUtxos ? false : isSendAll
-
-  let { selectedUtxos, fee, replaceTx } = selectUtxos({
-    asset,
-    usableUtxos,
-    replaceableTxs,
-    amount: sendAmount,
-    feeRate: customFee || feeRate,
-    receiveAddress: receiveAddress,
-    isSendAll: resolvedIsSendAll,
-    getFeeEstimator: (asset, { feePerKB, ...options }) => getFeeEstimator(asset, feePerKB, options),
-    mustSpendUtxos: utxosToBump,
-    allowUnconfirmedRbfEnabledUtxos,
-    unconfirmedTxAncestor,
-    inscriptionIds,
-  })
-
-  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,
-  // then something is wrong because we can't actually bump the tx.
-  // This shouldn't happen but might due to either the tx confirming before accelerate was
-  // pressed, or if the change was already spent from another wallet.
-  if (bumpTxId && (!selectedUtxos || (replaceTx && replaceTx.txId !== bumpTxId))) {
-    throw new Error(`Unable to bump ${bumpTxId}`)
-  }
-  if (transferOrdinalsUtxos) {
-    selectedUtxos = transferOrdinalsUtxos.union(selectedUtxos)
-  }
-  if (replaceTx) {
-    replaceTx = replaceTx.clone()
-    replaceTx = replaceTx.update({ data: { ...replaceTx.data } })
-    replaceTx.data.sent = replaceTx.data.sent.map((to) => {
-      return { ...to, amount: parseCurrency(to.amount, asset.currency) }
+    const sendAmount = bumpTxId || transferOrdinalsUtxos ? asset.currency.ZERO : amount.toDefault()
+    const receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
+    const feeRate = feeData.feePerKB
+    const resolvedIsSendAll = (!rbfEnabled && feePerKB) || transferOrdinalsUtxos ? false : isSendAll
+
+    let { selectedUtxos, fee, replaceTx } = selectUtxos({
+      asset,
+      usableUtxos,
+      replaceableTxs,
+      amount: sendAmount,
+      feeRate: customFee || feeRate,
+      receiveAddress,
+      isSendAll: resolvedIsSendAll,
+      getFeeEstimator: (asset, { feePerKB, ...options }) =>
+        getFeeEstimator(asset, feePerKB, options),
+      mustSpendUtxos: utxosToBump,
+      allowUnconfirmedRbfEnabledUtxos,
+      unconfirmedTxAncestor,
+      inscriptionIds,
     })
-    selectedUtxos = selectedUtxos.union(
-      // how to avoid replace tx inputs when inputs are ordinals? !!!!
-      UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
-    )
-  }
-  const addressPathsMap = selectedUtxos.getAddressPathsMap()
 
-  // transform UTXO object to raw
-  const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), rbfEnabled))
+    if (!selectedUtxos && !replaceTx) throw new Error('Not enough funds.')
 
-  let outputs
-  if (replaceTx) {
-    outputs = replaceTx.data.sent.map(({ address, amount }) =>
-      createOutput(assetName, address, amount)
-    )
-  } else {
-    outputs = []
-  }
+    // 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,
+    // then something is wrong because we can't actually bump the tx.
+    // This shouldn't happen but might due to either the tx confirming before accelerate was
+    // pressed, or if the change was already spent from another wallet.
+    if (bumpTxId && (!selectedUtxos || (replaceTx && replaceTx.txId !== bumpTxId))) {
+      throw new Error(`Unable to bump ${bumpTxId}`)
+    }
 
-  let sendOutput
-  if (address) {
     if (transferOrdinalsUtxos) {
-      outputs.push(
-        ...transferOrdinalsUtxos
-          .toArray()
-          .map((ordinalUtxo) => createOutput(assetName, address, ordinalUtxo.value))
+      selectedUtxos = transferOrdinalsUtxos.union(selectedUtxos)
+    }
+
+    if (replaceTx) {
+      replaceTx = replaceTx.clone()
+      replaceTx = replaceTx.update({ data: { ...replaceTx.data } })
+      replaceTx.data.sent = replaceTx.data.sent.map((to) => {
+        return { ...to, amount: parseCurrency(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 })
       )
-    } else {
-      sendOutput = createOutput(assetName, address, sendAmount)
-      outputs.push(sendOutput)
     }
-  }
 
-  const totalAmount = replaceTx
-    ? replaceTx.data.sent.reduce((total, { amount }) => total.add(amount), sendAmount)
-    : sendAmount
-
-  const change = selectedUtxos.value
-    .sub(totalAmount)
-    .sub(transferOrdinalsUtxos?.value || currency.ZERO)
-    .sub(fee)
-  const dust = getDustValue(asset)
-  let ourAddress = replaceTx?.data?.changeAddress || changeAddress
-  if (asset.address.toLegacyAddress) {
-    const legacyAddress = asset.address.toLegacyAddress(ourAddress.address)
-    ourAddress = Address.create(legacyAddress, ourAddress.meta)
-  }
-  let changeOutput
-  if (change.gte(dust)) {
-    changeOutput = createOutput(
-      assetName,
-      ourAddress.address ? 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)
-  }
+    const addressPathsMap = selectedUtxos.getAddressPathsMap()
 
-  outputs = replaceTx ? outputs : shuffle(outputs)
-  const blockHeight = ['zcash', 'bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)
-    ? await insightClient.fetchBlockHeight()
-    : 0
-
-  // desktop/mobile shared format
-  const unsignedTx = {
-    txData: {
-      inputs,
-      outputs,
-    },
-    txMeta: {
-      useCashAddress, // for trezor to show the receiver cash address
-      addressPathsMap,
-      blockHeight,
-    },
-  }
+    // transform UTXO object to raw
+    const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), rbfEnabled))
+
+    let outputs
+    if (replaceTx) {
+      outputs = replaceTx.data.sent.map(({ address, amount }) =>
+        createOutput(assetName, address, amount)
+      )
+    } else {
+      outputs = []
+    }
 
-  const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
-  Object.assign(unsignedTx.txMeta, { rawTxs: nonWitnessTxs })
-  const { rawTx, txId, tx } = await assetClientInterface.signTransaction({
-    assetName,
-    unsignedTx,
-    walletAccount,
-  })
-
-  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)
+    let sendOutput
+    if (address) {
+      if (transferOrdinalsUtxos) {
+        outputs.push(
+          ...transferOrdinalsUtxos
+            .toArray()
+            .map((ordinalUtxo) => createOutput(assetName, address, ordinalUtxo.value))
         )
-          e.finalError = true
-        throw e
+      } else {
+        sendOutput = createOutput(assetName, address, sendAmount)
+        outputs.push(sendOutput)
       }
-    },
-    { delayTimesMs: ['10s'] }
-  )
-
-  try {
-    await broadcastTxWithRetry(rawTx.toString('hex'))
-  } 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 (err.message.match(/Insight Broadcast HTTP Error.*Missing inputs/i)) {
-      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?
-        allUtxos: usableUtxos.toJSON(),
-      })
-      throw err
+    }
+
+    const totalAmount = replaceTx
+      ? replaceTx.data.sent.reduce((total, { amount }) => total.add(amount), sendAmount)
+      : sendAmount
+
+    const change = selectedUtxos.value
+      .sub(totalAmount)
+      .sub(transferOrdinalsUtxos?.value || currency.ZERO)
+      .sub(fee)
+    const dust = getDustValue(asset)
+    let ourAddress = replaceTx?.data?.changeAddress || changeAddress
+    if (asset.address.toLegacyAddress) {
+      const legacyAddress = asset.address.toLegacyAddress(ourAddress.address)
+      ourAddress = Address.create(legacyAddress, ourAddress.meta)
+    }
+
+    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 {
-      throw err
+      // If we don't have enough for a change output, then all remaining dust is just added to fee
+      fee = fee.add(change)
     }
-  }
 
-  function findUtxoIndex(output) {
-    let utxoIndex = -1
-    if (output) {
-      for (let i = 0; i < outputs.length; i++) {
-        const [address, amount] = outputs[i]
-        if (output[0] === address && output[1] === amount) {
-          utxoIndex = i
-          break
-        }
-      }
+    outputs = replaceTx ? outputs : shuffle(outputs)
+    const blockHeight = ['zcash', 'bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)
+      ? await insightClient.fetchBlockHeight()
+      : 0
+
+    // desktop/mobile shared format
+    const unsignedTx = {
+      txData: {
+        inputs,
+        outputs,
+      },
+      txMeta: {
+        useCashAddress, // for trezor to show the receiver cash address
+        addressPathsMap,
+        blockHeight,
+      },
     }
-    return utxoIndex
-  }
 
-  const changeUtxoIndex = findUtxoIndex(changeOutput)
-  const sendUtxoIndex = findUtxoIndex(sendOutput)
+    const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
+    Object.assign(unsignedTx.txMeta, { rawTxs: nonWitnessTxs })
+    const { rawTx, txId, tx } = await assetClientInterface.signTransaction({
+      assetName,
+      unsignedTx,
+      walletAccount,
+    })
 
-  const { script, size } = getSizeAndChangeScript({ assetName, tx, rawTx, changeUtxoIndex, txId })
+    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'] }
+    )
 
-  // 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,
+    try {
+      await broadcastTxWithRetry(rawTx.toString('hex'))
+    } 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)) {
+        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?
+          allUtxos: usableUtxos.toJSON(),
+        })
+        throw err
+      } else {
+        throw err
+      }
     }
 
-    knownBalanceUtxoIds.push(`${changeUtxo.txId}:${changeUtxo.vout}`.toLowerCase())
-    remainingUtxos = remainingUtxos.addUtxo(changeUtxo)
-  }
-  if (replaceTx) {
-    remainingUtxos = remainingUtxos.difference(remainingUtxos.getTxIdUtxos(replaceTx.txId))
-  }
+    function findUtxoIndex(output) {
+      let utxoIndex = -1
+      if (output) {
+        for (const [i, [address, amount]] of outputs.entries()) {
+          if (output[0] === address && output[1] === amount) {
+            utxoIndex = i
+            break
+          }
+        }
+      }
 
-  const remainingOrdinalsUtxos = transferOrdinalsUtxos
-    ? currentOrdinalsUtxos.difference(transferOrdinalsUtxos)
-    : currentOrdinalsUtxos
-
-  await assetClientInterface.updateAccountState({
-    assetName,
-    walletAccount,
-    newData: {
-      utxos: remainingUtxos,
-      ordinalsUtxos: remainingOrdinalsUtxos,
-      knownBalanceUtxoIds,
-    },
-  })
-
-  const walletAddresses = await assetClientInterface.getReceiveAddresses({
-    walletAccount,
-    assetName,
-    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
-    : walletAddresses.some((receiveAddress) => String(receiveAddress) === String(address))
-
-  const displayReceiveAddress = asset.address.displayAddress?.(receiveAddress) || receiveAddress
-
-  const receivers = bumpTxId
-    ? replaceTx
-      ? replaceTx.data.sent
-      : []
-    : replaceTx
-    ? replaceTx.data.sent.concat([{ address: displayReceiveAddress, amount }])
-    : [{ address: displayReceiveAddress, amount }]
-
-  const calculateCoinAmount = () => {
-    if (selfSend) {
-      return maybeToken.currency.ZERO
-    } else if (isToken) {
-      return tokenAmount.abs().negate()
-    } else if (nft) {
-      return transferOrdinalsUtxos.value.abs().negate()
-    } else {
-      return totalAmount.abs().negate()
+      return utxoIndex
     }
-  }
 
-  const coinAmount = calculateCoinAmount()
+    const changeUtxoIndex = findUtxoIndex(changeOutput)
+    const sendUtxoIndex = findUtxoIndex(sendOutput)
+
+    const { script, size } = getSizeAndChangeScript({ assetName, tx, rawTx, changeUtxoIndex, txId })
 
-  await assetClientInterface.updateTxLogAndNotify({
-    assetName: maybeToken.name,
-    walletAccount,
-    txs: [
-      {
+    // 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,
-        coinAmount,
-        coinName: maybeToken.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,
-        },
+        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,
       },
-    ],
-  })
+    })
 
-  // 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({
+    const walletAddressObjects = await assetClientInterface.getReceiveAddresses({
+      walletAccount,
       assetName,
+      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 }]
+        : [{ address: displayReceiveAddress, amount }]
+
+    const calculateCoinAmount = () => {
+      if (selfSend) {
+        return maybeToken.currency.ZERO
+      }
+
+      if (isToken) {
+        return tokenAmount.abs().negate()
+      }
+
+      if (nft) {
+        return transferOrdinalsUtxos.value.abs().negate()
+      }
+
+      return totalAmount.abs().negate()
+    }
+
+    const coinAmount = calculateCoinAmount()
+
+    await assetClientInterface.updateTxLogAndNotify({
+      assetName: maybeToken.name,
       walletAccount,
-      txs: [replaceTx],
+      txs: [
+        {
+          txId,
+          confirmations: 0,
+          coinAmount,
+          coinName: maybeToken.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,
+          },
+        },
+      ],
     })
-  }
 
-  return {
-    txId,
-    sendUtxoIndex,
-    sendAmount: sendAmount.toBaseNumber(),
-    replacedTxId: replaceTx?.txId,
+    // 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,
+      sendAmount: sendAmount.toBaseNumber(),
+      replacedTxId: replaceTx?.txId,
+    }
   }
-}
 
 export function createInputs(assetName, ...rest) {
   switch (assetName) {