@exodus/bitcoin-api 4.5.0 → 4.7.0

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.7.0](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.6.0...@exodus/bitcoin-api@4.7.0) (2025-11-17)
+
+
+### Features
+
+
+* feat: remove giant metadata from createTx result (#6860)
+
+
+
+## [4.6.0](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.2.1...@exodus/bitcoin-api@4.6.0) (2025-11-14)
+
+
+### Features
+
+
+* feat: add PSBT builder infrastructure (#6822)
+
+* feat: add PSBT parser functionality (#6823)
+
+* feat: integrate PSBT support and legacy chain index (#6819)
+
+* feat: integrate PSBT support and legacy chain index (#6819) (#6829)
+
+
+
 ## [4.5.0](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@4.2.1...@exodus/bitcoin-api@4.5.0) (2025-11-12)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "4.5.0",
+  "version": "4.7.0",
   "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": "482aa1dda8d9273c4f1a477ffcef2310f1df9884"
+  "gitHead": "e281f3eae247487330a0ae16eb57372fa7982ca2"
 }

package/src/psbt-builder.js

@@ -1,11 +1,17 @@
-import { payments, Psbt, Transaction } from '@exodus/bitcoinjs'
+import { payments } from '@exodus/bitcoinjs'
 import { publicKeyToX } from '@exodus/crypto/secp256k1'
 import assert from 'minimalistic-assert'
 
 import { SubType, writePsbtGlobalField, writePsbtOutputField } from './psbt-proprietary-types.js'
-import { getAddressType, getPurposeXPubs, validatePurpose } from './psbt-utils.js'
-
-function canParseTx(rawTxBuffer) {
+import {
+  getAddressType,
+  getPurposeXPubs,
+  setPsbtVersionIfNotBitcoin,
+  validatePurpose,
+} from './psbt-utils.js'
+import { getMaximumFeeRate } from './tx-sign/maximum-fee-rates.js'
+
+function canParseTx(rawTxBuffer, Transaction) {
   try {
     Transaction.fromBuffer(rawTxBuffer)
     return true
@@ -70,7 +76,14 @@ function writeGlobalMetadata(psbt, metadata) {
   }
 }
 
-function createPsbtInput({ input, asset, addressPathsMap, purposeXPubs, nonWitnessTxs }) {
+function createPsbtInput({
+  input,
+  asset,
+  addressPathsMap,
+  purposeXPubs,
+  nonWitnessTxs,
+  Transaction,
+}) {
   const psbtInput = {
     hash: input.txId,
     index: input.vout,
@@ -111,7 +124,7 @@ function createPsbtInput({ input, asset, addressPathsMap, purposeXPubs, nonWitne
     )
 
     const rawTxBuffer = Buffer.from(rawTx.rawData, 'hex')
-    if (canParseTx(rawTxBuffer)) {
+    if (canParseTx(rawTxBuffer, Transaction)) {
       psbtInput.nonWitnessUtxo = rawTxBuffer
     } else {
       // bitcoinjs can’t parse a handful of edge-case transactions (Litecoin MWEB, odd
@@ -181,6 +194,8 @@ export async function createPsbtWithMetadata({
   addressPathsMap,
   metadata,
   allowedPurposes,
+  Psbt,
+  Transaction,
 }) {
   assert(inputs, 'inputs is required')
   assert(outputs, 'outputs is required')
@@ -189,8 +204,16 @@ export async function createPsbtWithMetadata({
   assert(walletAccount, 'walletAccount is required')
   assert(addressPathsMap, 'addressPathsMap is required')
   assert(metadata, 'metadata is required')
+  assert(Psbt, 'Psbt is required')
+  assert(Transaction, 'Transaction is required')
+  const psbtOptions = { network: asset.coinInfo.toBitcoinJS() }
+  const maximumFeeRate = getMaximumFeeRate(asset.name)
+  if (maximumFeeRate !== undefined) {
+    psbtOptions.maximumFeeRate = maximumFeeRate
+  }
 
-  const psbt = new Psbt({ network: asset.coinInfo.toBitcoinJS() })
+  const psbt = new Psbt(psbtOptions)
+  setPsbtVersionIfNotBitcoin(psbt, asset.name)
 
   const purposeXPubs = await getPurposeXPubs({
     assetClientInterface,
@@ -209,6 +232,7 @@ export async function createPsbtWithMetadata({
       purposeXPubs,
       nonWitnessTxs,
       allowedPurposes,
+      Transaction,
     })
     psbt.addInput(psbtInput)
   }
@@ -221,6 +245,7 @@ export async function createPsbtWithMetadata({
       addressPathsMap,
       purposeXPubs,
       allowedPurposes,
+      changeOutputIndex: metadata.changeOutputIndex,
     })
     psbt.addOutput(psbtOutput)
   })
@@ -230,5 +255,9 @@ export async function createPsbtWithMetadata({
     writePsbtOutputField(psbt, sendOutputIndex, SubType.OutputRole, 'primary')
   }
 
-  return psbt.toBuffer()
+  if (metadata.changeOutputIndex !== undefined) {
+    writePsbtOutputField(psbt, metadata.changeOutputIndex, SubType.OutputRole, 'change')
+  }
+
+  return psbt
 }

package/src/psbt-parser.js

@@ -1,6 +1,5 @@
-import { Psbt, Transaction } from '@exodus/bitcoinjs'
 import { publicKeyToX } from '@exodus/crypto/secp256k1'
-import { UtxoCollection } from '@exodus/models'
+import { Address, UtxoCollection } from '@exodus/models'
 import BipPath from 'bip32-path'
 import assert from 'minimalistic-assert'
 
@@ -11,7 +10,7 @@ import { findUnconfirmedSentRbfTxs } from './tx-utils.js'
 import { getUnconfirmedTxAncestorMap } from './unconfirmed-ancestor-data.js'
 import { getUsableUtxos, getUtxos } from './utxos-utils.js'
 
-function extractInputUtxoData(psbtInput, txInput, index) {
+function extractInputUtxoData(psbtInput, txInput, index, Transaction) {
   if (psbtInput.nonWitnessUtxo) {
     const prevTx = Transaction.fromBuffer(psbtInput.nonWitnessUtxo)
     const prevOutput = prevTx.outs[txInput.index]
@@ -34,14 +33,14 @@ function extractInputUtxoData(psbtInput, txInput, index) {
   throw new Error(`Input ${index} has no witnessUtxo or nonWitnessUtxo`)
 }
 
-function parseSingleInput({ txInput, psbtInput, index, asset, purposeXPubs }) {
+function parseSingleInput({ txInput, psbtInput, index, asset, purposeXPubs, Transaction }) {
   const input = {
     txId: Buffer.from(txInput.hash).reverse().toString('hex'),
     vout: txInput.index,
     sequence: txInput.sequence,
   }
 
-  const inputUtxoData = extractInputUtxoData(psbtInput, txInput, index)
+  const inputUtxoData = extractInputUtxoData(psbtInput, txInput, index, Transaction)
 
   input.value = inputUtxoData.value
   input.script = Buffer.from(inputUtxoData.scriptBuffer).toString('hex')
@@ -71,7 +70,7 @@ function parseSingleInput({ txInput, psbtInput, index, asset, purposeXPubs }) {
     throw new Error(`Input ${index} has no derivation path`)
   }
 
-  input.address = { address, meta: { path: derivation.path, purpose } }
+  input.address = { address, meta: { path: derivation.path } }
   return input
 }
 
@@ -117,9 +116,15 @@ function readGlobalMetadata(psbt) {
 }
 
 function calculateFee(inputs, outputs) {
-  const inputSum = inputs.reduce((sum, input) => sum + (input.value || 0), 0)
-  const outputSum = outputs.reduce((sum, output) => sum + (output.amount || 0), 0)
-  return inputSum - outputSum
+  const inputSum = inputs.reduce((sum, input) => {
+    const value = BigInt(input.value || 0)
+    return sum + value
+  }, BigInt(0))
+  const outputSum = outputs.reduce((sum, output) => {
+    const amount = BigInt(output.amount || 0)
+    return sum + amount
+  }, BigInt(0))
+  return inputSum - outputSum // Return BigInt directly
 }
 
 function getBip32Derivation(hdkey, bip32Derivations, ignoreY) {
@@ -217,32 +222,22 @@ function getSelectedUtxos({ parsedInputs, utxos, asset, txSet }) {
 async function getChangeOutputData({ outputs, assetClientInterface, walletAccount, asset }) {
   let changeOutputData = null
   for (const [i, output] of outputs.entries()) {
-    // Outputs marked “primary” are treated as sends even if they use one of our paths
-    // (common for self‑sends, consolidations, etc.), so skip them during change detection.
-    if (output.metadata?.outputRole === 'primary') {
-      continue
-    }
-
-    // We only treat addresses we can re-derive from the wallet xpub as potential
-    // change outputs.
-    if (!output.address?.meta?.path) {
+    if (output.metadata?.outputRole !== 'change') {
       continue
     }
 
-    // At this point we already know the output was derived by our wallet and it is
-    // not explicitly flagged as a primary/send output, so we tentatively treat it as
-    // change and confirm by re-deriving the on-chain address.
     if (changeOutputData) {
-      // Multiple change outputs are a smell. This can happen if an external PSBT
-      // marks a send output of the same wallet with its derivation path, so we fail fast instead of
-      // silently mislabelling funds.
       throw new Error('Multiple change outputs are not allowed')
     }
 
+    if (!output.address?.meta?.path || !output.address?.meta?.purpose) {
+      throw new Error('Change output has no derivation path or purpose')
+    }
+
     const { path, purpose } = output.address.meta
     const [chainIndex, addressIndex] = BipPath.fromString(path).toPathArray()
 
-    const verifyAddr = await assetClientInterface.getAddress({
+    let ourAddress = await assetClientInterface.getAddress({
       assetName: asset.name,
       walletAccount: walletAccount.toString(),
       purpose,
@@ -250,10 +245,15 @@ async function getChangeOutputData({ outputs, assetClientInterface, walletAccoun
       addressIndex,
     })
 
-    if (verifyAddr.toString() === output.address.address) {
+    if (asset.address.toLegacyAddress) {
+      const legacyAddress = asset.address.toLegacyAddress(ourAddress.address)
+      ourAddress = Address.create(legacyAddress, ourAddress.meta)
+    }
+
+    if (ourAddress.toString() === output.address.address) {
       changeOutputData = {
-        address: verifyAddr,
-        amount: output.amount,
+        address: ourAddress,
+        amount: toBigIntAmount(output.amount),
         index: i,
       }
     } else {
@@ -311,6 +311,17 @@ function buildAddressPathsMap(selectedUtxos, changeOutputData) {
   return addressPathsMap
 }
 
+function buildOutputAddressPurposesMap(outputs) {
+  const map = Object.create(null)
+  for (const output of outputs) {
+    if (output.address?.meta?.purpose) {
+      map[output.address.address] = output.address.meta.purpose
+    }
+  }
+
+  return map
+}
+
 function extractRawTransactions(parsedInputs) {
   const rawTxsData = parsedInputs
     .filter((parsedInput) => parsedInput.prevTxId)
@@ -329,11 +340,15 @@ export async function parsePsbt({
   assetClientInterface,
   walletAccount,
   allowedPurposes,
+  Psbt,
+  Transaction,
 }) {
   assert(psbtBuffer, 'psbtBuffer is required')
   assert(asset, 'asset is required')
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(walletAccount, 'walletAccount is required')
+  assert(Psbt, 'Psbt is required')
+  assert(Transaction, 'Transaction is required')
 
   const purposeXPubs = await getPurposeXPubs({
     assetClientInterface,
@@ -353,6 +368,7 @@ export async function parsePsbt({
       asset,
       purposeXPubs,
       allowedPurposes,
+      Transaction,
     })
     inputs.push(input)
   }
@@ -382,30 +398,159 @@ export async function parsePsbt({
   }
 }
 
+function toBigIntAmount(value) {
+  return Buffer.isBuffer(value) ? value.readBigInt64LE(0) : BigInt(value)
+}
+
+function parseUnsignedTx({ unsignedTx }) {
+  const { txData, txMeta } = unsignedTx
+  assert(txData, 'txData is required')
+  assert(txMeta, 'txMeta is required')
+
+  const {
+    addressPathsMap = Object.create(null),
+    outputAddressPurposesMap = Object.create(null),
+    changeOutputIndex,
+    rawTxs = [],
+    blockHeight,
+    sendOutputIndexes = [],
+    rbfEnabled = false,
+    bumpTxId,
+    txType,
+  } = txMeta
+
+  const rawTxMap = new Map(rawTxs.map((tx) => [tx.txId, tx.rawData]))
+
+  const inputs = (txData.inputs || []).map((input) =>
+    parseUnsignedInput({
+      input,
+      addressPathsMap,
+      rawTxMap,
+    })
+  )
+
+  const outputs = (txData.outputs || []).map((output, index) =>
+    parseUnsignedOutput({
+      index,
+      output,
+      addressPathsMap,
+      outputAddressPurposesMap,
+      sendOutputIndexes,
+      changeOutputIndex,
+    })
+  )
+
+  const fee = computeFee(inputs, outputs)
+
+  const globalMetadata = {
+    blockHeight,
+    rbfEnabled,
+    bumpTxId,
+    txType,
+  }
+
+  return { inputs, outputs, fee, globalMetadata }
+}
+
+function computeFee(inputs, outputs) {
+  const inputSum = inputs.reduce((sum, input) => sum + toBigIntAmount(input.value), BigInt(0))
+  const outputSum = outputs.reduce((sum, output) => sum + toBigIntAmount(output.amount), BigInt(0))
+  return inputSum - outputSum
+}
+
+function parseUnsignedInput({ input, addressPathsMap, rawTxMap }) {
+  const { txId, vout, sequence, value, script, address: addressString } = input
+
+  const path = addressPathsMap[addressString]
+
+  const parsedInput = {
+    txId,
+    vout,
+    sequence,
+    value,
+    script,
+    address: { address: addressString, meta: { path } },
+  }
+
+  const rawTxHex = rawTxMap.get(txId)
+  if (rawTxHex) {
+    parsedInput.prevTxHex = rawTxHex
+    parsedInput.prevTxId = txId
+  }
+
+  return parsedInput
+}
+
+function parseUnsignedOutput({
+  index,
+  output,
+  addressPathsMap,
+  outputAddressPurposesMap,
+  sendOutputIndexes,
+  changeOutputIndex,
+}) {
+  const [addressString, amount] = output
+
+  const purpose = outputAddressPurposesMap[addressString]
+  const path = addressPathsMap[addressString]
+
+  const addressObject = { address: addressString }
+  if (purpose !== undefined) {
+    addressObject.meta = { purpose }
+  }
+
+  if (path !== undefined) {
+    addressObject.meta = { ...addressObject.meta, path }
+  }
+
+  const parsedOutput = {
+    amount,
+    address: addressObject,
+  }
+
+  if (sendOutputIndexes.includes(index)) {
+    parsedOutput.metadata = { outputRole: 'primary' }
+  } else if (changeOutputIndex === index) {
+    parsedOutput.metadata = { outputRole: 'change' }
+  }
+
+  return parsedOutput
+}
+
 export async function extractTransactionContext({
-  psbtBuffer,
+  unsignedTx,
   asset,
   assetClientInterface,
   walletAccount,
   allowedPurposes,
+  Psbt,
+  Transaction,
 }) {
-  assert(psbtBuffer, 'psbtBuffer is required')
+  assert(unsignedTx, 'unsignedTx is required')
   assert(asset, 'asset is required')
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(walletAccount, 'walletAccount is required')
 
+  const psbtBuffer = unsignedTx?.txData?.psbtBuffer
+
+  const parsed = psbtBuffer
+    ? await parsePsbt({
+        psbtBuffer,
+        asset,
+        assetClientInterface,
+        walletAccount,
+        allowedPurposes,
+        Psbt,
+        Transaction,
+      })
+    : parseUnsignedTx({ unsignedTx })
+
   const {
     inputs: parsedInputs,
     outputs: parsedOutputs,
     fee: calculatedFee,
     globalMetadata,
-  } = await parsePsbt({
-    psbtBuffer,
-    asset,
-    assetClientInterface,
-    walletAccount,
-    allowedPurposes,
-  })
+  } = parsed
 
   const changeOutputData = await getChangeOutputData({
     outputs: parsedOutputs,
@@ -466,6 +611,7 @@ export async function extractTransactionContext({
   )
 
   const addressPathsMap = buildAddressPathsMap(selectedUtxos, changeOutputData)
+  const outputAddressPurposesMap = buildOutputAddressPurposesMap(parsedOutputs)
   const rawTxs = extractRawTransactions(parsedInputs)
 
   return {
@@ -476,6 +622,7 @@ export async function extractTransactionContext({
     fee: asset.currency.baseUnit(calculatedFee),
     sendOutputIndexes: primaryOutputIndexes,
     changeOutputIndex: changeOutputData?.index,
+    outputAddressPurposesMap,
     sendAmounts,
     changeAmount,
     totalSendAmount,
@@ -489,5 +636,9 @@ export async function extractTransactionContext({
     changeOutput: changeOutputData ? outputs[changeOutputData.index] : undefined,
     rbfEnabled: globalMetadata.rbfEnabled,
     blockHeight: globalMetadata.blockHeight,
+    bumpTxId: globalMetadata.bumpTxId,
+    txType: globalMetadata.txType,
+    useCashAddress: unsignedTx?.txMeta?.useCashAddress,
+    psbtBuffer,
   }
 }

package/src/psbt-utils.js

@@ -131,3 +131,7 @@ export async function withUnsafeNonSegwit({ psbt, fn, unsafe = true }) {
     cache.__UNSAFE_SIGN_NONSEGWIT = prevValue
   }
 }
+
+export function setPsbtVersionIfNotBitcoin(psbt, assetName) {
+  if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
+}

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

@@ -174,6 +174,7 @@ function createTransactionOutputs({
   const assetName = asset.name
   let outputs = []
   let sendOutput
+  let adjustedFee
 
   // Add existing outputs from replacement transaction
   if (replaceTx) {
@@ -196,8 +197,7 @@ function createTransactionOutputs({
       )
     : sendAmount
 
-  // Handle change output
-  const { changeOutput, adjustedFee, changeAddressKeypath, ourAddress } = createChangeOutput({
+  const changeOutputData = createChangeOutput({
     selectedUtxos,
     totalAmount,
     fee,
@@ -206,18 +206,23 @@ function createTransactionOutputs({
     asset,
   })
 
-  if (changeOutput) {
-    outputs.push(changeOutput)
+  if (changeOutputData) {
+    outputs.push(changeOutputData.changeOutput)
+    adjustedFee = fee
+  } else {
+    // If we don't have enough for a change output, then all remaining dust is just added to fee
+    const changeAmount = selectedUtxos.value.sub(totalAmount).sub(fee)
+    adjustedFee = fee.add(changeAmount)
   }
 
   return {
     outputs: replaceTx ? outputs : shuffle(outputs),
     sendOutput,
-    changeOutput,
-    totalAmount,
+    ourAddress: changeOutputData?.ourAddress,
+    changeOutput: changeOutputData?.changeOutput,
+    changeAddressPath: changeOutputData?.changeAddressPath,
+    changeAddressPurpose: changeOutputData?.changeAddressPurpose,
     adjustedFee,
-    changeAddressKeypath,
-    ourAddress,
   }
 }
 
@@ -233,7 +238,7 @@ function createChangeOutput({ selectedUtxos, totalAmount, fee, replaceTx, change
     ourAddress = Address.create(legacyAddress, ourAddress.meta)
   }
 
-  // Create change output if above dust threshold
+  // Create change output if above dust threshold.
   if (change.gte(dust)) {
     const changeOutput = createOutput(
       asset.name,
@@ -241,22 +246,16 @@ function createChangeOutput({ selectedUtxos, totalAmount, fee, replaceTx, change
       change
     )
 
-    // Return the keypath for hardware wallet change detection
+    // Return the path for hardware wallet change detection
     return {
-      changeOutput,
-      adjustedFee: fee,
-      changeAddressKeypath: ourAddress.meta.path,
       ourAddress,
+      changeOutput,
+      changeAddressPath: ourAddress.meta.path,
+      changeAddressPurpose: ourAddress.meta.purpose,
     }
   }
 
-  // Add dust to fee if not enough for change output
-  return {
-    changeOutput: undefined,
-    adjustedFee: fee.add(change),
-    changeAddressKeypath: undefined,
-    ourAddress,
-  }
+  return null
 }
 
 async function createUnsignedTx({
@@ -275,7 +274,10 @@ async function createUnsignedTx({
   txType = 'transfer',
   sendOutputIndex,
   changeOutputIndex,
+  outputAddressPurposesMap,
   allowedPurposes,
+  Psbt,
+  Transaction,
 }) {
   const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
 
@@ -289,14 +291,21 @@ async function createUnsignedTx({
       addressPathsMap,
       blockHeight,
       rawTxs: nonWitnessTxs,
+      sendOutputIndexes:
+        sendOutputIndex === undefined || sendOutputIndex === null ? [] : [sendOutputIndex],
+      changeOutputIndex,
+      outputAddressPurposesMap,
+      rbfEnabled,
+      bumpTxId,
+      txType,
     },
   }
 
-  // Only attach PSBT metadata for Bitcoin transfer flows for now; support for other coins and
-  // transaction types will come later.
-  const isBitcoin = ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name)
-  if (isBitcoin) {
-    const psbtBuffer = await createPsbtWithMetadata({
+  // Create PSBT for all UTXO coins that support it
+  // Note: Some coins (like BCash) may not use PSBT in their signing flow,
+  // but creating it here allows for a unified transaction flow
+  if (Psbt) {
+    const psbt = await createPsbtWithMetadata({
       inputs,
       outputs,
       asset,
@@ -313,9 +322,11 @@ async function createUnsignedTx({
         bumpTxId,
         blockHeight,
       },
+      Psbt,
+      Transaction,
     })
 
-    result.txData.psbtBuffer = psbtBuffer
+    result.txData.psbtBuffer = psbt.toBuffer()
   }
 
   return result
@@ -347,6 +358,8 @@ const transferHandler = {
     assetClientInterface,
     changeAddressType,
     allowedPurposes,
+    Psbt,
+    Transaction,
   }) => {
     const assetName = asset.name
     const insightClient = asset.baseAsset.insightClient
@@ -444,10 +457,10 @@ const transferHandler = {
       outputs,
       sendOutput,
       changeOutput,
-      totalAmount,
-      adjustedFee,
-      changeAddressKeypath,
+      changeAddressPath,
+      changeAddressPurpose,
       ourAddress,
+      adjustedFee,
     } = createTransactionOutputs({
       replaceTx: processedReplaceTx,
       processedAddress,
@@ -458,11 +471,15 @@ const transferHandler = {
       changeAddress: context.changeAddress,
     })
 
+    // Create a map of wallet's own output addresses and their purposes.
+    const outputAddressPurposesMap = Object.create(null)
+
     // Add the keypath of change address to support Trezor detect the change output.
     // Output is change and does not need approval from user which shows the strange address that user never seen.
-    if (changeAddressKeypath) {
+    if (changeAddressPath && changeAddressPurpose) {
       const changeKey = ourAddress?.address ?? String(ourAddress)
-      addressPathsMap[changeKey] = changeAddressKeypath
+      addressPathsMap[changeKey] = changeAddressPath
+      outputAddressPurposesMap[changeKey] = changeAddressPurpose
     }
 
     // Create unsigned transaction
@@ -471,6 +488,7 @@ const transferHandler = {
       outputs,
       useCashAddress,
       addressPathsMap,
+      outputAddressPurposesMap,
       blockHeight: context.blockHeight,
       asset,
       selectedUtxos,
@@ -483,28 +501,11 @@ const transferHandler = {
       sendOutputIndex: sendOutput ? outputs.indexOf(sendOutput) : undefined,
       changeOutputIndex: changeOutput ? outputs.indexOf(changeOutput) : undefined,
       allowedPurposes,
+      Psbt,
+      Transaction,
     })
 
-    return {
-      unsignedTx,
-      metadata: {
-        fee: adjustedFee,
-        amount,
-        change: selectedUtxos.value.sub(totalAmount).sub(adjustedFee),
-        totalAmount,
-        address: processedAddress,
-        ourAddress,
-        receiveAddress: utxoParams.receiveAddress,
-        sendAmount: utxoParams.sendAmount,
-        usableUtxos: context.usableUtxos,
-        selectedUtxos,
-        replaceTx: processedReplaceTx,
-        sendOutput,
-        changeOutput,
-        blockHeight: context.blockHeight,
-        rbfEnabled: context.rbfEnabled,
-      },
-    }
+    return { unsignedTx, fee: adjustedFee }
   },
 }
 
@@ -516,6 +517,8 @@ export const createTxFactory =
     assetClientInterface,
     changeAddressType,
     allowedPurposes,
+    Psbt,
+    Transaction,
   }) =>
   async ({
     asset,
@@ -562,5 +565,7 @@ export const createTxFactory =
       assetClientInterface,
       changeAddressType,
       allowedPurposes,
+      Psbt,
+      Transaction,
     })
   }

package/src/tx-send/index.js

@@ -1,4 +1,5 @@
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs'
+import { Psbt as DefaultPsbt, Transaction as DefaultTransaction } from '@exodus/bitcoinjs'
 import assert from 'minimalistic-assert'
 
 import { extractTransactionContext } from '../psbt-parser.js'
@@ -98,61 +99,21 @@ export async function signTransaction({
   return { rawTx, txId, tx }
 }
 
-const getPrepareSendTransaction = async ({
-  address,
-  allowUnconfirmedRbfEnabledUtxos,
-  amount,
-  asset,
-  assetClientInterface,
-  changeAddressType,
-  getFeeEstimator,
-  options,
-  utxosDescendingOrder,
-  walletAccount,
-  allowedPurposes,
-}) => {
-  const createTx = createTxFactory({
-    getFeeEstimator,
-    allowUnconfirmedRbfEnabledUtxos,
-    utxosDescendingOrder,
-    assetClientInterface,
-    changeAddressType,
-    allowedPurposes,
-  })
-
-  // Set default values for options
-  const { isRbfAllowed = true, ...restOptions } = options || Object.create(null)
-
-  return createTx({
-    asset,
-    walletAccount,
-    type: 'transfer',
-    toAddress: address,
-    amount,
-    isRbfAllowed,
-    ...restOptions,
-  })
-}
-
-function toTransactionDescriptor(txContext, psbtBuffer) {
+function getTransferUnsignedTx(txContext) {
   const {
     inputs,
     outputs,
+    psbtBuffer,
+    useCashAddress,
     addressPathsMap,
+    outputAddressPurposesMap,
     blockHeight,
     rawTxs,
-    fee,
-    totalSendAmount,
-    changeAmount,
-    totalAmount,
-    primaryAddresses,
-    ourAddress,
-    usableUtxos,
-    selectedUtxos,
-    replaceTx,
-    sendOutputs,
-    changeOutput,
+    txType,
     rbfEnabled,
+    bumpTxId,
+    changeOutputIndex,
+    sendOutputIndexes,
   } = txContext
 
   return {
@@ -163,27 +124,47 @@ function toTransactionDescriptor(txContext, psbtBuffer) {
         psbtBuffer,
       },
       txMeta: {
+        useCashAddress,
         addressPathsMap,
+        outputAddressPurposesMap,
         blockHeight,
         rawTxs,
+        txType,
+        rbfEnabled,
+        bumpTxId,
+        changeOutputIndex,
+        sendOutputIndexes,
       },
     },
-    metadata: {
-      fee,
-      amount: totalSendAmount.isZero ? undefined : totalSendAmount,
-      sendAmount: totalSendAmount,
-      change: changeAmount,
-      totalAmount,
-      address: primaryAddresses[0]?.address,
-      ourAddress,
-      usableUtxos,
-      selectedUtxos,
-      replaceTx,
-      sendOutput: sendOutputs[0],
-      changeOutput,
-      rbfEnabled,
-      blockHeight,
-    },
+  }
+}
+
+// Get additional transaction metadata that are not part of the unsignedTx.txMeta
+function getExtendedTxMeta(txContext) {
+  const {
+    fee,
+    totalSendAmount,
+    changeAmount,
+    totalAmount,
+    primaryAddresses,
+    ourAddress,
+    usableUtxos,
+    selectedUtxos,
+    replaceTx,
+    changeOutput,
+  } = txContext
+
+  return {
+    fee,
+    sendAmount: totalSendAmount,
+    changeAmount,
+    totalAmount,
+    toAddress: primaryAddresses[0]?.address,
+    ourAddress,
+    usableUtxos,
+    selectedUtxos,
+    replaceTx,
+    changeOutput,
   }
 }
 
@@ -198,50 +179,80 @@ export const createAndBroadcastTXFactory =
     assetClientInterface,
     changeAddressType,
     allowedPurposes,
+    Psbt = DefaultPsbt,
+    Transaction = DefaultTransaction,
   }) =>
-  async ({ asset, walletAccount, address, amount, options }) => {
-    // Prepare transaction
-    const { bumpTxId } = options
-
+  async ({
+    asset,
+    walletAccount,
+    address,
+    amount,
+    multipleAddressesEnabled,
+    feePerKB,
+    customFee,
+    isSendAll,
+    bumpTxId: bumpTxIdProvided,
+    isExchange,
+    isRbfAllowed = true,
+    taprootInputWitnessSize,
+  }) => {
     const assetName = asset.name
     const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
 
-    let transactionDescriptor = await getPrepareSendTransaction({
-      address,
+    const createTx = createTxFactory({
+      getFeeEstimator,
       allowUnconfirmedRbfEnabledUtxos,
+      utxosDescendingOrder,
+      assetClientInterface,
+      changeAddressType,
+      allowedPurposes,
+      Psbt,
+      Transaction,
+    })
+
+    const { unsignedTx: unsignedTxByCreateTx } = await createTx({
+      asset,
+      walletAccount,
+      type: 'transfer',
+      toAddress: address,
       amount,
+      isRbfAllowed,
+      multipleAddressesEnabled,
+      feePerKB,
+      customFee,
+      isSendAll,
+      bumpTxId: bumpTxIdProvided,
+      isExchange,
+      taprootInputWitnessSize,
+    })
+
+    const txContext = await extractTransactionContext({
+      unsignedTx: unsignedTxByCreateTx,
       asset,
       assetClientInterface,
-      changeAddressType,
-      getFeeEstimator,
-      options,
-      utxosDescendingOrder,
       walletAccount,
       allowedPurposes,
+      Psbt,
+      Transaction,
     })
 
-    // If we already created a PSBT for Bitcoin, hydrate the full transaction
-    // context from it before signing.
-    let unsignedTx, metadata
-    if (transactionDescriptor.unsignedTx?.txData?.psbtBuffer) {
-      const psbtBuffer = transactionDescriptor.unsignedTx.txData.psbtBuffer
-      const txContext = await extractTransactionContext({
-        psbtBuffer,
-        asset,
-        assetClientInterface,
-        walletAccount,
-        allowedPurposes,
-      })
-      transactionDescriptor = toTransactionDescriptor(txContext, psbtBuffer)
-      unsignedTx = transactionDescriptor.unsignedTx
-      metadata = transactionDescriptor.metadata
-    } else {
-      // Legacy/non-PSBT flows stick with the original descriptor shape.
-      unsignedTx = transactionDescriptor.unsignedTx
-      metadata = transactionDescriptor.metadata
-    }
+    const { unsignedTx } = getTransferUnsignedTx(txContext)
 
-    const { sendAmount, usableUtxos, replaceTx, sendOutput, changeOutput } = metadata
+    const {
+      fee,
+      sendAmount,
+      changeAmount,
+      totalAmount,
+      toAddress,
+      ourAddress,
+      usableUtxos,
+      selectedUtxos,
+      replaceTx,
+      changeOutput,
+    } = getExtendedTxMeta(txContext)
+
+    const { sendOutputIndexes, changeOutputIndex, bumpTxId, rbfEnabled, blockHeight } =
+      unsignedTx.txMeta
 
     // Sign transaction
     const { rawTx, txId, tx } = await signTransaction({
@@ -258,7 +269,7 @@ export const createAndBroadcastTXFactory =
       if (/insight broadcast http error.*missing inputs/i.test(err.message)) {
         err.txInfo = JSON.stringify({
           amount: sendAmount.toDefaultString({ unit: true }),
-          fee: ((metadata.fee && metadata.fee.toDefaultString({ unit: true })) || 0).toString(),
+          fee: ((fee && fee.toDefaultString({ unit: true })) || 0).toString(),
           allUtxos: usableUtxos.toJSON(),
         })
       }
@@ -266,34 +277,31 @@ export const createAndBroadcastTXFactory =
       throw err
     }
 
-    function findUtxoIndex(output) {
-      let utxoIndex = -1
-      if (output) {
-        for (const [i, [address, amount]] of unsignedTx.txData.outputs.entries()) {
-          if (output[0] === address && output[1] === amount) {
-            utxoIndex = i
-            break
-          }
-        }
-      }
-
-      return utxoIndex
-    }
+    const changeUtxoIndex = changeOutputIndex ?? -1
+    const sendUtxoIndex = sendOutputIndexes?.[0] ?? -1
 
-    const changeUtxoIndex = findUtxoIndex(changeOutput)
-    const sendUtxoIndex = findUtxoIndex(sendOutput)
+    const { script, size } = getSizeAndChangeScript({
+      assetName,
+      tx,
+      rawTx,
+      changeUtxoIndex,
+      txId,
+    })
 
-    const { size } = await updateAccountState({
+    await updateAccountState({
       assetClientInterface,
       assetName,
       walletAccount,
       accountState,
       txId,
-      metadata,
-      tx,
-      rawTx,
       changeUtxoIndex,
-      getSizeAndChangeScript,
+      script,
+      usableUtxos,
+      selectedUtxos,
+      replaceTx,
+      changeAmount,
+      ourAddress,
+      rbfEnabled,
     })
 
     await updateTransactionLog({
@@ -301,7 +309,16 @@ export const createAndBroadcastTXFactory =
       assetClientInterface,
       walletAccount,
       txId,
-      metadata,
+      totalAmount,
+      selectedUtxos,
+      replaceTx,
+      changeOutput,
+      ourAddress,
+      fee,
+      blockHeight,
+      rbfEnabled,
+      toAddress,
+      sendAmount,
       bumpTxId,
       size,
     })

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

@@ -2,44 +2,21 @@ 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
- */
 export async function updateAccountState({
   assetClientInterface,
   assetName,
   walletAccount,
   accountState,
   txId,
-  metadata,
-  tx,
-  rawTx,
   changeUtxoIndex,
-  getSizeAndChangeScript,
+  script,
+  usableUtxos,
+  selectedUtxos,
+  replaceTx,
+  changeAmount,
+  ourAddress,
+  rbfEnabled,
 }) {
-  const { usableUtxos, selectedUtxos, replaceTx, change, ourAddress, rbfEnabled } = 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)
@@ -52,7 +29,7 @@ export async function updateAccountState({
       address,
       vout: changeUtxoIndex,
       script,
-      value: change,
+      value: changeAmount,
       confirmations: 0,
       rbfEnabled,
     }
@@ -75,42 +52,26 @@ export async function updateAccountState({
       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.metadata - Transaction metadata
- * @param {string} params.bumpTxId - ID of transaction being bumped (if applicable)
- * @param {number} params.size - Transaction size
- */
 export async function updateTransactionLog({
   asset,
   assetClientInterface,
   walletAccount,
   txId,
-  metadata,
   bumpTxId,
   size,
+  totalAmount,
+  selectedUtxos,
+  replaceTx,
+  changeOutput,
+  ourAddress,
+  fee,
+  blockHeight,
+  rbfEnabled,
+  toAddress,
+  sendAmount,
 }) {
-  const {
-    totalAmount,
-    selectedUtxos,
-    replaceTx,
-    changeOutput,
-    ourAddress,
-    fee,
-    blockHeight,
-    rbfEnabled,
-    address,
-    amount,
-  } = metadata
   const assetName = asset.name
 
   // Check if this is a self-send
@@ -129,9 +90,11 @@ export async function updateTransactionLog({
   // 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))
+    : walletAddressObjects.some((receiveAddress) => String(receiveAddress) === String(toAddress))
 
-  const displayReceiveAddress = asset.address.displayAddress?.(address) || address
+  const displayReceiveAddress = asset.address.displayAddress?.(toAddress) || toAddress
+
+  const amountToSerialize = sendAmount.isZero ? undefined : sendAmount
 
   // Build receivers list
   const receivers = bumpTxId
@@ -141,9 +104,17 @@ export async function updateTransactionLog({
     : replaceTx
       ? [
           ...replaceTx.data.sent,
-          { address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) },
+          {
+            address: displayReceiveAddress,
+            amount: serializeCurrency(amountToSerialize, asset.currency),
+          },
+        ]
+      : [
+          {
+            address: displayReceiveAddress,
+            amount: serializeCurrency(amountToSerialize, asset.currency),
+          },
         ]
-      : [{ address: displayReceiveAddress, amount: serializeCurrency(amount, asset.currency) }]
 
   // Calculate coin amount
   const coinAmount = selfSend ? asset.currency.ZERO : totalAmount.abs().negate()
@@ -177,11 +148,17 @@ export async function updateTransactionLog({
 
   // If replacing a transaction, update the old one
   if (replaceTx) {
-    replaceTx.data.replacedBy = txId
+    const updatedReplaceTx = {
+      ...replaceTx,
+      data: {
+        ...replaceTx.data,
+        replacedBy: txId,
+      },
+    }
     await assetClientInterface.updateTxLogAndNotify({
       assetName,
       walletAccount,
-      txs: [replaceTx],
+      txs: [updatedReplaceTx],
     })
   }
 }

package/src/tx-sign/common.js

@@ -27,3 +27,12 @@ export const serializeTx = ({ tx }) => {
     })),
   }
 }
+
+export function shouldSkipFinalize(unsignedTx) {
+  const isExternalPsbt =
+    unsignedTx.txData.psbtBuffer &&
+    unsignedTx.txMeta.addressPathsMap &&
+    unsignedTx.txMeta.inputsToSign
+
+  return isExternalPsbt || unsignedTx.txMeta.returnPsbt
+}

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

@@ -1,7 +1,7 @@
 import { Psbt as DefaultPsbt, Transaction as DefaultTransaction } from '@exodus/bitcoinjs'
 import assert from 'minimalistic-assert'
 
-import { extractTransaction } from './common.js'
+import { extractTransaction, shouldSkipFinalize } from './common.js'
 import { createSignWithWallet } from './create-sign-with-wallet.js'
 import { createPrepareForSigning } from './default-prepare-for-signing.js'
 
@@ -57,11 +57,7 @@ export const signTxFactory = ({
       },
     })
 
-    const isExternalPsbt =
-      unsignedTx.txData.psbtBuffer &&
-      unsignedTx.txMeta.addressPathsMap &&
-      unsignedTx.txMeta.inputsToSign
-    const skipFinalize = isExternalPsbt || unsignedTx.txMeta.returnPsbt
+    const skipFinalize = shouldSkipFinalize(unsignedTx)
     await signWithWallet(psbt, inputsToSign, skipFinalize)
     return extractTransaction({ psbt, skipFinalize })
   }

package/src/tx-sign/default-prepare-for-signing.js

@@ -2,11 +2,8 @@ import { Psbt as DefaultPsbt, Transaction as DefaultTransaction } from '@exodus/
 import assert from 'minimalistic-assert'
 
 import { writePsbtBlockHeight } from '../psbt-proprietary-types.js'
-
-const _MAXIMUM_FEE_RATES = {
-  qtumignition: 25_000,
-  ravencoin: 1_000_000,
-}
+import { setPsbtVersionIfNotBitcoin } from '../psbt-utils.js'
+import { getMaximumFeeRate } from './maximum-fee-rates.js'
 
 /**
  * Factory function that create the prepareForSigning function for a bitcoin-like asset.
@@ -26,9 +23,19 @@ export function createPrepareForSigning({
 
   return ({ unsignedTx }) => {
     const networkInfo = coinInfo.toBitcoinJS()
+    const maximumFeeRate = getMaximumFeeRate(assetName)
+
+    const psbtOptions = { network: networkInfo }
+    if (maximumFeeRate !== undefined) {
+      psbtOptions.maximumFeeRate = maximumFeeRate
+    }
 
     if (unsignedTx.txData.psbtBuffer) {
-      return createPsbtFromBuffer({ Psbt, psbtBuffer: unsignedTx.txData.psbtBuffer, networkInfo })
+      return createPsbtFromBuffer({
+        Psbt,
+        psbtBuffer: unsignedTx.txData.psbtBuffer,
+        psbtOptions,
+      })
     }
 
     // Create PSBT based on internal Exodus data structure
@@ -41,15 +48,17 @@ export function createPrepareForSigning({
       Psbt,
       Transaction,
     })
-    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
+    setPsbtVersionIfNotBitcoin(psbt, assetName)
 
     return psbt
   }
 }
 
 // Creates a PSBT instance from the passed transaction buffer provided by 3rd parties (e.g. dApps).
-function createPsbtFromBuffer({ Psbt, psbtBuffer, ecc, networkInfo }) {
-  return Psbt.fromBuffer(psbtBuffer, { eccLib: ecc, network: networkInfo })
+function createPsbtFromBuffer({ Psbt, psbtBuffer, ecc, psbtOptions = {} }) {
+  const fromBufferOptions = { ...psbtOptions }
+  if (ecc) fromBufferOptions.eccLib = ecc
+  return Psbt.fromBuffer(psbtBuffer, fromBufferOptions)
 }
 
 // Creates a PSBT instance from the passed inputs, outputs etc. The wallet itself provides this data.
@@ -64,11 +73,18 @@ function createPsbtFromTxData({
   Transaction,
   blockHeight,
 }) {
-  // use harcoded max fee rates for specific assets
-  // if undefined, will be set to default value by PSBT (2500)
-  const maximumFeeRate = _MAXIMUM_FEE_RATES[assetName]
+  // use hardcoded max fee rates for specific assets
+  // if undefined, the PSBT default (5000 sat/vB) is used. Passing `undefined`
+  // directly into the constructor used to clobber the default (buggy behavior),
+  // so we now only set the override when we actually have one.
+  const maximumFeeRate = getMaximumFeeRate(assetName)
+
+  const psbtOptions = { network: networkInfo }
+  if (maximumFeeRate !== undefined) {
+    psbtOptions.maximumFeeRate = maximumFeeRate
+  }
 
-  const psbt = new Psbt({ maximumFeeRate, network: networkInfo })
+  const psbt = new Psbt(psbtOptions)
 
   // If present, add blockHeight as a proprietary field
   if (blockHeight !== undefined) {

package/src/tx-sign/default-sign-hardware.js

@@ -1,6 +1,6 @@
 import assert from 'minimalistic-assert'
 
-import { extractTransaction } from './common.js'
+import { extractTransaction, shouldSkipFinalize } from './common.js'
 import { createPrepareForSigning } from './default-prepare-for-signing.js'
 
 export const signHardwareFactory = ({ assetName, resolvePurpose, keys, coinInfo }) => {
@@ -40,11 +40,7 @@ export const signHardwareFactory = ({ assetName, resolvePurpose, keys, coinInfo
       multisigData,
     })
 
-    const isExternalPsbt =
-      unsignedTx.txData.psbtBuffer &&
-      unsignedTx.txMeta.addressPathsMap &&
-      unsignedTx.txMeta.inputsToSign
-    const skipFinalize = isExternalPsbt || unsignedTx.txMeta.returnPsbt
+    const skipFinalize = shouldSkipFinalize(unsignedTx)
     return extractTransaction({ psbt, skipFinalize })
   }
 }

package/src/tx-sign/maximum-fee-rates.js

@@ -0,0 +1,13 @@
+// We keep hardcoded fee caps here so both signing and PSBT builders reuse the
+// same per-asset overrides (e.g. Dogecoin needs a higher ceiling than the
+// bitcoinjs default). If an asset is missing, the library fallback (5000 sat/vB)
+// will apply instead.
+const MAXIMUM_FEE_RATES = {
+  dogecoin: 12_000,
+  qtumignition: 25_000,
+  ravencoin: 1_000_000,
+}
+
+export function getMaximumFeeRate(assetName) {
+  return MAXIMUM_FEE_RATES[assetName]
+}