@exodus/bitcoin-api 2.6.8 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.6.8",
+  "version": "2.7.1",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -43,5 +43,5 @@
     "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
   },
-  "gitHead": "eae322a1c75f9cdaebc919af510619cb59ba4c0e"
+  "gitHead": "9c993eed3a3bcfc1c49d86377fdc5c7cb731d632"
 }

package/src/account-state.js

@@ -10,6 +10,7 @@ export function createAccountState({ asset, ordinalsEnabled = false, brc20Enable
 
   if (ordinalsEnabled) {
     defaults.ordinalsUtxos = empty
+    defaults.knownBalanceUtxoIds = []
   }
 
   if (brc20Enabled) {

package/src/insight-api-client/index.js

@@ -2,6 +2,7 @@
 import urlJoin from 'url-join'
 import qs from 'querystring'
 import delay from 'delay'
+import { isEmpty } from 'lodash'
 
 const getTextFromResponse = async (response) => {
   try {
@@ -105,13 +106,22 @@ export default class InsightAPIClient {
     const url = urlJoin(this._baseURL, `/tx/${encodedTxId}`)
     const response = await fetch(url)
 
-    // change in https://github.com/jprichardson/exodus-rn/pull/4336 may break Insight compatibility
-    // we're probably past the point of just spinning up an Insight server and have it plug n' play for Magnifier
-
     if (response.status === 404) return null
     return response.json()
   }
 
+  async fetchTxObject(txId) {
+    const url = urlJoin(this._baseURL, `/fulltx?${new URLSearchParams({ hash: txId })}`)
+    const response = await fetch(url)
+
+    if (response.status === 404) return null
+    const object = await response.json()
+    if (isEmpty(object)) {
+      return null
+    }
+    return object
+  }
+
   async fetchRawTx(txId) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/rawtx/${encodedTxId}`)

package/src/tx-log/bitcoin-monitor-scanner.js

@@ -1,11 +1,12 @@
 import { orderTxs } from '../insight-api-client/util'
 import { Address, UtxoCollection } from '@exodus/models'
-import { isEqual, compact, uniq } from 'lodash'
+import { compact, isEqual, uniq } from 'lodash'
 import ms from 'ms'
 import assert from 'minimalistic-assert'
 import { isChangeAddress, isReceiveAddress } from '../address-utils'
 import { getOrdinalsUtxos, getUtxos, partitionUtxos } from '../utxos-utils'
 import { getOrdinalAddress } from '../ordinals-utils'
+import { indexOrdinalUnconfirmedTx } from './ordinals-indexer-utils'
 
 // Time to check whether to drop a sent tx
 const SENT_TIME_TO_DROP = ms('2m')
@@ -67,7 +68,6 @@ export class BitcoinMonitorScanner {
 
     const storedUtxos = getUtxos({ asset, accountState })
     const storedOrdinalUtxos = getOrdinalsUtxos({ asset, accountState })
-    const ordinalAddress = await this.getOrdinalAddress({ walletAccount })
 
     const currentStoredUtxos = storedUtxos.union(storedOrdinalUtxos)
 
@@ -90,7 +90,9 @@ export class BitcoinMonitorScanner {
       : (txs) =>
           txs.filter((tx) => {
             const txItem = currentTxs.get(tx.txid)
-            return txItem && txItem.confirmed
+            const confirmed = txItem && txItem.confirmed
+            const inscriptionsIndexed = txItem?.data?.inscriptionsIndexed
+            return confirmed && (!this.#ordinalsEnabled || inscriptionsIndexed)
           }).length >= txs.length
 
     const unusedAddressIndexes = await assetClientInterface.getUnusedAddressIndexes({
@@ -190,8 +192,30 @@ export class BitcoinMonitorScanner {
         promises.push(promise)
       }
 
-      const txArrays = await Promise.all(promises)
-      return txArrays.reduce((total, some) => total.concat(some), [])
+      const insightTxs = (await Promise.all(promises)).reduce(
+        (total, some) => total.concat(some),
+        []
+      )
+      if (!this.#ordinalsEnabled) {
+        return insightTxs
+      }
+      return Promise.all(
+        insightTxs.map((tx) => {
+          try {
+            return indexOrdinalUnconfirmedTx({
+              tx,
+              currency: this.#asset.currency,
+              insightClient,
+            })
+          } catch (e) {
+            console.warn(
+              `Could not index ${asset.name} ordinal tx ${tx.txid} for wallet account ${walletAccount}. message: ${e.message}`,
+              e
+            )
+            return tx
+          }
+        })
+      )
     }
 
     const gapSearchParameters = newChains.map(({ purpose, chain }) => {
@@ -344,6 +368,15 @@ export class BitcoinMonitorScanner {
         currencies: { [assetName]: currency },
       }
 
+      if (this.#ordinalsEnabled) {
+        txLogItem.data = {
+          ...txLogItem.data,
+          inscriptionsIndexed: txItem.inscriptionsIndexed,
+          sentInscriptions: [],
+          receivedInscriptions: [],
+        }
+      }
+
       let from = []
 
       // if txItem.vin has an address that matches ours, means we've spent this tx
@@ -361,8 +394,13 @@ export class BitcoinMonitorScanner {
         txLogItem.coinAmount = txLogItem.coinAmount.sub(currency.defaultUnit(vin.value))
         isSent = true
         txLogItem.data.sent = []
-        if (ordinalAddress && address.toString() === ordinalAddress.toString()) {
-          txLogItem.data.isInscriptionSent = true
+        if (this.#ordinalsEnabled && vin.inscriptions) {
+          txLogItem.data.sentInscriptions.push(
+            ...vin.inscriptions.map((i) => ({
+              ...i,
+              value: currency.defaultUnit(vin.value).toBaseNumber(),
+            }))
+          )
         }
 
         // this is only used to exclude the utxos in the reducer which is why we don't care about the other fields
@@ -432,8 +470,13 @@ export class BitcoinMonitorScanner {
           txLogItem.data.changeAddress = address
         }
 
-        if (ordinalAddress && address.toString() === ordinalAddress.toString()) {
-          txLogItem.data.isInscriptionReceived = true
+        if (this.#ordinalsEnabled && vout.inscriptions) {
+          txLogItem.data.receivedInscriptions.push(
+            ...vout.inscriptions.map((i) => ({
+              ...i,
+              value: currency.defaultUnit(vout.value).toBaseNumber(),
+            }))
+          )
         }
 
         // it was sent to us...
@@ -450,6 +493,11 @@ export class BitcoinMonitorScanner {
           rbfEnabled: txItem.rbf,
         }
 
+        if (this.#ordinalsEnabled) {
+          output.inscriptionsIndexed = txItem.inscriptionsIndexed
+          output.inscriptions = vout.inscriptions || []
+        }
+
         if (this.#shouldExcludeVoutUtxo({ asset, output, txItem, vout })) {
           return
         }
@@ -540,10 +588,13 @@ export class BitcoinMonitorScanner {
       return !isEqual(chain, originalChain.chain)
     })
 
+    const ordinalAddress = await this.getOrdinalAddress({ walletAccount })
     const utxosData = utxoCol
       ? partitionUtxos({
           allUtxos: utxoCol,
+          ordinalsEnabled: this.#ordinalsEnabled,
           ordinalAddress,
+          knownBalanceUtxoIds: accountState.knownBalanceUtxoIds,
         })
       : {}
 
@@ -603,7 +654,9 @@ export class BitcoinMonitorScanner {
 
     const { utxos, ordinalsUtxos } = partitionUtxos({
       allUtxos: txConfirmedUtxos,
+      ordinalsEnabled: this.#ordinalsEnabled,
       ordinalAddress: await this.getOrdinalAddress({ walletAccount }),
+      knownBalanceUtxoIds: accountState.knownBalanceUtxoIds,
     })
 
     return {

package/src/tx-log/ordinals-indexer-utils.js

@@ -0,0 +1,53 @@
+import { memoizeLruCache } from '@exodus/asset-lib'
+import { cloneDeep } from 'lodash'
+
+export const indexOutputs = ({ tx, currency }) => {
+  const inscriptions = []
+
+  let inputOffset = 0
+  for (let i = 0; i < tx.vin.length; i++) {
+    const vin = tx.vin[i]
+    const value = currency.defaultUnit(vin.value).toBaseNumber()
+    inscriptions.push(
+      ...(vin.inscriptions || []).map((i) => ({ ...i, offset: i.offset + inputOffset }))
+    )
+    inputOffset = value
+  }
+
+  let outputOffset = 0
+  for (let i = 0; i < tx.vout.length; i++) {
+    const vout = tx.vout[i]
+    const value = currency.defaultUnit(vout.value).toBaseNumber()
+    vout.inscriptions = inscriptions
+      .map((i) => ({ ...i, offset: i.offset - outputOffset }))
+      .filter((i) => i.offset >= 0 && i.offset < value)
+    outputOffset = value
+  }
+  tx.inscriptionsMemoryIndexed = true // avoids btc being spent even when the mempool index was done in memory
+  return tx
+}
+
+export const indexOrdinalUnconfirmedTx = memoizeLruCache(
+  async ({ insightClient, currency, tx }) => {
+    if (tx.inscriptionsIndexed || tx.inscriptionsMemoryIndexed) {
+      return tx
+    }
+    const copyTx = cloneDeep(tx)
+    await Promise.all(
+      copyTx.vin.map(async (vin) => {
+        const outputTx = await indexOrdinalUnconfirmedTx({
+          insightClient,
+          currency,
+          tx: await insightClient.fetchTxObject(vin.txid),
+        })
+        if (!outputTx.inscriptionsIndexed && !outputTx.inscriptionsMemoryIndexed) {
+          throw new Error(`Cannot index ${tx.txid}. Input tx ${outputTx.txid} is not indexed. `)
+        }
+        vin.inscriptions = outputTx.vout[vin.vout].inscriptions
+      })
+    )
+    return indexOutputs({ tx: copyTx, currency })
+  },
+  ({ tx }) => tx.txid,
+  100
+)

package/src/tx-send/index.js

@@ -14,7 +14,12 @@ import {
   createOutput as dogecoinCreateOutput,
 } from './dogecoin'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
-import { getOrdinalsUtxos, getUsableUtxos, getUtxos } from '../utxos-utils'
+import {
+  getOrdinalsUtxos,
+  getTransferOrdinalsUtxos,
+  getUsableUtxos,
+  getUtxos,
+} from '../utxos-utils'
 
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
 
@@ -132,6 +137,7 @@ export const createAndBroadcastTXFactory = ({
   getFeeEstimator,
   getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
   allowUnconfirmedRbfEnabledUtxos,
+  ordinalsEnabled = false,
 }) => async (
   { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
   { assetClientInterface }
@@ -167,6 +173,11 @@ export const createAndBroadcastTXFactory = ({
 
   const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
 
+  assert(
+    ordinalsEnabled || !inscriptionIds,
+    'inscriptions cannot be sent when ordinalsEnabled=false '
+  )
+
   const shuffle = (list) => {
     return inscriptionIds ? list : doShuffle(list) // don't shuffle when sending ordinal!!!!
   }
@@ -192,26 +203,9 @@ export const createAndBroadcastTXFactory = ({
 
   const currentOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
   const transferOrdinalsUtxos = inscriptionIds
-    ? currentOrdinalsUtxos.filter((utxo) => inscriptionIds.includes(utxo.inscriptionId)) /// this could be bulk transfer if multiple inscription ids are provided
+    ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos: currentOrdinalsUtxos })
     : undefined
 
-  if (inscriptionIds) {
-    assert(
-      transferOrdinalsUtxos?.size === inscriptionIds.length,
-      `Expected ordinal utxos ${inscriptionIds.length}. Found: ${transferOrdinalsUtxos?.size || 0}`
-    )
-
-    // const unconfirmedOrdinalUtxos = transferOrdinalsUtxos
-    //   .toArray()
-    //   .filter((ordinalUtxo) => !(ordinalUtxo.confirmations > 0))
-    // assert(
-    //   !unconfirmedOrdinalUtxos.length,
-    //   `OrdinalUtxo with inscription ids ${unconfirmedOrdinalUtxos
-    //     .map((utxo) => utxo.inscriptionId)
-    //     .join(', ')} have not confirmed yet`
-    // )
-  }
-
   const insightClient = asset.baseAsset.insightClient
   const currency = asset.currency
   const feeData = await assetClientInterface.getFeeConfig({ assetName })
@@ -434,6 +428,8 @@ 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) {
     const address = Address.create(ourAddress.address, ourAddress.meta)
@@ -446,6 +442,8 @@ export const createAndBroadcastTXFactory = ({
       confirmations: 0,
       rbfEnabled,
     }
+
+    knownBalanceUtxoIds.push(`${changeUtxo.txId}:${changeUtxo.vout}`.toLowerCase())
     remainingUtxos = remainingUtxos.addUtxo(changeUtxo)
   }
   if (replaceTx) {
@@ -454,7 +452,7 @@ export const createAndBroadcastTXFactory = ({
 
   const remainingOrdinalsUtxos = transferOrdinalsUtxos
     ? currentOrdinalsUtxos.difference(transferOrdinalsUtxos)
-    : undefined
+    : currentOrdinalsUtxos
 
   await assetClientInterface.updateAccountState({
     assetName,
@@ -462,6 +460,7 @@ export const createAndBroadcastTXFactory = ({
     newData: {
       utxos: remainingUtxos,
       ordinalsUtxos: remainingOrdinalsUtxos,
+      knownBalanceUtxoIds,
     },
   })
 
@@ -522,7 +521,16 @@ export const createAndBroadcastTXFactory = ({
           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
-          inscriptionIds: inscriptionIds,
+          inscriptionsIndexed: ordinalsEnabled ? true : undefined,
+          sentInscriptions: inscriptionIds
+            ? inscriptionIds.map((inscriptionId) => {
+                return {
+                  inscriptionId,
+                  offset: 0,
+                  value: 0,
+                }
+              })
+            : undefined,
         },
       },
     ],

package/src/tx-sign/common.js

@@ -0,0 +1,29 @@
+export function extractTransaction({ psbt, skipFinalize }) {
+  // If a dapp authored the TX, it expects a serialized PSBT response.
+  // Note: we wouldn't be able to finalise inputs in some cases that's why we serialize before finalizing inputs.
+
+  if (skipFinalize) {
+    const rawPSBT = psbt.toBuffer()
+
+    return { plainTx: { rawPSBT } }
+  } else {
+    // Serialize tx
+    psbt.finalizeAllInputs()
+    const tx = psbt.extractTransaction()
+    const rawTx = tx.toBuffer()
+    const txId = tx.getId()
+
+    // tx needs to be serializable for desktop RPC send => sign communication
+    return { rawTx, txId, tx: serializeTx({ tx }) }
+  }
+}
+
+export const serializeTx = ({ tx }) => {
+  // for desktop compatibility
+  return {
+    virtualSize: tx.virtualSize?.(),
+    outs: tx.outs?.map((out) => ({
+      script: out.script.toString('hex'),
+    })),
+  }
+}

package/src/tx-sign/create-get-key-and-purpose.js

@@ -0,0 +1,47 @@
+import lodash from 'lodash'
+import assert from 'minimalistic-assert'
+import { getOwnProperty } from '@exodus/basic-utils'
+import { getECPair } from '../bitcoinjs-lib'
+
+import secp256k1 from 'secp256k1'
+
+const ECPair = getECPair()
+
+export const createGetKeyAndPurpose = ({
+  keys,
+  hdkeys,
+  resolvePurpose,
+  addressPathsMap,
+  privateKeysAddressMap,
+  coinInfo,
+}) =>
+  lodash.memoize((address) => {
+    const purpose = resolvePurpose(address)
+    const networkInfo = coinInfo.toBitcoinJS()
+    if (privateKeysAddressMap) {
+      return getPrivateKeyFromMap(privateKeysAddressMap, networkInfo, purpose, address)
+    } else {
+      return getPrivateKeyFromHDKeys(hdkeys, addressPathsMap, keys, networkInfo, purpose, address)
+    }
+  })
+
+function getPrivateKeyFromMap(privateKeysAddressMap, networkInfo, purpose, address) {
+  const privateKey = getOwnProperty(privateKeysAddressMap, address, 'string')
+  assert(privateKey, `there is no private key for address ${address}`)
+  const key = ECPair.fromWIF(privateKey, networkInfo)
+  const publicKey = secp256k1.publicKeyCreate(key.privateKey, true)
+  return { key, purpose, publicKey }
+}
+
+function getPrivateKeyFromHDKeys(hdkeys, addressPathsMap, keys, networkInfo, purpose, address) {
+  const path = getOwnProperty(addressPathsMap, address, 'string')
+  assert(hdkeys, 'hdkeys must be provided')
+  assert(purpose, `purpose for address ${address} could not be resolved`)
+  const hdkey = hdkeys[purpose]
+  assert(hdkey, `hdkey for purpose for ${purpose} and address ${address} could not be resolved`)
+  const derivedhdkey = hdkey.derive(path)
+  const privateEncoded = keys.encodePrivate(derivedhdkey.privateKey)
+  const key = ECPair.fromWIF(privateEncoded, networkInfo)
+  const publicKey = derivedhdkey.publicKey
+  return { key, publicKey, purpose }
+}

package/src/tx-sign/create-sign-with-wallet.js

@@ -0,0 +1,70 @@
+import { Transaction, payments } from '@exodus/bitcoinjs-lib'
+
+import { getECPair } from '../bitcoinjs-lib'
+import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
+import { createGetKeyAndPurpose } from './create-get-key-and-purpose'
+import { toAsyncSigner, tweakSigner } from './taproot'
+
+const ECPair = getECPair()
+
+export function createSignWithWallet({
+  keys,
+  hdkeys,
+  resolvePurpose,
+  privateKeysAddressMap,
+  addressPathsMap,
+  coinInfo,
+  network,
+}) {
+  const getKeyAndPurpose = createGetKeyAndPurpose({
+    keys,
+    hdkeys,
+    resolvePurpose,
+    privateKeysAddressMap,
+    addressPathsMap,
+    coinInfo,
+  })
+
+  return async (psbt, inputsToSign) => {
+    // The Taproot SIGHASH flag includes all previous outputs,
+    // so signing is only done AFTER all inputs have been updated
+    for (let index = 0; index < psbt.inputCount; index++) {
+      const inputInfo = inputsToSign[index]
+      // dApps request to sign only specific transaction inputs.
+      if (!inputInfo) continue
+      const { address, sigHash } = inputInfo
+      // TODO: we can remove SIGHASH_ALL, it is default.
+      const sigHashTypes = sigHash !== undefined ? [sigHash || Transaction.SIGHASH_ALL] : undefined
+      const { key, purpose, publicKey } = getKeyAndPurpose(address)
+
+      const isP2SH = purpose === 49
+      const isTaprootAddress = purpose === 86
+
+      if (isP2SH) {
+        // If spending from a P2SH address, we assume the address is P2SH wrapping
+        // P2WPKH. Exodus doesn't use P2SH addresses so we should only ever be
+        // signing a P2SH input if we are importing a private key
+        // BIP143: As a default policy, only compressed public keys are accepted in P2WPKH and P2WSH
+        const p2wpkh = payments.p2wpkh({ pubkey: publicKey })
+        const p2sh = payments.p2sh({ redeem: p2wpkh })
+        if (address === p2sh.address && !Buffer.isBuffer(psbt.data.inputs[index].redeemScript)) {
+          psbt.updateInput(index, {
+            redeemScript: p2sh.redeem.output,
+          })
+        } else {
+          throw new Error('Expected P2SH script to be a nested segwit input')
+        }
+      } else if (isTaprootAddress && !Buffer.isBuffer(psbt.data.inputs[index].tapInternalKey)) {
+        // tapInternalKey is metadata for signing and not part of the hash to sign.
+        // so modifying it here is fine.
+        psbt.updateInput(index, {
+          tapInternalKey: toXOnly(publicKey),
+        })
+      }
+
+      // desktop / BE / mobile with bip-schnorr signing
+      const signingKey = isTaprootAddress ? tweakSigner({ signer: key, ECPair, network }) : key
+      await psbt.signInputAsync(index, toAsyncSigner({ keyPair: signingKey }), sigHashTypes)
+    }
+  }
+}

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

@@ -1,91 +1,8 @@
 import assert from 'minimalistic-assert'
-import lodash from 'lodash'
-import { payments, Psbt, Transaction } from '@exodus/bitcoinjs-lib'
-import { getOwnProperty } from '@exodus/basic-utils'
 
-import secp256k1 from 'secp256k1'
-
-import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
-import { toAsyncSigner, tweakSigner } from './taproot'
-import { getECPair } from '../bitcoinjs-lib'
-
-let ECPair
-
-const _MAXIMUM_FEE_RATES = {
-  qtumignition: 25000,
-  ravencoin: 1000000,
-}
-
-const canParseTx = (rawTxBuffer) => {
-  try {
-    Transaction.fromBuffer(rawTxBuffer)
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-export const serializeTx = ({ tx }) => {
-  // for desktop compatibility
-  return {
-    virtualSize: tx.virtualSize?.(),
-    outs: tx.outs?.map((out) => ({
-      script: out.script.toString('hex'),
-    })),
-  }
-}
-
-// Creates a PSBT instance from the passed inputs, outputs etc. The wallet itself provides this data.
-function createPSBT({ inputs, outputs, rawTxs, networkInfo, getKeyAndPurpose, assetName }) {
-  // 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]
-
-  const psbt = new Psbt({ maximumFeeRate, network: networkInfo })
-
-  // Fill tx
-  for (const { txId, vout, address, value, script, sequence } of inputs) {
-    const { purpose, publicKey } = getKeyAndPurpose(address)
-
-    const isSegwitAddress = purpose === 84
-    const isTaprootAddress = purpose === 86
-    const txIn = { hash: txId, index: vout, sequence }
-    if (isSegwitAddress || isTaprootAddress) {
-      // witness outputs only require the value and the script, not the full transaction
-      txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
-      if (isTaprootAddress) {
-        txIn.tapInternalKey = toXOnly(publicKey)
-      }
-    } else {
-      const rawTx = (rawTxs || []).find((t) => t.txId === txId)
-      // non-witness outptus require the full transaction
-      assert(!!rawTx, 'Non-witness outputs require the full previous transaction.')
-      const rawTxBuffer = Buffer.from(rawTx.rawData, 'hex')
-      if (canParseTx(rawTxBuffer)) {
-        txIn.nonWitnessUtxo = rawTxBuffer
-      } else {
-        // temp fix for https://exodusio.slack.com/archives/CP202D90Q/p1671014704829939 until bitcoinjs could parse a mweb tx without failing
-        console.warn(`Setting psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true for asset ${assetName}`)
-        psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true
-        txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
-      }
-    }
-    psbt.addInput(txIn)
-  }
-
-  for (const [address, amount] of outputs) {
-    psbt.addOutput({ value: amount, address })
-  }
-
-  return psbt
-}
-
-// Creates a PSBT instance from the passed transaction buffer provided by 3rd parties (e.g. dApps).
-function createPSBTFromBuffer({ psbtBuffer, ecc }) {
-  const psbt = Psbt.fromBuffer(psbtBuffer, { eccLib: ecc })
-
-  return psbt
-}
+import { createPrepareForSigning } from './default-prepare-for-signing'
+import { createSignWithWallet } from './create-sign-with-wallet'
+import { extractTransaction } from './common'
 
 export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, network }) => {
   assert(assetName, 'assetName is required')
@@ -93,91 +10,34 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
   assert(keys, 'keys is required')
   assert(coinInfo, 'coinInfo is required')
 
+  const prepareForSigning = createPrepareForSigning({
+    assetName,
+    resolvePurpose,
+    coinInfo,
+  })
+
   return async ({ unsignedTx, hdkeys, privateKeysAddressMap }) => {
     assert(unsignedTx, 'unsignedTx is required')
     assert(hdkeys || privateKeysAddressMap, 'hdkeys or privateKeysAddressMap is required')
-    const { addressPathsMap } = unsignedTx.txMeta
-    const networkInfo = { ...coinInfo.toBitcoinJS(), messagePrefix: '' }
 
-    ECPair = getECPair()
+    const { addressPathsMap } = unsignedTx.txMeta
 
-    const getKeyAndPurpose = lodash.memoize((address) => {
-      const purpose = resolvePurpose(address)
-      if (privateKeysAddressMap) {
-        const privateKey = getOwnProperty(privateKeysAddressMap, address, 'string')
-        assert(privateKey, `there is no private key for address ${address}`)
-        const key = ECPair.fromWIF(privateKey, networkInfo)
-        const publicKey = secp256k1.publicKeyCreate(key.privateKey, true)
-        return { key, purpose, publicKey }
-      }
-      const path = getOwnProperty(addressPathsMap, address, 'string')
-      assert(hdkeys, 'hdkeys must be provided')
-      assert(purpose, `purpose for address ${address} could not be resolved`)
-      const hdkey = hdkeys[purpose]
-      assert(hdkey, `hdkey for purpose for ${purpose} and address ${address} could not be resolved`)
-      const derivedhdkey = hdkey.derive(path)
-      const privateEncoded = keys.encodePrivate(derivedhdkey.privateKey)
-      const key = ECPair.fromWIF(privateEncoded, networkInfo)
-      const publicKey = derivedhdkey.publicKey
-      return { key, publicKey, purpose }
+    const psbt = prepareForSigning({ unsignedTx })
+
+    const inputsToSign = unsignedTx.txMeta.inputsToSign || unsignedTx.txData.inputs
+    const signWithWallet = createSignWithWallet({
+      keys,
+      hdkeys,
+      resolvePurpose,
+      privateKeysAddressMap,
+      addressPathsMap,
+      coinInfo,
+      network,
     })
 
-    const isPsbtBufferPassed =
-      unsignedTx.txData.psbtBuffer &&
-      unsignedTx.txMeta.addressPathsMap &&
-      unsignedTx.txMeta.inputsToSign
-    const psbt = isPsbtBufferPassed
-      ? createPSBTFromBuffer({ psbtBuffer: unsignedTx.txData.psbtBuffer })
-      : createPSBT({ ...unsignedTx.txData, ...unsignedTx.txMeta, getKeyAndPurpose, networkInfo })
-    const { inputs } = unsignedTx.txData
-
-    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
-
-    const inputsToSign = isPsbtBufferPassed ? unsignedTx.txMeta.inputsToSign : inputs
-
-    // The Taproot SIGHASH flag includes all previous outputs,
-    // so signing is only done AFTER all inputs have been updated
-    for (let index = 0; index < psbt.inputCount; index++) {
-      const inputInfo = inputsToSign[index]
-      // dApps request to sign only specific transaction inputs.
-      if (!inputInfo) continue
-      const { address, sigHash } = inputInfo
-      const sigHashTypes = sigHash !== undefined ? [sigHash || Transaction.SIGHASH_ALL] : undefined
-      const { key, purpose, publicKey } = getKeyAndPurpose(address)
-
-      // We shouldn't modify dApp PSBTs.
-      if (purpose === 49 && !isPsbtBufferPassed) {
-        // If spending from a P2SH address, we assume the address is P2SH wrapping
-        // P2WPKH. Exodus doesn't use P2SH addresses so we should only ever be
-        // signing a P2SH input if we are importing a private key
-        // BIP143: As a default policy, only compressed public keys are accepted in P2WPKH and P2WSH
-        const p2wpkh = payments.p2wpkh({ pubkey: publicKey })
-        const p2sh = payments.p2sh({ redeem: p2wpkh })
-        psbt.updateInput(index, {
-          redeemScript: p2sh.redeem.output,
-        })
-      }
-
-      // desktop / BE / mobile with bip-schnorr signing
-      const isTaprootAddress = purpose === 86
-      const signingKey = isTaprootAddress ? tweakSigner({ signer: key, ECPair, network }) : key
-      await psbt.signInputAsync(index, toAsyncSigner({ keyPair: signingKey }), sigHashTypes)
-    }
-
-    // If a dapp authored the TX, it expects a serialized PSBT response.
-    // Note: we wouldn't be able to finalise inputs in some cases that's why we serialize before finalizing inputs.
-    if (isPsbtBufferPassed) {
-      const rawPSBT = psbt.toBuffer()
-
-      return { plainTx: { rawPSBT } }
-    }
-    // Serialize tx
-    psbt.finalizeAllInputs()
-    const tx = psbt.extractTransaction()
-    const rawTx = tx.toBuffer()
-    const txId = tx.getId()
+    await signWithWallet(psbt, inputsToSign)
 
-    // tx needs to be serializable for desktop RPC send => sign communication
-    return { rawTx, txId, tx: serializeTx({ tx }) }
+    const skipFinalize = !!unsignedTx.txData.psbtBuffer
+    return extractTransaction({ psbt, skipFinalize })
   }
 }

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

@@ -0,0 +1,103 @@
+import assert from 'minimalistic-assert'
+import { Psbt, Transaction } from '@exodus/bitcoinjs-lib'
+
+const _MAXIMUM_FEE_RATES = {
+  qtumignition: 25000,
+  ravencoin: 1000000,
+}
+
+/**
+ * Factory function that create the prepareForSigning function for a bitcoin-like asset.
+ * @param { assetName, resolvePurpose, coinInfo} dependencies
+ * @returns A prepareForSigning function that returns a PSBTv1 as buffer
+ */
+export function createPrepareForSigning({ assetName, resolvePurpose, coinInfo }) {
+  assert(assetName, 'assetName is required')
+  assert(resolvePurpose, 'resolvePurpose is required')
+  assert(coinInfo, 'coinInfo is required')
+
+  return ({ unsignedTx }) => {
+    const isPsbtBufferPassed =
+      unsignedTx.txData.psbtBuffer &&
+      unsignedTx.txMeta.addressPathsMap &&
+      unsignedTx.txMeta.inputsToSign
+    if (isPsbtBufferPassed) {
+      // PSBT created externally (Web3, etc..)
+      return createPsbtFromBuffer({ psbtBuffer: unsignedTx.txData.psbtBuffer })
+    } else {
+      // Create PSBT based on internal Exodus data structure
+      const networkInfo = coinInfo.toBitcoinJS()
+      const psbt = createPsbtFromTxData({
+        ...unsignedTx.txData,
+        ...unsignedTx.txMeta,
+        resolvePurpose,
+        networkInfo,
+      })
+      if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
+
+      return psbt
+    }
+  }
+}
+
+// Creates a PSBT instance from the passed transaction buffer provided by 3rd parties (e.g. dApps).
+function createPsbtFromBuffer({ psbtBuffer, ecc }) {
+  const psbt = Psbt.fromBuffer(psbtBuffer, { eccLib: ecc })
+
+  return psbt
+}
+
+// Creates a PSBT instance from the passed inputs, outputs etc. The wallet itself provides this data.
+function createPsbtFromTxData({ inputs, outputs, rawTxs, networkInfo, resolvePurpose, assetName }) {
+  // 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]
+
+  const psbt = new Psbt({ maximumFeeRate, network: networkInfo })
+
+  // Fill tx
+  for (const { txId, vout, address, value, script, sequence } of inputs) {
+    // TODO: don't use the purpose as intermediate variable
+    // see internals of `resolvePurposes`, just use `isP2TR, isP2SH etc directly
+    const purpose = resolvePurpose(address)
+
+    const isSegwitAddress = purpose === 84
+    const isTaprootAddress = purpose === 86
+
+    const txIn = { hash: txId, index: vout, sequence }
+    if (isSegwitAddress || isTaprootAddress) {
+      // witness outputs only require the value and the script, not the full transaction
+      txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
+    } else {
+      const rawTx = (rawTxs || []).find((t) => t.txId === txId)
+      // non-witness outptus require the full transaction
+      assert(!!rawTx, 'Non-witness outputs require the full previous transaction.')
+      const rawTxBuffer = Buffer.from(rawTx.rawData, 'hex')
+      if (canParseTx(rawTxBuffer)) {
+        txIn.nonWitnessUtxo = rawTxBuffer
+      } else {
+        // temp fix for https://exodusio.slack.com/archives/CP202D90Q/p1671014704829939 until bitcoinjs could parse a mweb tx without failing
+        console.warn(`Setting psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true for asset ${assetName}`)
+        psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true
+        txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
+      }
+    }
+
+    psbt.addInput(txIn)
+  }
+
+  for (const [address, amount] of outputs) {
+    psbt.addOutput({ value: amount, address })
+  }
+
+  return psbt
+}
+
+const canParseTx = (rawTxBuffer) => {
+  try {
+    Transaction.fromBuffer(rawTxBuffer)
+    return true
+  } catch (e) {
+    return false
+  }
+}

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

@@ -0,0 +1,98 @@
+import assert from 'minimalistic-assert'
+
+import { createPrepareForSigning } from './default-prepare-for-signing'
+import { extractTransaction } from './common'
+
+export const signHardwareFactory = ({ assetName, resolvePurpose, keys, coinInfo }) => {
+  assert(assetName, 'assetName is required')
+  assert(resolvePurpose, 'resolvePurpose is required')
+  assert(keys, 'keys is required')
+  assert(coinInfo, 'coinInfo is required')
+
+  const prepareForSigning = createPrepareForSigning({
+    assetName,
+    resolvePurpose,
+    coinInfo,
+  })
+
+  const signWithHardwareWallet = createSignWithHardwareWallet({
+    assetName,
+    resolvePurpose,
+  })
+
+  return async ({ unsignedTx, hardwareDevice, accountIndex }) => {
+    assert(unsignedTx, 'unsignedTx is required')
+    assert(hardwareDevice, 'hardwareDevice is required')
+    assert(Number.isInteger(accountIndex), 'accountIndex must be integer')
+
+    const { addressPathsMap } = unsignedTx.txMeta
+
+    const psbt = prepareForSigning({ unsignedTx })
+
+    const inputsToSign = unsignedTx.txMeta.inputsToSign || unsignedTx.txData.inputs
+
+    await signWithHardwareWallet({
+      psbt,
+      inputsToSign,
+      addressPathsMap,
+      hardwareDevice,
+      accountIndex,
+    })
+
+    const skipFinalize = !!unsignedTx.txData.psbtBuffer
+    return extractTransaction({ psbt, skipFinalize })
+  }
+}
+
+function createSignWithHardwareWallet({ assetName, resolvePurpose }) {
+  return async ({ psbt, inputsToSign, addressPathsMap, accountIndex, hardwareDevice }) => {
+    const derivationPaths = getDerivationPaths({ resolvePurpose, addressPathsMap, accountIndex })
+    const signatures = await hardwareDevice.signTransaction({
+      assetName,
+      signableTransaction: psbt.toBuffer(),
+      derivationPaths,
+    })
+
+    applySignatures(psbt, signatures, inputsToSign)
+  }
+}
+
+function getDerivationPaths({ resolvePurpose, accountIndex, addressPathsMap }) {
+  let derivationPaths = []
+  for (const [address, path] of Object.entries(addressPathsMap)) {
+    const purpose = resolvePurpose(address)
+    const derivationPath = `m/${purpose}'/0'/${accountIndex}'/${path.slice(2)}` // TODO: coinindex
+    derivationPaths.push(derivationPath)
+  }
+  return derivationPaths
+}
+
+export function applySignatures(psbt, signatures, inputsToSign) {
+  for (let inputIndex = 0; inputIndex < psbt.inputCount; inputIndex++) {
+    const shouldSign = !!inputsToSign[inputIndex]
+    if (shouldSign) {
+      const signature = signatures.find((signature) => signature.inputIndex === inputIndex)
+      if (signature) {
+        const isTaprootSig = signature.publicKey.length === 32
+        if (isTaprootSig) {
+          psbt.data.updateInput(inputIndex, {
+            tapKeySig: signature.signature,
+          })
+        } else {
+          psbt.data.updateInput(inputIndex, {
+            partialSig: [
+              {
+                pubkey: signature.publicKey,
+                signature: signature.signature,
+              },
+            ],
+          })
+        }
+      } else {
+        throw new Error(
+          `expected to sign for inputIndex ${inputIndex} but no signature was produced`
+        )
+      }
+    }
+  }
+}

package/src/tx-sign/index.js

@@ -1 +1,3 @@
-export { signTxFactory, serializeTx } from './default-create-tx'
+export { signTxFactory } from './default-create-tx'
+export { serializeTx } from './common'
+export { signHardwareFactory } from './default-sign-hardware'

package/src/tx-sign/taproot.js

@@ -3,12 +3,14 @@ import assert from 'minimalistic-assert'
 import { getSchnorrEntropy } from './default-entropy'
 import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
 import { eccFactory } from '../bitcoinjs-lib/ecc'
+import { getECPair } from '../bitcoinjs-lib'
 
 const ecc = eccFactory()
+const ECPair = getECPair()
 
-export function tweakSigner({ signer, ECPair, tweakHash, network }) {
+export function tweakSigner({ signer, tweakHash, network }) {
   assert(signer, 'signer is required')
-  assert(ECPair, 'ECPair is required')
+
   let privateKey = signer.privateKey
   if (!privateKey) {
     throw new Error('Private key is required for tweaking signer!')

package/src/utxos-utils.js

@@ -5,6 +5,46 @@ import assert from 'minimalistic-assert'
 
 const MAX_ORDINAL_VALUE_POSTAGE = 10000
 
+export function getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos }) {
+  const transferOrdinalsUtxos = ordinalsUtxos.filter((utxo) =>
+    utxo.inscriptions?.some((i) => inscriptionIds.includes(i.inscriptionId))
+  )
+  const unsafeInscriptions = transferOrdinalsUtxos.toArray().flatMap(
+    (utxo) =>
+      utxo.inscriptions?.filter((i) => {
+        const validInscription = isValidInscription({
+          value: utxo.value.toBaseNumber(),
+          offset: i.offset,
+        })
+        return validInscription && !inscriptionIds.includes(i.inscriptionId)
+      }) || []
+  )
+  assert(
+    !unsafeInscriptions.length,
+    `The following inscriptions are unsafe ${unsafeInscriptions.map(
+      (i) => i.inscriptionId
+    )} when ${inscriptionIds} should be spent`
+  )
+
+  const transferInscriptionIds = transferOrdinalsUtxos
+    .toArray()
+    .flatMap((utxo) => utxo.inscriptions)
+    .filter(({ inscriptionId }) => inscriptionIds.includes(inscriptionId))
+
+  assert(
+    transferInscriptionIds.length === inscriptionIds.length,
+    `Expected inscriptions ${inscriptionIds.length}. Found: ${transferInscriptionIds.length}`
+  )
+  return transferOrdinalsUtxos
+}
+
+export function isValidInscription({ value, offset }) {
+  assert(typeof value === 'number', 'value must be a number')
+  assert(typeof offset === 'number', 'offset must be a number')
+  // value >= 0 in case offset, alternatively convert to string/ln
+  return (value >= 0 && value <= MAX_ORDINAL_VALUE_POSTAGE) || offset === 0
+}
+
 export function getUtxos({ accountState, asset }) {
   return (
     accountState?.utxos ||
@@ -23,31 +63,41 @@ export function getOrdinalsUtxos({ accountState, asset }) {
   )
 }
 
-function isOrdinalUtxo({ utxo, ordinalAddress }) {
-  if (utxo.inscriptionId) {
-    return true
-  }
-  if (!ordinalAddress) {
-    // exclude utxos splitting
+export function getValidInscriptions({ utxo }) {
+  return (utxo.inscriptions || []).filter((i) =>
+    isValidInscription({ value: utxo.value.toBaseNumber(), offset: i.offset })
+  )
+}
+
+function isOrdinalUtxo({ utxo, ordinalsEnabled, knownBalanceUtxoIds }) {
+  if (!ordinalsEnabled) {
     return false
   }
 
-  if (utxo.address.toString() === ordinalAddress.toString()) {
-    return true // we assume any utxo to the ordinal address is a ordinal utxos just in case
+  const utxoId = `${utxo.txId}:${utxo.vout}`.toLowerCase()
+
+  if (knownBalanceUtxoIds?.includes(utxoId) && !utxo.inscriptionsIndexed) {
+    return false // this allows users see and spend change balance after sending before hiro confirmation
   }
 
-  if (utxo.confirmations) {
-    return false
+  if (!utxo.inscriptionsIndexed) {
+    return true
   }
 
-  return utxo.value.toBaseNumber() <= MAX_ORDINAL_VALUE_POSTAGE // while unconfirmed, put  < 10000- sats in the ordinal utxos box just in case
+  const validInscriptions = getValidInscriptions({ utxo })
+  return validInscriptions.length > 0
 }
 
-export function partitionUtxos({ allUtxos, ordinalAddress }) {
+export function partitionUtxos({ allUtxos, ordinalsEnabled, knownBalanceUtxoIds }) {
   assert(allUtxos, 'allUtxos is required')
+  // assert(ordinalAddress, 'ordinalAddress is required') // not used atm we may need to tune by ordinalAddress when unconfirmed or rubbish inscriptions
   return {
-    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalAddress })),
-    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalAddress })),
+    utxos: allUtxos.filter(
+      (utxo) => !isOrdinalUtxo({ utxo, ordinalsEnabled, knownBalanceUtxoIds })
+    ),
+    ordinalsUtxos: allUtxos.filter((utxo) =>
+      isOrdinalUtxo({ utxo, ordinalsEnabled, knownBalanceUtxoIds })
+    ),
   }
 }
 
@@ -68,12 +118,20 @@ export function getConfirmedOrRfbDisabledUtxos({ utxos, allowUnconfirmedRbfEnabl
   return utxos.filter((utxo) => utxo.confirmations > 0 || !utxo.rbfEnabled)
 }
 
+function filterDustUtxos({ utxos, feeData }) {
+  if (feeData.utxoDustValue) {
+    return utxos.filter((utxo) => utxo.value.toBaseNumber() > feeData.utxoDustValue)
+  }
+  return utxos
+}
+
 export function getUsableUtxos({ asset, utxos, feeData, txSet }) {
   assert(asset, 'asset is required')
   assert(utxos, 'utxos is required')
   assert(feeData, 'feeData is required')
   assert(txSet, 'txSet is required')
-  if (!['bitcoin', 'bitcointestnet', 'bitcoinregtest'].includes(asset.name)) return utxos
+  if (!['bitcoin', 'bitcointestnet', 'bitcoinregtest'].includes(asset.name))
+    return filterDustUtxos({ utxos, feeData })
   const { fastestFee } = feeData
   const feeRate = fastestFee.toBaseNumber()
   const maxFee = feeData.maxExtraCpfpFee
@@ -85,7 +143,9 @@ export function getUsableUtxos({ asset, utxos, feeData, txSet }) {
     feeRate,
     maxFee,
   })
-  return largeUnconfirmedTxs.size === 0
-    ? utxos
-    : utxos.filter((utxo) => !largeUnconfirmedTxs.has(utxo.txId))
+  const confirmedAndSmallUtxos =
+    largeUnconfirmedTxs.size === 0
+      ? utxos
+      : utxos.filter((utxo) => !largeUnconfirmedTxs.has(utxo.txId))
+  return filterDustUtxos({ utxos: confirmedAndSmallUtxos, feeData })
 }