@exodus/bitcoin-api 4.1.1 → 4.1.3

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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)
+
+
+### Bug Fixes
+
+
+* fix: remove isBip70 from bitcoin libs (#6660)
+
+* fix: remove unused bitcoin.api.prepareSendTx (#6662)
+
+
+
 ## [4.1.1](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.1.0...@exodus/bitcoin-api@4.1.1) (2025-09-30)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "Bitcoin transaction and fee monitors, RPC with the blockchain node, other networking code.",
   "type": "module",
   "main": "src/index.js",
@@ -12,7 +12,8 @@
   "author": "Exodus Movement, Inc.",
   "license": "MIT",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   },
   "scripts": {
     "test": "run -T exodus-test --jest",
@@ -59,5 +60,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "0d64e50fa0875dc526ce20e3be748f50c8483e9e"
+  "gitHead": "48e0d08e2fe044fb98d2fb16fc790f642a3c1eb2"
 }

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/move-funds.js

@@ -3,7 +3,7 @@ import { Address, UtxoCollection } from '@exodus/models'
 import assert from 'minimalistic-assert'
 import wif from 'wif'
 
-import { createInputs, createOutput, getNonWitnessTxs } from './tx-send/index.js'
+import { createInputs, createOutput, getNonWitnessTxs } from './tx-create/tx-create-utils.js'
 
 const isValidPrivateKey = (privateKey) => {
   try {

package/src/send-validation.js

@@ -5,16 +5,6 @@ import { getSendDustValue as getDustValue } from './dust.js'
 
 const { createValidator, FIELDS, PRIORITY_LEVELS, VALIDATION_TYPES } = sendValidationModel
 
-const bip70Validator = createValidator({
-  id: 'BIP70',
-  type: VALIDATION_TYPES.ERROR,
-  priority: PRIORITY_LEVELS.MIDDLE,
-  field: FIELDS.ADDRESS,
-  shouldValidate: ({ bip70 }) => !!bip70,
-  isValid: async ({ bip70 }) => !bip70.isInvalid(),
-  getMessage: () => t(`The payment request is invalid.`),
-})
-
 const bcnLegacyAddressValidator = createValidator({
   type: VALIDATION_TYPES.WARN,
   priority: PRIORITY_LEVELS.BASE,
@@ -80,9 +70,4 @@ const bitcoinCpfpWarning = createValidator({
   },
 })
 
-export default [
-  bitcoinCpfpWarning,
-  bip70Validator,
-  bcnLegacyAddressValidator,
-  notEnoughOutputValidator,
-]
+export default [bitcoinCpfpWarning, bcnLegacyAddressValidator, notEnoughOutputValidator]

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

@@ -0,0 +1,321 @@
+import { Address, UtxoCollection } from '@exodus/models'
+import lodash from 'lodash'
+import assert from 'minimalistic-assert'
+
+import { getChangeDustValue } from '../dust.js'
+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 { getUsableUtxos, getUtxos } from '../utxos-utils.js'
+import { createInputs, createOutput, getBlockHeight, getNonWitnessTxs } from './tx-create-utils.js'
+
+async function createUnsignedTx({
+  inputs,
+  outputs,
+  useCashAddress,
+  addressPathsMap,
+  blockHeight,
+  asset,
+  selectedUtxos,
+  insightClient,
+}) {
+  const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
+
+  return {
+    txData: {
+      inputs,
+      outputs,
+    },
+    txMeta: {
+      useCashAddress, // for trezor to show the receiver cash address
+      addressPathsMap,
+      blockHeight,
+      rawTxs: nonWitnessTxs,
+    },
+  }
+}
+
+const getTxHandler = (type) => {
+  switch (type) {
+    case 'transfer':
+      return transferHandler
+    default:
+      throw new Error(`Unknown transaction type: ${type}`)
+  }
+}
+
+const transferHandler = {
+  buildTransaction: async ({
+    asset,
+    walletAccount,
+    toAddress,
+    amount,
+    blockHeight: providedBlockHeight,
+    rbfEnabled: providedRbfEnabled,
+    multipleAddressesEnabled,
+    feePerKB,
+    customFee,
+    isSendAll,
+    bumpTxId,
+    isExchange,
+    isRbfAllowed,
+    taprootInputWitnessSize,
+    accountState,
+    feeData,
+    getFeeEstimator,
+    allowUnconfirmedRbfEnabledUtxos,
+    utxosDescendingOrder,
+    assetClientInterface,
+    changeAddressType,
+  }) => {
+    const assetName = asset.name
+    const updatedFeeData = { ...feeData, feePerKB: feePerKB ?? feeData.feePerKB }
+    const insightClient = asset.baseAsset.insightClient
+
+    const blockHeight = providedBlockHeight || (await getBlockHeight({ assetName, insightClient }))
+
+    const rbfEnabled =
+      providedRbfEnabled || (updatedFeeData.rbfEnabled && !isExchange && isRbfAllowed)
+
+    const shuffle = (list) => {
+      // Using full lodash.shuffle notation so it can be mocked with spyOn in tests
+      return lodash.shuffle(list)
+    }
+
+    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'
+    )
+
+    const useCashAddress = asset.address.isCashAddress?.(toAddress)
+
+    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,
+    })
+
+    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,
+      replaceableTxs,
+      amount: sendAmount,
+      feeRate: customFee || feeRate,
+      receiveAddress,
+      isSendAll: resolvedIsSendAll,
+      getFeeEstimator: (asset, { feePerKB, ...options }) =>
+        getFeeEstimator(asset, feePerKB, options),
+      mustSpendUtxos: utxosToBump,
+      allowUnconfirmedRbfEnabledUtxos,
+      unconfirmedTxAncestor,
+      utxosDescendingOrder,
+      taprootInputWitnessSize,
+      changeAddressType,
+    })
+
+    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 (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 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)
+    }
+
+    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)
+    }
+
+    // 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)
+    }
+
+    outputs = replaceTx ? outputs : shuffle(outputs)
+
+    const unsignedTx = await createUnsignedTx({
+      inputs,
+      outputs,
+      useCashAddress,
+      addressPathsMap,
+      blockHeight,
+      asset,
+      selectedUtxos,
+      insightClient,
+    })
+
+    return {
+      amount,
+      change,
+      totalAmount,
+      address: processedAddress,
+      ourAddress,
+      receiveAddress,
+      sendAmount,
+      fee,
+      usableUtxos,
+      selectedUtxos,
+      replaceTx,
+      sendOutput,
+      changeOutput,
+      unsignedTx,
+    }
+  },
+}
+
+export const createTxFactory =
+  ({
+    getFeeEstimator,
+    allowUnconfirmedRbfEnabledUtxos,
+    utxosDescendingOrder,
+    assetClientInterface,
+    changeAddressType,
+  }) =>
+  async ({
+    asset,
+    walletAccount,
+    type,
+    toAddress,
+    amount,
+    blockHeight,
+    rbfEnabled,
+    multipleAddressesEnabled,
+    feePerKB,
+    customFee,
+    isSendAll,
+    bumpTxId,
+    isExchange,
+    isRbfAllowed,
+    taprootInputWitnessSize,
+  }) => {
+    const assetName = asset.name
+    const accountState = await assetClientInterface.getAccountState({
+      assetName,
+      walletAccount,
+    })
+    const feeData = await assetClientInterface.getFeeConfig({ assetName })
+
+    const txHandler = getTxHandler(type)
+
+    return txHandler.buildTransaction({
+      asset,
+      walletAccount,
+      toAddress,
+      amount,
+      blockHeight,
+      rbfEnabled,
+      multipleAddressesEnabled,
+      feePerKB,
+      customFee,
+      isSendAll,
+      bumpTxId,
+      isExchange,
+      isRbfAllowed,
+      taprootInputWitnessSize,
+      accountState,
+      feeData,
+      getFeeEstimator,
+      allowUnconfirmedRbfEnabledUtxos,
+      utxosDescendingOrder,
+      assetClientInterface,
+      changeAddressType,
+    })
+  }

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

@@ -0,0 +1,91 @@
+import { getTxSequence } from '@exodus/bitcoin-lib'
+
+import {
+  createInputs as dogecoinCreateInputs,
+  createOutput as dogecoinCreateOutput,
+} from './dogecoin.js'
+
+const ASSETS_USING_BUFFER_VALUES = new Set(['dogecoin', 'digibyte'])
+
+const ASSETS_SUPPORTED_BIP_174 = new Set([
+  'bitcoin',
+  'bitcoinregtest',
+  'bitcointestnet',
+  'litecoin',
+  'dash',
+  'dogecoin',
+  'ravencoin',
+  'digibyte',
+  'qtumignition',
+  'vertcoin', // is not available on mobile!
+])
+
+export async function getBlockHeight({ assetName, insightClient }) {
+  return ['zcash', 'bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)
+    ? insightClient.fetchBlockHeight()
+    : 0
+}
+
+export async function getNonWitnessTxs(asset, utxos, insightClient) {
+  const rawTxs = []
+
+  // BIP 174 (PSBT) requires full transaction for non-witness outputs
+  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) ||
+            asset.address.isP2SH2?.(a) ||
+            asset.address.isP2WPKH?.(a) ||
+            asset.address.isP2WSH?.(a)
+        )
+    )
+
+    if (nonWitnessTxIds.length > 0) {
+      for (const txId of nonWitnessTxIds) {
+        // full transaction is required for non-witness outputs
+        const rawData = await insightClient.fetchRawTx(txId)
+        rawTxs.push({ txId, rawData })
+      }
+    }
+  }
+
+  return rawTxs
+}
+
+export function createInputs(assetName, ...rest) {
+  if (ASSETS_USING_BUFFER_VALUES.has(assetName)) {
+    return dogecoinCreateInputs(...rest)
+  }
+
+  return defaultCreateInputs(...rest)
+}
+
+export function defaultCreateInputs(utxos, rbfEnabled) {
+  return utxos.map((utxo) => ({
+    txId: utxo.txId,
+    vout: utxo.vout,
+    address: utxo.address.toString(),
+    value: parseInt(utxo.value.toBaseString(), 10),
+    script: utxo.script,
+    sequence: getTxSequence(rbfEnabled),
+    inscriptionId: utxo.inscriptionId,
+    derivationPath: utxo.derivationPath,
+  }))
+}
+
+export function createOutput(assetName, ...rest) {
+  if (ASSETS_USING_BUFFER_VALUES.has(assetName)) {
+    return dogecoinCreateOutput(...rest)
+  }
+
+  return defaultCreateOutput(...rest)
+}
+
+export function defaultCreateOutput(address, sendAmount) {
+  return [address, parseInt(sendAmount.toBaseString(), 10)]
+}

package/src/tx-send/index.js

@@ -1,72 +1,11 @@
-import { getTxSequence } from '@exodus/bitcoin-lib'
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs'
-import { Address, UtxoCollection } from '@exodus/models'
+import { Address } from '@exodus/models'
 import { retry } from '@exodus/simple-retry'
-import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 
-import { getChangeDustValue } from '../dust.js'
-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 {
-  createInputs as dogecoinCreateInputs,
-  createOutput as dogecoinCreateOutput,
-} from './dogecoin.js'
-
-const ASSETS_SUPPORTED_BIP_174 = new Set([
-  'bitcoin',
-  'bitcoinregtest',
-  'bitcointestnet',
-  'litecoin',
-  'dash',
-  'dogecoin',
-  'ravencoin',
-  'digibyte',
-  'qtumignition',
-  'vertcoin', // is not available on mobile!
-])
-
-const ASSETS_USING_BUFFER_VALUES = new Set(['dogecoin', 'digibyte'])
-
-export async function getNonWitnessTxs(asset, utxos, insightClient) {
-  const rawTxs = []
-
-  // BIP 174 (PSBT) requires full transaction for non-witness outputs
-  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) ||
-            asset.address.isP2SH2?.(a) ||
-            asset.address.isP2WPKH?.(a) ||
-            asset.address.isP2WSH?.(a)
-        )
-    )
-
-    if (nonWitnessTxIds.length > 0) {
-      for (const txId of nonWitnessTxIds) {
-        // full transaction is required for non-witness outputs
-        const rawData = await insightClient.fetchRawTx(txId)
-        rawTxs.push({ txId, rawData })
-      }
-    }
-  }
-
-  return rawTxs
-}
+import { serializeCurrency } from '../fee/fee-utils.js'
+import { createTxFactory } from '../tx-create/create-tx.js'
+import { getBlockHeight } from '../tx-create/tx-create-utils.js'
 
 const getSize = (tx) => {
   if (typeof tx.size === 'number') return tx.size
@@ -160,290 +99,39 @@ export async function signTransaction({
   return { rawTx, txId, tx }
 }
 
-async function createUnsignedTx({
-  inputs,
-  outputs,
-  useCashAddress,
-  addressPathsMap,
-  blockHeight,
+const getPrepareSendTransaction = async ({
+  address,
+  allowUnconfirmedRbfEnabledUtxos,
+  amount,
   asset,
-  selectedUtxos,
-  insightClient,
-}) {
-  const unsignedTx = {
-    txData: {
-      inputs,
-      outputs,
-    },
-    txMeta: {
-      useCashAddress, // for trezor to show the receiver cash address
-      addressPathsMap,
-      blockHeight,
-    },
-  }
-
-  const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
-  Object.assign(unsignedTx.txMeta, { rawTxs: nonWitnessTxs })
-  return unsignedTx
-}
-
-async function getBlockHeight({ assetName, insightClient }) {
-  return ['zcash', 'bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)
-    ? insightClient.fetchBlockHeight()
-    : 0
-}
-
-export const getPrepareSendTransaction =
-  ({
-    blockHeight: providedBlockHeight,
-    ordinalsEnabled,
+  assetClientInterface,
+  blockHeight,
+  changeAddressType,
+  getFeeEstimator,
+  options,
+  rbfEnabled,
+  utxosDescendingOrder,
+  walletAccount,
+}) => {
+  const createTx = createTxFactory({
     getFeeEstimator,
     allowUnconfirmedRbfEnabledUtxos,
     utxosDescendingOrder,
-    rbfEnabled: providedRbfEnabled,
     assetClientInterface,
     changeAddressType,
-  }) =>
-  async ({ asset, walletAccount, address, amount, options }) => {
-    const {
-      multipleAddressesEnabled,
-      feePerKB,
-      customFee,
-      isSendAll,
-      bumpTxId,
-      nft,
-      isExchange,
-      isBip70,
-      isRbfAllowed,
-      taprootInputWitnessSize,
-    } = options
-
-    const assetName = asset.name
-    const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
-    const feeData = await assetClientInterface.getFeeConfig({ assetName })
-    feeData.feePerKB = feePerKB ?? feeData.feePerKB
-    const insightClient = asset.baseAsset.insightClient
-
-    const blockHeight = providedBlockHeight || (await getBlockHeight({ assetName, insightClient }))
-
-    const rbfEnabled =
-      providedRbfEnabled || (feeData.rbfEnabled && !isExchange && !isBip70 && isRbfAllowed && !nft)
-
-    const inscriptionIds = getInscriptionIds({ nft })
-
-    assert(
-      ordinalsEnabled || !inscriptionIds,
-      'inscriptions cannot be sent when ordinalsEnabled=false '
-    )
-
-    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!!!!
-    }
-
-    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'
-    )
-
-    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)
-
-    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 currency = asset.currency
-
-    const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
-    const usableUtxos = getUsableUtxos({
-      asset,
-      utxos: getUtxos({ accountState, asset }),
-      feeData,
-      txSet,
-      unconfirmedTxAncestor,
-    })
-
-    let replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
-
-    if (asset.address.toLegacyAddress) {
-      address = asset.address.toLegacyAddress(address)
-    }
-
-    if (assetName === 'digibyte' && asset.address.isP2SH2(address)) {
-      address = asset.address.P2SH2ToP2SH(address)
-    }
-
-    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 || transferOrdinalsUtxos ? asset.currency.ZERO : amount
-    const receiveAddress = bumpTxId
-      ? replaceableTxs.length > 0
-        ? null
-        : changeAddressType
-      : 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,
-      transferOrdinalsUtxos,
-      utxosDescendingOrder,
-      taprootInputWitnessSize,
-      changeAddressType,
-    })
-
-    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 (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(
-        // how to avoid replace tx inputs when inputs are ordinals? !!!!
-        UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
-      )
-    }
-
-    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, currency))
-        )
-      : []
-
-    // Send output
-    let sendOutput
-    if (address) {
-      if (transferOrdinalsUtxos) {
-        outputs.push(
-          ...transferOrdinalsUtxos
-            .toArray()
-            .map((ordinalUtxo) => createOutput(assetName, address, ordinalUtxo.value))
-        )
-      } else {
-        sendOutput = createOutput(assetName, address, sendAmount)
-        outputs.push(sendOutput)
-      }
-    }
-
-    const totalAmount = replaceTx
-      ? replaceTx.data.sent.reduce(
-          (total, { amount }) => total.add(parseCurrency(amount, asset.currency)),
-          sendAmount
-        )
-      : sendAmount
-
-    const change = selectedUtxos.value
-      .sub(totalAmount)
-      .sub(transferOrdinalsUtxos?.value || currency.ZERO)
-      .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)
-    }
-
-    // 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)
-    }
-
-    outputs = replaceTx ? outputs : shuffle(outputs)
+  })
 
-    const unsignedTx = await createUnsignedTx({
-      inputs,
-      outputs,
-      useCashAddress,
-      addressPathsMap,
-      blockHeight,
-      asset,
-      selectedUtxos,
-      insightClient,
-    })
-    return {
-      amount,
-      change,
-      totalAmount,
-      currentOrdinalsUtxos,
-      inscriptionIds,
-      address,
-      ourAddress,
-      receiveAddress,
-      sendAmount,
-      fee,
-      usableUtxos,
-      selectedUtxos,
-      transferOrdinalsUtxos,
-      replaceTx,
-      sendOutput,
-      changeOutput,
-      unsignedTx,
-    }
-  }
+  return createTx({
+    asset,
+    walletAccount,
+    type: 'transfer',
+    toAddress: address,
+    amount,
+    blockHeight,
+    rbfEnabled,
+    ...options,
+  })
+}
 
 // not ported from Exodus; but this demos signing / broadcasting
 // NOTE: this will be ripped out in the coming weeks
@@ -452,47 +140,47 @@ 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, isBip70, 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 && !isBip70 && isRbfAllowed && !nft
+    const rbfEnabled = feeData.rbfEnabled && !isExchange && isRbfAllowed
 
     // blockHeight
     const blockHeight = await getBlockHeight({ assetName, insightClient })
 
     const transactionDescriptor = await getPrepareSendTransaction({
-      blockHeight,
-      ordinalsEnabled,
-      getFeeEstimator,
+      address,
       allowUnconfirmedRbfEnabledUtxos,
-      utxosDescendingOrder,
-      rbfEnabled,
+      amount,
+      asset,
       assetClientInterface,
+      blockHeight,
       changeAddressType,
-    })({ asset, walletAccount, address, amount, options })
+      getFeeEstimator,
+      options,
+      rbfEnabled,
+      utxosDescendingOrder,
+      walletAccount,
+    })
     const {
       change,
       totalAmount,
-      currentOrdinalsUtxos,
-      inscriptionIds,
       ourAddress,
       receiveAddress,
       sendAmount,
       fee,
       usableUtxos,
       selectedUtxos,
-      transferOrdinalsUtxos,
       replaceTx,
       sendOutput,
       changeOutput,
@@ -570,7 +258,6 @@ export const createAndBroadcastTXFactory =
 
     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) {
@@ -593,16 +280,11 @@ export const createAndBroadcastTXFactory =
       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,
       },
     })
@@ -640,10 +322,6 @@ export const createAndBroadcastTXFactory =
         return asset.currency.ZERO
       }
 
-      if (nft) {
-        return transferOrdinalsUtxos.value.abs().negate()
-      }
-
       return totalAmount.abs().negate()
     }
 
@@ -670,17 +348,6 @@ export const createAndBroadcastTXFactory =
             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,
           },
         },
       ],
@@ -705,38 +372,5 @@ export const createAndBroadcastTXFactory =
     }
   }
 
-export function createInputs(assetName, ...rest) {
-  if (ASSETS_USING_BUFFER_VALUES.has(assetName)) {
-    return dogecoinCreateInputs(...rest)
-  }
-
-  return defaultCreateInputs(...rest)
-}
-
-function defaultCreateInputs(utxos, rbfEnabled) {
-  return utxos.map((utxo) => ({
-    txId: utxo.txId,
-    vout: utxo.vout,
-    address: utxo.address.toString(),
-    value: parseInt(utxo.value.toBaseString(), 10),
-    script: utxo.script,
-    sequence: getTxSequence(rbfEnabled),
-    inscriptionId: utxo.inscriptionId,
-    derivationPath: utxo.derivationPath,
-  }))
-}
-
-export function createOutput(assetName, ...rest) {
-  if (ASSETS_USING_BUFFER_VALUES.has(assetName)) {
-    return dogecoinCreateOutput(...rest)
-  }
-
-  return defaultCreateOutput(...rest)
-}
-
-function defaultCreateOutput(address, sendAmount) {
-  return [address, parseInt(sendAmount.toBaseString(), 10)]
-}
-
 // back compatibiliy
 export { getSendDustValue as getDustValue } from '../dust.js'