@exodus/bitcoin-api 2.5.0-alpha.0 → 2.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.5.0-alpha.0",
+  "version": "2.5.1",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -39,7 +39,9 @@
   },
   "devDependencies": {
     "@exodus/bitcoin-meta": "^1.0.1",
+    "@scure/base": "^1.1.3",
+    "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
   },
-  "gitHead": "04641210f5ac2a4b490cf348b2917b28cf463ba2"
+  "gitHead": "562c288cde1c1d7c7ab2c7bc6b1804ccca9b37f2"
 }

package/src/address-utils.js

@@ -1,10 +1,5 @@
 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
 }

package/src/bitcoinjs-lib/ecc/common.js

@@ -1,5 +1,5 @@
 import secp256k1 from '@exodus/secp256k1'
-import { toXOnly } from '../../tx-sign/taproot'
+import { toXOnly } from '../ecc-utils'
 
 /**
  * Common ecc functions between mobile and desktop. Once mobile accepts @noble/secp256k1, we can unify both

package/src/bitcoinjs-lib/ecc-utils.js

@@ -0,0 +1,3 @@
+export const toXOnly = (publicKey) => {
+  return publicKey.slice(1, 33)
+}

package/src/bitcoinjs-lib/script-classify/index.js

@@ -1,5 +1,4 @@
 import { payments } from 'bitcoinjs-lib'
-import assert from 'minimalistic-assert'
 
 function isPaymentFactory(payment: any): (script: Buffer, eccLib?: any) => boolean {
   return (script: Buffer, eccLib?: any): boolean => {
@@ -31,10 +30,9 @@ const types = {
   NONSTANDARD: 'nonstandard',
 }
 
-const outputFactory = ({ ecc }) => (script: Buffer) => {
-  assert(ecc, 'ecc is required')
+const outputFactory = () => (script: Buffer) => {
   if (isP2WPKH(script)) return types.P2WPKH
-  if (isP2TR(script, ecc)) return types.P2TR
+  if (isP2TR(script)) return types.P2TR
   if (isP2PKH(script)) return types.P2PKH
   if (isP2MS(script)) return types.P2MS
   if (isP2PK(script)) return types.P2PK

package/src/btc-like-address.js

@@ -8,14 +8,12 @@ export const createBtcLikeAddress = ({
   versions,
   coinInfo,
   bitcoinjsLib: bitcoinjsLibFork,
-  ecc,
   useBip86 = false,
   validateFunctions = {},
   extraFunctions = {},
 }) => {
   assert(versions, 'versions is required')
   assert(coinInfo, 'coinInfo is required')
-  assert(ecc, 'ecc is required')
 
   const bs58validateFactory = (version) =>
     version === undefined
@@ -55,7 +53,7 @@ export const createBtcLikeAddress = ({
       ((addr) => {
         try {
           const network = coinInfo.toBitcoinJS()
-          bitcoinjsLibFork.payments.p2tr({ address: addr, network }, { eccLib: ecc })
+          bitcoinjsLibFork.payments.p2tr({ address: addr, network })
           return true
         } catch (e) {
           return false
@@ -91,7 +89,7 @@ export const createBtcLikeAddress = ({
 
   const toScriptPubKey = (string) => {
     const network = coinInfo.toBitcoinJS()
-    return bitcoinjsOriginal.address.toOutputScript(string, network, ecc)
+    return bitcoinjsOriginal.address.toOutputScript(string, network)
   }
 
   const fromScriptPubKey = (scriptPubKey) => {

package/src/btc-like-keys.js

@@ -6,7 +6,8 @@ import { identity, pickBy } from 'lodash'
 import * as defaultBitcoinjsLib from 'bitcoinjs-lib'
 import secp256k1 from 'secp256k1'
 import { hash160 } from './hash-utils'
-import { toXOnly } from './tx-sign/taproot'
+import { toXOnly } from './bitcoinjs-lib/ecc-utils'
+import { eccFactory } from './bitcoinjs-lib/ecc'
 
 export const publicKeyToHashFactory = (p2pkh) => (publicKey) => {
   const payload = Buffer.concat([Buffer.from([p2pkh]), hash160(publicKey)])
@@ -16,14 +17,13 @@ export const publicKeyToHashFactory = (p2pkh) => (publicKey) => {
 export const createBtcLikeKeys = ({
   coinInfo,
   versions,
-  ecc,
   useBip86 = false,
   bitcoinjsLib = defaultBitcoinjsLib,
   extraFunctions = {},
 }) => {
   assert(coinInfo, 'coinInfo is required')
   assert(versions, 'versions is required')
-  assert(ecc, 'ecc is required')
+  const ecc = eccFactory()
   const {
     encodePrivate: encodePrivateCustom,
     encodePublic: encodePublicCustom,
@@ -91,10 +91,7 @@ export const createBtcLikeKeys = ({
     (useBip86
       ? (publicKey: Buffer): string => {
           const network = coinInfo.toBitcoinJS()
-          return bitcoinjsLib.payments.p2tr(
-            { internalPubkey: toXOnly(publicKey), network },
-            { eccLib: ecc }
-          ).address
+          return bitcoinjsLib.payments.p2tr({ internalPubkey: toXOnly(publicKey), network }).address
         }
       : undefined)
 

package/src/fee/fee-estimator.js

@@ -53,12 +53,11 @@ const scriptPubKeyLengths = {
 // 10 = version: 4, locktime: 4, inputs and outputs count: 1
 // 148 = txId: 32, vout: 4, count: 1, script: 107 (max), sequence: 4
 // 34 = value: 8, count: 1, scriptPubKey: 25 (P2PKH) and 23 (P2SH)
-export const getSizeFactory = ({ ecc, defaultOutputType, addressApi }) => {
-  assert(ecc, 'ecc is required')
+export const getSizeFactory = ({ defaultOutputType, addressApi }) => {
   assert(defaultOutputType, 'defaultOutputType is required')
   assert(addressApi, 'addressApi is required')
 
-  const scriptClassifier = scriptClassifierFactory({ ecc, addressApi })
+  const scriptClassifier = scriptClassifierFactory({ addressApi })
 
   return (
     asset: Object,
@@ -166,8 +165,8 @@ export const getSizeFactory = ({ ecc, defaultOutputType, addressApi }) => {
   }
 }
 
-const getFeeEstimatorFactory = ({ ecc, defaultOutputType, addressApi }) => {
-  const getSize = getSizeFactory({ ecc, defaultOutputType, addressApi })
+const getFeeEstimatorFactory = ({ defaultOutputType, addressApi }) => {
+  const getSize = getSizeFactory({ defaultOutputType, addressApi })
   return createDefaultFeeEstimator(getSize)
 }
 export default getFeeEstimatorFactory

package/src/fee/script-classifier.js

@@ -16,11 +16,10 @@ const hashStringIfTooBig = (str) =>
         .slice(0, maxSize)
     : str
 
-export const scriptClassifierFactory = ({ addressApi, ecc }) => {
-  assert(ecc, 'ecc is required')
+export const scriptClassifierFactory = ({ addressApi }) => {
   assert(addressApi, 'addressApi is required')
 
-  const classifyOutput = scriptClassify.outputFactory({ ecc })
+  const classifyOutput = scriptClassify.outputFactory()
 
   const classifyScriptHex = memoizeLruCache(
     ({ assetName, script }) => {
@@ -42,6 +41,7 @@ export const scriptClassifierFactory = ({ addressApi, ecc }) => {
       else if (addressApi.isP2TR && addressApi.isP2TR(address)) return P2TR
       else if (addressApi.isP2WSH && addressApi.isP2WSH(address)) return P2WSH
       return classifyScriptHex({
+        assetName,
         classifyOutput,
         script: addressApi.toScriptPubKey(address).toString('hex'),
       })

package/src/index.js

@@ -16,3 +16,6 @@ export * from './unconfirmed-ancestor-data'
 export * from './parse-unsigned-tx'
 export * from './insight-api-client/util'
 export * from './move-funds'
+export { toAsyncSigner } from './tx-sign/taproot'
+export { toXOnly } from './bitcoinjs-lib/ecc-utils'
+export * from './ordinals-utils'

package/src/ordinals-utils.js

@@ -0,0 +1,22 @@
+import assert from 'minimalistic-assert'
+
+export function getOrdinalAddress({
+  asset,
+  assetClientInterface,
+  walletAccount,
+  ordinalChainIndex,
+}) {
+  assert(asset, 'asset is required')
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(walletAccount, 'walletAccount is required')
+  if (ordinalChainIndex === undefined) {
+    return undefined
+  }
+  return assetClientInterface.getAddress({
+    assetName: asset.name,
+    walletAccount,
+    purpose: 86,
+    chainIndex: ordinalChainIndex,
+    addressIndex: 0,
+  })
+}

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

@@ -6,6 +6,7 @@ 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'
 
 // Time to check whether to drop a sent tx
 const SENT_TIME_TO_DROP = ms('2m')
@@ -519,7 +520,10 @@ export class BitcoinMonitorScanner {
     })
 
     const utxosData = utxoCol
-      ? partitionUtxos({ allUtxos: utxoCol, ordinalChainIndex: this.#ordinalChainIndex })
+      ? partitionUtxos({
+          allUtxos: utxoCol,
+          ordinalAddress: await this.getOrdinalAddress({ walletAccount }),
+        })
       : {}
 
     return {
@@ -578,7 +582,7 @@ export class BitcoinMonitorScanner {
 
     const { utxos, ordinalsUtxos } = partitionUtxos({
       allUtxos: txConfirmedUtxos,
-      ordinalChainIndex: this.#ordinalChainIndex,
+      ordinalAddress: await this.getOrdinalAddress({ walletAccount }),
     })
 
     return {
@@ -587,4 +591,13 @@ export class BitcoinMonitorScanner {
       txsToUpdate: updatedPropertiesTxs,
     }
   }
+
+  getOrdinalAddress({ walletAccount }) {
+    return getOrdinalAddress({
+      asset: this.#asset,
+      assetClientInterface: this.#assetClientInterface,
+      walletAccount,
+      ordinalChainIndex: this.#ordinalChainIndex,
+    })
+  }
 }

package/src/tx-send/index.js

@@ -201,15 +201,15 @@ export const createAndBroadcastTXFactory = ({
       `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 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
@@ -305,6 +305,8 @@ export const createAndBroadcastTXFactory = ({
   } else {
     outputs = []
   }
+
+  let sendOutput
   if (address) {
     if (transferOrdinalsUtxos) {
       outputs.push(
@@ -313,7 +315,8 @@ export const createAndBroadcastTXFactory = ({
           .map((ordinalUtxo) => createOutput(assetName, address, ordinalUtxo.value))
       )
     } else {
-      outputs.push(createOutput(assetName, address, sendAmount))
+      sendOutput = createOutput(assetName, address, sendAmount)
+      outputs.push(sendOutput)
     }
   }
 
@@ -408,17 +411,23 @@ export const createAndBroadcastTXFactory = ({
     }
   }
 
-  let changeUtxoIndex = -1
-  if (changeOutput) {
-    for (let i = 0; i < outputs.length; i++) {
-      const [address, amount] = outputs[i]
-      if (changeOutput[0] === address && changeOutput[1] === amount) {
-        changeUtxoIndex = i
-        break
+  function findUtxoIndex(output) {
+    let utxoIndex = -1
+    if (output) {
+      for (let i = 0; i < outputs.length; i++) {
+        const [address, amount] = outputs[i]
+        if (output[0] === address && output[1] === amount) {
+          utxoIndex = i
+          break
+        }
       }
     }
+    return utxoIndex
   }
 
+  const changeUtxoIndex = findUtxoIndex(changeOutput)
+  const sendUtxoIndex = findUtxoIndex(sendOutput)
+
   const { script, size } = getSizeAndChangeScript({ assetName, tx, rawTx, changeUtxoIndex, txId })
 
   let remainingUtxos = usableUtxos.difference(selectedUtxos)
@@ -518,7 +527,12 @@ export const createAndBroadcastTXFactory = ({
     })
   }
 
-  return { txId, replacedTxId: replaceTx?.txId }
+  return {
+    txId,
+    sendUtxoIndex,
+    sendAmount: sendAmount.toBaseNumber(),
+    replacedTxId: replaceTx?.txId,
+  }
 }
 
 export function createInputs(assetName, ...rest) {

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

@@ -6,7 +6,9 @@ import { getOwnProperty } from '@exodus/basic-utils'
 
 import secp256k1 from 'secp256k1'
 
-import { toAsyncSigner, toXOnly, tweakSigner } from './taproot'
+import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
+import { toAsyncSigner, tweakSigner } from './taproot'
+import { eccFactory } from '../bitcoinjs-lib/ecc'
 
 let ECPair
 
@@ -34,28 +36,71 @@ export const serializeTx = ({ tx }) => {
   }
 }
 
-export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, network, ecc }) => {
+// 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
+}
+
+export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, network }) => {
   assert(assetName, 'assetName is required')
   assert(resolvePurpose, 'resolvePurpose is required')
   assert(keys, 'keys is required')
   assert(coinInfo, 'coinInfo is required')
-  assert(ecc, 'ecc is required')
+
   return async ({ unsignedTx, hdkeys, privateKeysAddressMap }): Object => {
     assert(unsignedTx, 'unsignedTx is required')
     assert(hdkeys || privateKeysAddressMap, 'hdkeys or privateKeysAddressMap is required')
-    const { addressPathsMap, rawTxs } = unsignedTx.txMeta
-    const { inputs, outputs } = unsignedTx.txData
+    const { addressPathsMap } = unsignedTx.txMeta
     const networkInfo = { ...coinInfo.toBitcoinJS(), messagePrefix: '' }
 
-    // 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, eccLib: ecc, network: networkInfo })
-
-    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
-
-    ECPair = ECPair || ECPairFactory(ecc)
+    ECPair = ECPair || ECPairFactory(eccFactory())
 
     const getKeyAndPurpose = lodash.memoize((address) => {
       const purpose = resolvePurpose(address)
@@ -78,44 +123,27 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
       return { key, publicKey, purpose }
     })
 
-    // Fill tx
-    for (const { txId, vout, address, value, script, sequence } of inputs) {
-      const { purpose, publicKey } = getKeyAndPurpose(address)
+    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
 
-      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)
-    }
+    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
 
-    for (const [address, amount] of outputs) {
-      psbt.addOutput({ value: amount, address })
-    }
+    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 < inputs.length; index++) {
-      const { address } = inputs[index]
+    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 ? [sigHash] : undefined
       const { key, purpose, publicKey } = getKeyAndPurpose(address)
 
       if (purpose === 49) {
@@ -130,19 +158,19 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
         })
       }
 
-      if (ecc.signSchnorrAsync) {
-        // desktop / BE / mobile with bip-schnorr signing
-        const isTaprootAddress = purpose === 86
-        const signingKey = isTaprootAddress
-          ? tweakSigner({ signer: key, ECPair, ecc, network })
-          : key
-        await psbt.signInputAsync(index, toAsyncSigner({ keyPair: signingKey, ecc }))
-      } else {
-        // mobile signing
-        psbt.signInput(index, key)
-      }
+      // 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()

package/src/tx-sign/taproot.js

@@ -1,11 +1,14 @@
 import { crypto } from 'bitcoinjs-lib'
 import assert from 'minimalistic-assert'
 import { getSchnorrEntropy } from './default-entropy'
+import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
+import { eccFactory } from '../bitcoinjs-lib/ecc'
 
-export function tweakSigner({ signer, ECPair, ecc, tweakHash, network }) {
+const ecc = eccFactory()
+
+export function tweakSigner({ signer, ECPair, tweakHash, network }) {
   assert(signer, 'signer is required')
   assert(ECPair, 'ECPair is required')
-  assert(ecc, 'ecc is required')
   let privateKey: Uint8Array | undefined = signer.privateKey
   if (!privateKey) {
     throw new Error('Private key is required for tweaking signer!')
@@ -34,9 +37,8 @@ function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
 /**
  * Take a sync signer and make it async.
  */
-export function toAsyncSigner({ keyPair, ecc }) {
+export function toAsyncSigner({ keyPair }) {
   assert(keyPair, 'keyPair is required')
-  assert(ecc, 'ecc is required')
   keyPair.sign = async (h) => {
     const sig = await ecc.signAsync(h, keyPair.privateKey)
     return Buffer.from(sig)
@@ -48,7 +50,3 @@ export function toAsyncSigner({ keyPair, ecc }) {
   }
   return keyPair
 }
-
-export const toXOnly = (publicKey) => {
-  return publicKey.slice(1, 33)
-}

package/src/utxos-utils.js

@@ -2,7 +2,6 @@
 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
 
@@ -24,29 +23,31 @@ export function getOrdinalsUtxos({ accountState, asset }) {
   )
 }
 
-function isOrdinalUtxo({ utxo, ordinalChainIndex }) {
+function isOrdinalUtxo({ utxo, ordinalAddress }) {
   if (utxo.inscriptionId) {
     return true
   }
-  if (ordinalChainIndex === undefined || ordinalChainIndex < 0) {
+  if (!ordinalAddress) {
     // 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.address.toString() === ordinalAddress.toString()) {
+    return true // we assume any utxo to the ordinal address is a ordinal utxos just in case
+  }
+
   if (utxo.confirmations) {
-    return maybeAnOrdinalAddress
+    return false
   }
 
-  return utxo.value.toBaseNumber() <= MAX_ORDINAL_VALUE_POSTAGE || maybeAnOrdinalAddress // while unconfirmed, put  < 10000- sats in the ordinal utxos box just in case
+  return utxo.value.toBaseNumber() <= MAX_ORDINAL_VALUE_POSTAGE // while unconfirmed, put  < 10000- sats in the ordinal utxos box just in case
 }
 
-export function partitionUtxos({ allUtxos, ordinalChainIndex }) {
+export function partitionUtxos({ allUtxos, ordinalAddress }) {
   assert(allUtxos, 'allUtxos is required')
   return {
-    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalChainIndex })),
-    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalChainIndex })),
+    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalAddress })),
+    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalAddress })),
   }
 }