@exodus/bitcoin-api 2.3.16 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.3.16",
+  "version": "2.4.1",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -40,6 +40,5 @@
   "devDependencies": {
     "@exodus/bitcoin-meta": "^1.0.1",
     "jest-when": "^3.5.1"
-  },
-  "gitHead": "ea21eb60e35f84cf2086ae0304bf9fa8ce4058b1"
+  }
 }

package/src/account-state.js

@@ -1,11 +1,22 @@
 import { AccountState, UtxoCollection } from '@exodus/models'
 
-export function createAccountState({ asset }) {
+export function createAccountState({ asset, ordinalsEnabled = false, brc20Enabled = false }) {
+  const empty = UtxoCollection.createEmpty({
+    currency: asset.currency,
+  })
+  const defaults = {
+    utxos: empty,
+  }
+
+  if (ordinalsEnabled) {
+    defaults.ordinalsUtxos = empty
+  }
+
+  if (brc20Enabled) {
+    defaults.brc20Balances = {}
+  }
+
   return class BitcoinAccountState extends AccountState {
-    static defaults = {
-      utxos: UtxoCollection.createEmpty({
-        currency: asset.currency,
-      }),
-    }
+    static defaults = defaults
   }
 }

package/src/address-utils.js

@@ -0,0 +1,24 @@
+import assert from 'minimalistic-assert'
+
+export function isOrdinalAddress(address, ordinalChainIndex) {
+  assert(typeof ordinalChainIndex === 'number', `ordinalChainIndex must be a number`)
+  return parsePath(address)[0] === ordinalChainIndex
+}
+
+export function isReceiveAddress(address): boolean {
+  return parsePath(address)[0] === 0
+}
+
+export function isChangeAddress(address): boolean {
+  return parsePath(address)[0] === 1
+}
+
+function parsePath(address) {
+  assert(
+    address.meta.path,
+    `address parameter ${address} does not have a meta.path. Is it a valid Address object?`
+  )
+  const path = address.meta.path
+  const p1 = path ? path.replace('m/', '').split('/') : ['0', '0']
+  return p1.map((i) => parseInt(i, 10))
+}

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

@@ -14,15 +14,39 @@ export class GetFeeResolver {
     this.#allowUnconfirmedRbfEnabledUtxos = allowUnconfirmedRbfEnabledUtxos
   }
 
-  getFee = ({ asset, accountState, txSet, feeData, amount, customFee, isSendAll }) => {
+  getFee = ({
+    asset,
+    accountState,
+    txSet,
+    feeData,
+    amount,
+    customFee,
+    isSendAll,
+    nft, // sending one nft
+    brc20, // sending multiple inscriptions ids (as in sending multiple transfer ordinals)
+  }) => {
+    if (nft) {
+      assert(!amount, 'amount must not be provided when nft is provided!!!')
+      assert(!isSendAll, 'isSendAll must not be provided when nft is provided!!!')
+      assert(!brc20, 'brc20 must not be provided when nft is provided!!!')
+    }
+    if (brc20) {
+      // assert(!amount, 'amount must not be provided when brc20 is provided!!!')
+      assert(!isSendAll, 'isSendAll must not be provided when brc20 is provided!!!')
+      assert(!nft, 'nft must not be provided when brc20 is provided!!!')
+    }
+
+    const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20?.inscriptionIds
+
     const { resolvedFee, extraFee } = this.#getUtxosData({
       asset,
       accountState,
       txSet,
       feeData,
-      amount,
+      amount: brc20 ? undefined : amount,
       customFee,
       isSendAll,
+      inscriptionIds,
     })
     return { fee: resolvedFee, extraFee }
   }
@@ -49,7 +73,16 @@ export class GetFeeResolver {
     }).spendableBalance
   }
 
-  #getUtxosData = ({ asset, accountState, txSet, feeData, amount, customFee, isSendAll }) => {
+  #getUtxosData = ({
+    asset,
+    accountState,
+    txSet,
+    feeData,
+    amount,
+    customFee,
+    isSendAll,
+    inscriptionIds,
+  }) => {
     assert(asset, 'asset must be provided')
     assert(feeData, 'feeData must be provided')
     assert(accountState, 'accountState must be provided')
@@ -65,10 +98,6 @@ export class GetFeeResolver {
     })
     const replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
 
-    const receiveAddress = ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name)
-      ? 'P2WSH'
-      : 'P2PKH'
-
     const feePerKB = customFee || feeData.feePerKB
     return getUtxosData({
       asset,
@@ -76,7 +105,7 @@ export class GetFeeResolver {
       replaceableTxs,
       amount,
       feeRate: feePerKB,
-      receiveAddress,
+      inscriptionIds,
       isSendAll: isSendAll,
       getFeeEstimator: this.#getFeeEstimator,
       allowUnconfirmedRbfEnabledUtxos: this.#allowUnconfirmedRbfEnabledUtxos,
@@ -91,7 +120,6 @@ export class GetFeeResolver {
       accountState,
       feeData,
       getFeeEstimator: this.#getFeeEstimator,
-
       allowUnconfirmedRbfEnabledUtxos: this.#allowUnconfirmedRbfEnabledUtxos,
     })
   }

package/src/fee/utxo-selector.js

@@ -6,19 +6,44 @@ import { getConfirmedUtxos, getConfirmedOrRfbDisabledUtxos } from '../utxos-util
 
 const MIN_RELAY_FEE = 1000
 
+const getBestReceiveAddresses = ({ asset, receiveAddress, inscriptionIds }) => {
+  if (inscriptionIds) {
+    return receiveAddress || 'P2TR'
+  }
+  if (receiveAddress === null) {
+    return null
+  }
+
+  return ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name) ? 'P2WSH' : 'P2PKH'
+}
+
 export const selectUtxos = ({
   asset,
   usableUtxos,
   replaceableTxs,
   amount,
   feeRate,
-  receiveAddress = 'P2WSH',
+  receiveAddress, // it could be null
   isSendAll,
   getFeeEstimator,
   disableReplacement = false,
   mustSpendUtxos,
   allowUnconfirmedRbfEnabledUtxos,
+  inscriptionIds, // for each inscription transfer, we need to calculate one more input and one more output
 }) => {
+  const resolvedReceiveAddresses = getBestReceiveAddresses({
+    asset,
+    receiveAddress,
+    inscriptionIds,
+  })
+
+  const receiveAddresses = []
+  if (inscriptionIds) {
+    receiveAddresses.push(...inscriptionIds.map(() => resolvedReceiveAddresses))
+  } else {
+    receiveAddresses.push(resolvedReceiveAddresses)
+  }
+
   assert(asset, 'asset is required')
   assert(usableUtxos, 'usableUtxos is required')
   assert(getFeeEstimator, 'getFeeEstimator is required')
@@ -34,6 +59,7 @@ 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 &&
@@ -53,6 +79,7 @@ export const selectUtxos = ({
       }
 
       const replaceFeeEstimator = getFeeEstimator(asset, { feePerKB })
+      // 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)
@@ -60,9 +87,7 @@ export const selectUtxos = ({
             ...tx.data.sent.map(({ address }) => address),
             tx.data.changeAddress?.address || changeAddressType,
           ]
-      if (receiveAddress) {
-        outputs.push(receiveAddress)
-      }
+      if (receiveAddresses.find(Boolean)) outputs.push(...receiveAddresses)
 
       let fee
       let additionalUtxos
@@ -78,9 +103,11 @@ export const selectUtxos = ({
           if (confirmedUtxosArray.length === 0) {
             // Try estimating fee with no change
             if (replaceTxAmount.add(additionalUtxos.value).lt(amount.add(fee))) {
-              const noChangeOutputs = receiveAddress
-                ? [...tx.data.sent.map(({ address }) => address), receiveAddress]
-                : tx.data.sent.map(({ address }) => address)
+              const noChangeOutputs = [
+                ...tx.data.sent.map(({ address }) => address),
+                ...receiveAddresses,
+              ]
+
               fee = replaceFeeEstimator({
                 inputs: inputs.union(additionalUtxos),
                 outputs: noChangeOutputs,
@@ -95,7 +122,7 @@ export const selectUtxos = ({
         }
       }
       if (isSendAll || replaceTxAmount.add(additionalUtxos.value).gte(amount.add(fee))) {
-        const chainOutputs = isSendAll ? [receiveAddress] : [receiveAddress, changeAddressType]
+        const chainOutputs = isSendAll ? receiveAddresses : [...receiveAddresses, changeAddressType]
         const chainFee = feeEstimator({
           inputs: changeUtxos.union(additionalUtxos),
           outputs: chainOutputs,
@@ -132,7 +159,7 @@ export const selectUtxos = ({
 
   if (isSendAll) {
     const selectedUtxos = UtxoCollection.fromArray(utxosArray, { currency })
-    const fee = feeEstimator({ inputs: selectedUtxos, outputs: [receiveAddress] })
+    const fee = feeEstimator({ inputs: selectedUtxos, outputs: receiveAddresses })
     if (selectedUtxos.value.lt(amount.add(fee))) {
       return { fee }
     }
@@ -159,7 +186,10 @@ export const selectUtxos = ({
   let selectedUtxos = UtxoCollection.fromArray(selectedUtxosArray, { currency })
 
   // start figuring out fees
-  const outputs = amount.isZero ? [changeAddressType] : [receiveAddress, changeAddressType]
+  const outputs =
+    amount.isZero && !inscriptionIds
+      ? [changeAddressType]
+      : [...receiveAddresses, changeAddressType]
 
   let fee = feeEstimator({ inputs: selectedUtxos, outputs })
 
@@ -167,7 +197,7 @@ export const selectUtxos = ({
     // We ran out of UTXOs, give up now
     if (remainingUtxosArray.length === 0) {
       // Try fee with no change
-      fee = feeEstimator({ inputs: selectedUtxos, outputs: [receiveAddress] })
+      fee = feeEstimator({ inputs: selectedUtxos, outputs: receiveAddresses })
       break
     }
 
@@ -193,6 +223,7 @@ export const getUtxosData = ({
   disableReplacement,
   mustSpendUtxos,
   allowUnconfirmedRbfEnabledUtxos,
+  inscriptionIds,
 }) => {
   const { selectedUtxos, replaceTx, fee } = selectUtxos({
     asset,
@@ -206,6 +237,7 @@ export const getUtxosData = ({
     disableReplacement,
     mustSpendUtxos,
     allowUnconfirmedRbfEnabledUtxos,
+    inscriptionIds,
   })
 
   const resolvedFee = replaceTx ? fee.sub(replaceTx.feeAmount) : fee

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

@@ -3,26 +3,13 @@ import { orderTxs } from '../insight-api-client/util'
 import { Address, UtxoCollection } from '@exodus/models'
 import { isEqual, compact, uniq } from 'lodash'
 import ms from 'ms'
-
 import assert from 'minimalistic-assert'
-import { getUtxos } from '../utxos-utils'
+import { isChangeAddress, isReceiveAddress } from '../address-utils'
+import { getOrdinalsUtxos, getUtxos, partitionUtxos } from '../utxos-utils'
 
 // Time to check whether to drop a sent tx
 const SENT_TIME_TO_DROP = ms('2m')
 
-function isReceiveAddress(addr: Address): boolean {
-  return parsePath(addr.meta.path)[0] === 0
-}
-function isChangeAddress(addr: Address): boolean {
-  return parsePath(addr.meta.path)[0] === 1
-}
-
-function parsePath(path) {
-  let p1 = path ? path.replace('m/', '').split('/') : ['0', '0']
-  p1 = p1.map((i) => parseInt(i, 10))
-  return p1
-}
-
 export class BitcoinMonitorScanner {
   #asset
   #insightClient
@@ -30,6 +17,8 @@ export class BitcoinMonitorScanner {
   #txFetchLimitResolver
   #shouldExcludeVoutUtxo
   #yieldToUI
+  #ordinalsEnabled
+  #ordinalChainIndex
 
   constructor({
     asset,
@@ -38,6 +27,8 @@ export class BitcoinMonitorScanner {
     yieldToUI = () => {},
     shouldExcludeVoutUtxo = () => false,
     txFetchLimitResolver = ({ refresh }) => (refresh ? 50 : 10),
+    ordinalsEnabled,
+    ordinalChainIndex,
   }) {
     assert(asset, 'asset is required!')
     assert(assetClientInterface, 'assetClientInterface is required!')
@@ -51,6 +42,8 @@ export class BitcoinMonitorScanner {
     this.#assetClientInterface = assetClientInterface
     this.#txFetchLimitResolver = txFetchLimitResolver
     this.#shouldExcludeVoutUtxo = shouldExcludeVoutUtxo
+    this.#ordinalsEnabled = ordinalsEnabled
+    this.#ordinalChainIndex = ordinalChainIndex
   }
 
   async rescanBlockchainInsight({ walletAccount, refresh }) {
@@ -64,7 +57,11 @@ export class BitcoinMonitorScanner {
     const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
     const currency = asset.currency
     const currentTxs = await assetClientInterface.getTxLog({ assetName, walletAccount })
-    const currentUtxos = getUtxos({ asset, accountState })
+
+    const storedUtxos = getUtxos({ asset, accountState })
+    const storedOrdinalUtxos = getOrdinalsUtxos({ asset, accountState })
+
+    const currentStoredUtxos = storedUtxos.union(storedOrdinalUtxos)
 
     const currentTime = new Date().getTime()
     const unconfirmedTxsToCheck = Array.from(currentTxs).reduce((txs, tx) => {
@@ -221,6 +218,21 @@ export class BitcoinMonitorScanner {
         })
         .flat()
 
+      if (
+        fetchCount === 0 &&
+        this.#ordinalsEnabled &&
+        this.#ordinalChainIndex > 1 &&
+        purposes.includes(86)
+      ) {
+        // this is the ordinal address
+        chainObjects.push({
+          purpose: 86,
+          chainIndex: this.#ordinalChainIndex,
+          startAddressIndex: 0,
+          endAddressIndex: 1,
+        })
+      }
+
       const addresses = await aggregateAddresses(chainObjects)
 
       const txs = await fetchAllTxs(addresses)
@@ -243,6 +255,11 @@ export class BitcoinMonitorScanner {
           const metaAddressIndex = parseInt(pd[2])
           const addressString = String(address)
           const purposeToUpdate = purposeMap[addressString]
+
+          if (metaChainIndex === this.#ordinalChainIndex && this.#ordinalChainIndex > 1) {
+            return
+          }
+
           if (!purposeToUpdate) {
             console.warn(`${assetName}: Cannot resolve purpose from address ${addressString}`)
             return
@@ -466,8 +483,8 @@ export class BitcoinMonitorScanner {
     let utxoCol = UtxoCollection.fromArray(utxos, { currency })
 
     const utxosToRemoveCol = UtxoCollection.fromArray(utxosToRemove, { currency })
-    // if something else can update currentUtxos in the meantime, we probably need to grab it from state again
-    utxoCol = utxoCol.union(currentUtxos.difference(utxosToRemoveCol))
+    // if something else can update currentStoredUtxos in the meantime, we probably need to grab it from state again
+    utxoCol = currentStoredUtxos.union(utxoCol.difference(utxosToRemoveCol))
 
     for (let tx of Object.values(unconfirmedTxsToCheck)) {
       existingTxs.push({ ...tx, dropped: true }) // TODO: this will decrease the chain index, it shouldn't be an issue considering the gap limit
@@ -491,7 +508,7 @@ export class BitcoinMonitorScanner {
     }
 
     // no changes, ignore
-    if (utxoCol.equals(currentUtxos)) {
+    if (utxoCol.equals(currentStoredUtxos)) {
       utxoCol = null
     }
 
@@ -501,10 +518,14 @@ export class BitcoinMonitorScanner {
       return !isEqual(chain, originalChain.chain)
     })
 
+    const utxosData = utxoCol
+      ? partitionUtxos({ allUtxos: utxoCol, ordinalChainIndex: this.#ordinalChainIndex })
+      : {}
+
     return {
       txsToUpdate: existingTxs,
       txsToAdd: newTxs,
-      utxos: utxoCol,
+      ...utxosData,
       changedUnusedAddressIndexes,
     }
   }
@@ -517,6 +538,8 @@ export class BitcoinMonitorScanner {
     const accountState = await aci.getAccountState({ assetName, walletAccount })
 
     const storedUtxos = getUtxos({ accountState, asset })
+    const storedOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
+    const allStoredUtxos = storedUtxos.union(storedOrdinalsUtxos)
 
     const currentTxs = Array.from(await aci.getTxLog({ assetName, walletAccount }))
 
@@ -551,13 +574,16 @@ export class BitcoinMonitorScanner {
       })
       .filter((tx) => Object.keys(tx).length > 1)
 
-    // Note about storedUtxos.clone(): updateConfirmations mutates the ordinal utxos, it's not possible to perform the equals below if not cloned
-    const updatedUtxos = confirmationsList.length
-      ? storedUtxos.clone().updateConfirmations(confirmationsList)
-      : null
+    const txConfirmedUtxos = allStoredUtxos.updateConfirmations(confirmationsList)
+
+    const { utxos, ordinalsUtxos } = partitionUtxos({
+      allUtxos: txConfirmedUtxos,
+      ordinalChainIndex: this.#ordinalChainIndex,
+    })
 
     return {
-      utxos: !updatedUtxos || updatedUtxos.equals(storedUtxos) ? null : updatedUtxos,
+      utxos: utxos.equals(storedUtxos) ? null : utxos,
+      ordinalsUtxos: ordinalsUtxos.equals(storedOrdinalsUtxos) ? null : ordinalsUtxos,
       txsToUpdate: updatedPropertiesTxs,
     }
   }

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

@@ -1,5 +1,5 @@
 import assert from 'minimalistic-assert'
-import { isEmpty, isEqual } from 'lodash'
+import { isEmpty, isEqual, pickBy } from 'lodash'
 
 import { BaseMonitor } from '@exodus/asset-lib'
 import InsightWSClient from '../insight-api-client/ws'
@@ -142,17 +142,21 @@ export class Monitor extends BaseMonitor {
     const assetName = asset.name
     const walletAccounts = await aci.getWalletAccounts({ assetName })
     for (const walletAccount of walletAccounts) {
-      const { txsToUpdate, utxos } = await this.#scanner.rescanOnNewBlock({
+      const { txsToUpdate, utxos, ordinalsUtxos } = await this.#scanner.rescanOnNewBlock({
         walletAccount,
       })
 
-      if (utxos) {
+      if (utxos || ordinalsUtxos) {
         await aci.updateAccountState({
           assetName,
           walletAccount,
-          newData: {
-            utxos,
-          },
+          newData: pickBy(
+            {
+              utxos,
+              ordinalsUtxos,
+            },
+            Boolean
+          ),
         })
       }
 
@@ -211,6 +215,7 @@ export class Monitor extends BaseMonitor {
       txsToAdd,
       txsToUpdate,
       utxos,
+      ordinalsUtxos,
       changedUnusedAddressIndexes,
     } = await this.#scanner.rescanBlockchainInsight({
       walletAccount,
@@ -218,7 +223,18 @@ export class Monitor extends BaseMonitor {
     })
     const accountState = await aci.getAccountState({ assetName, walletAccount })
 
-    if (utxos) await aci.updateAccountState({ assetName, walletAccount, newData: { utxos } })
+    if (utxos || ordinalsUtxos)
+      await aci.updateAccountState({
+        assetName,
+        walletAccount,
+        newData: pickBy(
+          {
+            utxos,
+            ordinalsUtxos,
+          },
+          Boolean
+        ),
+      })
 
     if (!isEmpty(changedUnusedAddressIndexes)) {
       // Only for mobile atm, browser and hydra calculates from the latest txLogs

package/src/tx-send/index.js

@@ -1,6 +1,6 @@
 import assert from 'minimalistic-assert'
 // Using this notation so it can be mocked by jest
-import shuffle from 'lodash/shuffle'
+import doShuffle from 'lodash/shuffle'
 
 import { UtxoCollection, Address } from '@exodus/models'
 import { retry } from '@exodus/simple-retry'
@@ -14,7 +14,7 @@ import {
   createOutput as dogecoinCreateOutput,
 } from './dogecoin'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
-import { getUsableUtxos, getUtxos } from '../utxos-utils'
+import { getOrdinalsUtxos, getUsableUtxos, getUtxos } from '../utxos-utils'
 
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
 
@@ -132,7 +132,10 @@ export const createAndBroadcastTXFactory = ({
   getFeeEstimator,
   getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
   allowUnconfirmedRbfEnabledUtxos,
-}) => async ({ asset, walletAccount, address, amount, options }, { assetClientInterface }) => {
+}) => async (
+  { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
+  { assetClientInterface }
+) => {
   const {
     multipleAddressesEnabled,
     feePerKB,
@@ -142,30 +145,73 @@ export const createAndBroadcastTXFactory = ({
     isBip70,
     bumpTxId,
     isRbfAllowed = true,
+    nft,
+    feeOpts,
   } = options
 
+  const brc20 = options.brc20 || feeOpts?.brc20 // feeOpts is the only way I've found atm to pass brc20 param without changing the tx-send hydra module
+
+  const asset = maybeToken.baseAsset
+
+  const isToken = maybeToken.name !== asset.name
+
+  if (isToken) {
+    assert(brc20, 'brc20 is required when sending bitcoin token')
+  }
+
+  const amount = isToken ? asset.currency.ZERO : tokenAmount
+
+  const assetName = asset.name
+
+  const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
+
+  const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
+
+  const shuffle = (list) => {
+    return inscriptionIds ? list : doShuffle(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'
   )
 
-  const useCashAddress = asset.address.isCashAddress?.(address)
-
-  const assetName = asset.name
+  if (inscriptionIds) {
+    assert(!bumpTxId, 'only inscriptionIds or bumpTxId must be provided')
+    assert(address, 'address must be provided when sending ordinals')
+  }
 
-  const receiveAddresses = await assetClientInterface.getReceiveAddresses({
-    walletAccount,
-    assetName,
-    multiAddressMode: true,
-  })
+  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 accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
+
+  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
+    : 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 })
@@ -188,7 +234,7 @@ export const createAndBroadcastTXFactory = ({
     }
   }
 
-  const rbfEnabled = feeData.rbfEnabled && !isExchange && !isBip70 && isRbfAllowed
+  const rbfEnabled = feeData.rbfEnabled && !isExchange && !isBip70 && isRbfAllowed && !nft && !brc20
 
   let utxosToBump
   if (bumpTxId) {
@@ -204,9 +250,10 @@ export const createAndBroadcastTXFactory = ({
     }
   }
 
-  const sendAmount = bumpTxId ? asset.currency.ZERO : amount.toDefault()
-  let receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
+  const sendAmount = bumpTxId || transferOrdinalsUtxos ? asset.currency.ZERO : amount.toDefault()
+  const receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
   const feeRate = feeData.feePerKB
+  const resolvedIsSendAll = (!rbfEnabled && feePerKB) || transferOrdinalsUtxos ? false : isSendAll
 
   let { selectedUtxos, fee, replaceTx } = selectUtxos({
     asset,
@@ -214,11 +261,12 @@ export const createAndBroadcastTXFactory = ({
     replaceableTxs,
     amount: sendAmount,
     feeRate: customFee || feeRate,
-    receiveAddress,
-    isSendAll: !rbfEnabled && feePerKB ? false : isSendAll,
+    receiveAddress: receiveAddress,
+    isSendAll: resolvedIsSendAll,
     getFeeEstimator: (asset, { feePerKB }) => getFeeEstimator(asset, feePerKB),
     mustSpendUtxos: utxosToBump,
     allowUnconfirmedRbfEnabledUtxos,
+    inscriptionIds,
   })
 
   if (!selectedUtxos && !replaceTx) throw new Error('Not enough funds.')
@@ -231,7 +279,9 @@ export const createAndBroadcastTXFactory = ({
   if (bumpTxId && (!selectedUtxos || (replaceTx && replaceTx.txId !== bumpTxId))) {
     throw new Error(`Unable to bump ${bumpTxId}`)
   }
-
+  if (transferOrdinalsUtxos) {
+    selectedUtxos = transferOrdinalsUtxos.union(selectedUtxos)
+  }
   if (replaceTx) {
     replaceTx = replaceTx.clone()
     replaceTx = replaceTx.update({ data: { ...replaceTx.data } })
@@ -239,6 +289,7 @@ export const createAndBroadcastTXFactory = ({
       return { ...to, amount: parseCurrency(to.amount, asset.currency) }
     })
     selectedUtxos = selectedUtxos.union(
+      // how to avoid replace tx inputs when inputs are ordinals? !!!!
       UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
     )
   }
@@ -255,14 +306,25 @@ export const createAndBroadcastTXFactory = ({
     outputs = []
   }
   if (address) {
-    outputs.push(createOutput(assetName, address, sendAmount))
+    if (transferOrdinalsUtxos) {
+      outputs.push(
+        ...transferOrdinalsUtxos
+          .toArray()
+          .map((ordinalUtxo) => createOutput(assetName, address, ordinalUtxo.value))
+      )
+    } else {
+      outputs.push(createOutput(assetName, address, sendAmount))
+    }
   }
 
   const totalAmount = replaceTx
     ? replaceTx.data.sent.reduce((total, { amount }) => total.add(amount), sendAmount)
     : sendAmount
 
-  const change = selectedUtxos.value.sub(totalAmount).sub(fee)
+  const change = selectedUtxos.value
+    .sub(totalAmount)
+    .sub(transferOrdinalsUtxos?.value || currency.ZERO)
+    .sub(fee)
   const dust = getDustValue(asset)
   let ourAddress = replaceTx?.data?.changeAddress || changeAddress
   if (asset.address.toLegacyAddress) {
@@ -377,18 +439,29 @@ export const createAndBroadcastTXFactory = ({
     remainingUtxos = remainingUtxos.difference(remainingUtxos.getTxIdUtxos(replaceTx.txId))
   }
 
+  const remainingOrdinalsUtxos = transferOrdinalsUtxos
+    ? currentOrdinalsUtxos.difference(transferOrdinalsUtxos)
+    : undefined
+
   await assetClientInterface.updateAccountState({
     assetName,
     walletAccount,
-    accountState,
-    newData: { utxos: remainingUtxos },
+    newData: {
+      utxos: remainingUtxos,
+      ordinalsUtxos: remainingOrdinalsUtxos,
+    },
   })
 
+  const walletAddresses = await assetClientInterface.getReceiveAddresses({
+    walletAccount,
+    assetName,
+    multiAddressMode: true,
+  })
   // There are two cases of bumping, replacing or chaining a self-send.
   // If we have a bumpTxId, but we aren't replacing, then it is a self-send.
   const selfSend = bumpTxId
     ? !replaceTx
-    : receiveAddresses.some((receiveAddress) => String(receiveAddress) === String(address))
+    : walletAddresses.some((receiveAddress) => String(receiveAddress) === String(address))
 
   const displayReceiveAddress = asset.address.displayAddress?.(receiveAddress) || receiveAddress
 
@@ -400,15 +473,21 @@ export const createAndBroadcastTXFactory = ({
     ? replaceTx.data.sent.concat([{ address: displayReceiveAddress, amount }])
     : [{ address: displayReceiveAddress, amount }]
 
+  const coinAmount = selfSend
+    ? maybeToken.currency.ZERO
+    : isToken
+    ? tokenAmount.abs().negate()
+    : totalAmount.abs().negate()
+
   await assetClientInterface.updateTxLogAndNotify({
-    assetName,
+    assetName: maybeToken.name,
     walletAccount,
     txs: [
       {
         txId,
         confirmations: 0,
-        coinAmount: selfSend ? currency.ZERO : totalAmount.abs().negate(),
-        coinName: assetName,
+        coinAmount,
+        coinName: maybeToken.name,
         feeAmount: fee,
         feeCoinName: assetName,
         selfSend,
@@ -421,6 +500,8 @@ 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
+          inscriptionIds: inscriptionIds,
         },
       },
     ],
@@ -457,6 +538,7 @@ function defaultCreateInputs(utxos, rbfEnabled) {
     value: parseInt(utxo.value.toBaseString(), 10),
     script: utxo.script,
     sequence: getTxSequence(rbfEnabled),
+    inscriptionId: utxo.inscriptionId,
   }))
 }
 

package/src/utxos-utils.js

@@ -2,6 +2,9 @@
 import { UtxoCollection } from '@exodus/models'
 import { findLargeUnconfirmedTxs } from './tx-utils'
 import assert from 'minimalistic-assert'
+import { isOrdinalAddress } from './address-utils'
+
+const MAX_ORDINAL_VALUE_POSTAGE = 10000
 
 export function getUtxos({ accountState, asset }) {
   return (
@@ -12,6 +15,41 @@ export function getUtxos({ accountState, asset }) {
   )
 }
 
+export function getOrdinalsUtxos({ accountState, asset }) {
+  return (
+    accountState?.ordinalsUtxos ||
+    UtxoCollection.createEmpty({
+      currency: asset.currency,
+    })
+  )
+}
+
+function isOrdinalUtxo({ utxo, ordinalChainIndex }) {
+  if (utxo.inscriptionId) {
+    return true
+  }
+  if (ordinalChainIndex === undefined || ordinalChainIndex < 0) {
+    // exclude utxos splitting
+    return false
+  }
+
+  const maybeAnOrdinalAddress =
+    ordinalChainIndex && isOrdinalAddress(utxo.address, ordinalChainIndex) // if wallet receives utxos to the special address, consider it as ordinal
+  if (utxo.confirmations) {
+    return maybeAnOrdinalAddress
+  }
+
+  return utxo.value.toBaseNumber() <= MAX_ORDINAL_VALUE_POSTAGE || maybeAnOrdinalAddress // while unconfirmed, put  < 10000- sats in the ordinal utxos box just in case
+}
+
+export function partitionUtxos({ allUtxos, ordinalChainIndex }) {
+  assert(allUtxos, 'allUtxos is required')
+  return {
+    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalChainIndex })),
+    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalChainIndex })),
+  }
+}
+
 export function getConfirmedUtxos({ utxos }) {
   assert(utxos, 'utxos is required')
   return utxos.filter(({ confirmations }) => confirmations > 0)