@exodus/bitcoin-api 1.0.0-alpha.4 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -21,7 +21,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/bitcoinjs-lib": "6.0.2-beta.4",
-    "@exodus/keychain": "^2.0.0",
+    "@exodus/keychain": "^3.0.0",
     "@exodus/models": "^8.10.4",
     "@exodus/secp256k1": "4.0.2-exodus.0",
     "@exodus/simple-retry": "0.0.6",
@@ -33,5 +33,7 @@
     "socket.io-client": "2.1.1",
     "url-join": "4.0.0"
   },
-  "gitHead": "ba3e6b48c4f717a74e59fc832e306b60ab4df06d"
+  "devDependencies": {
+    "@noble/secp256k1": "~1.5.3"
+  }
 }

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

@@ -0,0 +1,44 @@
+import secp256k1 from '@exodus/secp256k1'
+
+/**
+ * Common ecc functions between mobile and desktop. Once mobile accepts @noble/secp256k1, we can unify both
+ */
+export const common = {
+  // These methods have been addded in order to comply with the public interface
+  // In practice the async version will be used
+  sign: (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
+    secp256k1.ecdsaSign(h, d, { data: e }).signature,
+  verify: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean =>
+    secp256k1.ecdsaVerify(signature, h, Q),
+
+  privateAdd: (d: Uint8Array, tweak: Uint8Array): Uint8Array | null =>
+    // cloning input. secp256k1 modifies it and it cannot be reused/cached
+    secp256k1.privateKeyTweakAdd(Buffer.from(d), tweak),
+
+  privateNegate: (d: Uint8Array): Uint8Array =>
+    // cloning input. secp256k1 modifies it and it cannot be reused/cached
+    secp256k1.privateKeyNegate(Buffer.from(d)),
+
+  xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array) => {
+    try {
+      const t = secp256k1.publicKeyTweakAdd(toPubKey(p), tweak)
+      return {
+        parity: t[0] === 0x02 ? 0 : 1,
+        xOnlyPubkey: t.slice(1, 33),
+      }
+    } catch (err) {
+      return null
+    }
+  },
+
+  isPrivate: (d: Uint8Array): boolean => secp256k1.privateKeyVerify(d),
+  pointFromScalar: (d: Uint8Array, compressed?: boolean): Uint8Array | null =>
+    secp256k1.publicKeyCreate(d, compressed),
+}
+
+export const toPubKey = (xOnly: Uint8Array) => {
+  const p = new Uint8Array(33)
+  p.set([0x02])
+  p.set(xOnly, 1)
+  return p
+}

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

@@ -0,0 +1,49 @@
+import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
+import { Point, schnorr, sign } from '@noble/secp256k1'
+import { common, toPubKey } from './common'
+
+/**
+ * Wrapper around `secp256k1` in order to follow the bitcoinjs-lib `TinySecp256k1Interface`
+ * Schnorr signatures are offered by @noble/secp256k1
+ */
+export const desktopEcc: TinySecp256k1Interface = {
+  ...common,
+
+  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
+    sign(h, d, {
+      extraEntropy,
+      canonical: true,
+      der: false,
+    }),
+
+  signSchnorrAsync: async (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
+    schnorr.sign(h, d, e),
+  verifySchnorrAsync: async (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean =>
+    schnorr.verify(signature, h, Q),
+
+  // The underlying library does not expose sync functions for Schnorr sign and verify.
+  // These function are explicitly defined here as `null` for documentation purposes.
+  signSchnorr: null,
+  verifySchnorr: null,
+
+  isPoint: (p: Uint8Array): boolean => {
+    try {
+      Point.fromHex(p).assertValidity()
+      return true
+    } catch {
+      return false
+    }
+  },
+
+  isXOnlyPoint: (p: Uint8Array): boolean => {
+    try {
+      Point.fromHex(toPubKey(p)).assertValidity()
+      return true
+    } catch {
+      return false
+    }
+  },
+
+  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
+    Point.fromHex(p).toRawBytes(compressed),
+}

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

@@ -1,81 +1,2 @@
-import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
-// TODO: temp import until '@noble/secp256k1' can be used
-import tinySecp256k1 from 'tiny-secp256k1'
-import secp256k1 from '@exodus/secp256k1'
-
-// TODO: migrate library
-// import { sign, schnorr, Point } from '@noble/secp256k1'
-
-/**
- * Wrapper around `secp256k1` in order to follow the bitcoinjs-lib `TinySecp256k1Interface`
- * Schnorr signatures are offered by @noble/secp256k1
- */
-export const ecc: TinySecp256k1Interface = {
-  // These methods have been addded in order to comply with the public interface
-  // In practice the async version will be used
-  sign: (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
-    secp256k1.ecdsaSign(h, d, { data: e }).signature,
-  verify: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean =>
-    secp256k1.ecdsaVerify(signature, h, Q),
-
-  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
-    secp256k1.ecdsaSign(h, d, { data: extraEntropy }).signature,
-
-  // TODO: waiting for the '@noble/secp256k1' lib
-  // signSchnorrAsync: async (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
-  //   schnorr.sign(h, d, e),
-  // verifySchnorrAsync: async (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean =>
-  //   schnorr.verify(signature, h, Q),
-
-  // The underlying library does not expose sync functions for Schnorr sign and verify.
-  // These function are explicitly defined here as `null` for documentation purposes.
-  signSchnorr: null,
-  verifySchnorr: null,
-
-  isPoint: (p: Uint8Array): boolean => {
-    try {
-      // temp solution secp256k1 does not actually verify the value range, only the data length
-      return tinySecp256k1.isPoint(Buffer.from(p))
-    } catch {
-      return false
-    }
-  },
-
-  isXOnlyPoint: (p: Uint8Array): boolean => {
-    try {
-      // temp solution secp256k1 does not actually verify the value range, only the data length
-      return tinySecp256k1.isPoint(Buffer.from(toPubKey(p)))
-    } catch (err) {
-      return false
-    }
-  },
-  xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array) => {
-    try {
-      const t = secp256k1.publicKeyTweakAdd(toPubKey(p), tweak)
-      return {
-        parity: t[0] === 0x02 ? 0 : 1,
-        xOnlyPubkey: t.slice(1, 33),
-      }
-    } catch (err) {
-      return null
-    }
-  },
-
-  privateAdd: (d: Uint8Array, tweak: Uint8Array): Uint8Array | null =>
-    secp256k1.privateKeyTweakAdd(d, tweak),
-
-  privateNegate: (d: Uint8Array): Uint8Array => secp256k1.privateKeyNegate(d),
-
-  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
-    secp256k1.publicKeyConvert(p, compressed),
-  isPrivate: (d: Uint8Array): boolean => secp256k1.privateKeyVerify(d),
-  pointFromScalar: (d: Uint8Array, compressed?: boolean): Uint8Array | null =>
-    secp256k1.publicKeyCreate(d, compressed),
-}
-
-const toPubKey = (xOnly: Uint8Array) => {
-  const p = new Uint8Array(33)
-  p.set([0x02])
-  p.set(xOnly, 1)
-  return p
-}
+export const eccFactory = (useDesktopEcc) =>
+  useDesktopEcc ? require('./desktop').desktopEcc : require('./mobile').mobileEcc

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

@@ -0,0 +1,48 @@
+import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
+import secp256k1 from '@exodus/secp256k1'
+// TODO: temp import until '@noble/secp256k1' can be used
+import tinySecp256k1 from 'tiny-secp256k1'
+import { common, toPubKey } from './common'
+
+/**
+ * Wrapper around `secp256k1` in order to follow the bitcoinjs-lib `TinySecp256k1Interface`
+ * Schnorr signatures are offered by @noble/secp256k1
+ */
+export const mobileEcc: TinySecp256k1Interface = {
+  ...common,
+
+  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
+    secp256k1.ecdsaSign(h, d, { data: extraEntropy }).signature,
+
+  // TODO: waiting for the '@noble/secp256k1' lib
+  // signSchnorrAsync: async (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
+  //   schnorr.sign(h, d, e),
+  // verifySchnorrAsync: async (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean =>
+  //   schnorr.verify(signature, h, Q),
+
+  // The underlying library does not expose sync functions for Schnorr sign and verify.
+  // These function are explicitly defined here as `null` for documentation purposes.
+  signSchnorr: null,
+  verifySchnorr: null,
+
+  isPoint: (p: Uint8Array): boolean => {
+    try {
+      // temp solution secp256k1 does not actually verify the value range, only the data length
+      return tinySecp256k1.isPoint(Buffer.from(p))
+    } catch {
+      return false
+    }
+  },
+
+  isXOnlyPoint: (p: Uint8Array): boolean => {
+    try {
+      // temp solution secp256k1 does not actually verify the value range, only the data length
+      return tinySecp256k1.isPoint(Buffer.from(toPubKey(p)))
+    } catch (err) {
+      return false
+    }
+  },
+
+  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
+    secp256k1.publicKeyConvert(p, compressed),
+}

package/src/bitcoinjs-lib/index.js

@@ -1,4 +1,2 @@
-import { ecc } from './ecc'
-import { scriptClassify } from './script-classify'
-
-export { ecc, scriptClassify }
+export * from './ecc'
+export { scriptClassify } from './script-classify'

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

@@ -1,5 +1,5 @@
 import { payments } from '@exodus/bitcoinjs-lib'
-import { ecc } from '../ecc'
+import assert from 'minimalistic-assert'
 
 function isPaymentFactory(payment: any): (script: Buffer, eccLib?: any) => boolean {
   return (script: Buffer, eccLib?: any): boolean => {
@@ -31,7 +31,8 @@ const types = {
   NONSTANDARD: 'nonstandard',
 }
 
-const clasifyOutput = (script: Buffer) => {
+const outputFactory = ({ ecc }) => (script: Buffer) => {
+  assert(ecc, 'ecc is required')
   if (isP2WPKH(script)) return types.P2WPKH
   if (isP2TR(script, ecc)) return types.P2TR
   if (isP2PKH(script)) return types.P2PKH
@@ -45,5 +46,5 @@ const clasifyOutput = (script: Buffer) => {
 
 export const scriptClassify = {
   types,
-  output: clasifyOutput,
+  outputFactory,
 }

package/src/btc-like-address.js

@@ -2,19 +2,19 @@ import bs58check from 'bs58check'
 import bech32 from 'bech32'
 import assert from 'minimalistic-assert'
 import { identity, pickBy } from 'lodash'
-import { ecc as defaultEcc } from './bitcoinjs-lib'
 
 export const createBtcLikeAddress = ({
   versions,
   coinInfo,
   bitcoinjsLib,
-  ecc = defaultEcc,
+  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

package/src/btc-like-keys.js

@@ -1,22 +1,22 @@
 import bs58check from 'bs58check'
-import secp256k1 from 'tiny-secp256k1'
 import wif from 'wif'
 import createHash from 'create-hash'
 import bech32 from 'bech32'
 import assert from 'minimalistic-assert'
 import { identity, pickBy } from 'lodash'
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
-import { ecc } from './bitcoinjs-lib'
 
 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 {
     encodePrivate: encodePrivateCustom,
     encodePublic: encodePublicCustom,
@@ -48,7 +48,7 @@ export const createBtcLikeKeys = ({
     encodePublicFromWIFCustom ||
     ((privateKeyWIF) => {
       const { privateKey, compressed } = wif.decode(privateKeyWIF, coinInfo.versions.private)
-      const publicKey = secp256k1.pointFromScalar(privateKey, compressed)
+      const publicKey = ecc.pointFromScalar(privateKey, compressed)
       return encodePublicPurpose44(publicKey)
     })
   const encodePublicBech32 =
@@ -74,7 +74,7 @@ export const createBtcLikeKeys = ({
           // NOTE: No password support here
           const { versions } = coinInfo
           const { privateKey, compressed } = wif.decode(privateKeyWIF, versions.private)
-          const publicKey = secp256k1.pointFromScalar(privateKey, compressed)
+          const publicKey = ecc.pointFromScalar(privateKey, compressed)
           return encodePublicBech32(publicKey)
         }
       : undefined

package/src/fee/can-bump-tx.js

@@ -50,21 +50,21 @@ const _canBumpTx = ({
     }
   }
 
-  const allUtxos = getUtxos({ accountState, asset })
+  const utxos = getUtxos({ accountState, asset })
 
-  const utxos = getSpendableUtxos({
+  const spendableUtxos = getSpendableUtxos({
     asset,
-    utxos: allUtxos,
+    utxos,
     feeData,
     txSet,
     taprootEnabled,
   })
-  if (!utxos) return { errorMessage: 'insufficient funds' }
+  if (!spendableUtxos) return { errorMessage: 'insufficient funds' }
 
   const { txId } = tx
   const replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
   const bumpTx = replaceableTxs.find((tx) => tx.txId === txId)
-  const changeUtxos = utxos.getTxIdUtxos(txId)
+  const changeUtxos = spendableUtxos.getTxIdUtxos(txId)
 
   // Can't bump a non-rbf tx with no change
   if (!bumpTx && changeUtxos.size === 0) return { errorMessage: 'no change' }
@@ -80,7 +80,7 @@ const _canBumpTx = ({
   if (bumpTx) {
     const { replaceTx } = selectUtxos({
       asset,
-      utxos,
+      spendableUtxos,
       replaceableTxs: [bumpTx],
       feeRate,
       receiveAddress: null,
@@ -91,7 +91,7 @@ const _canBumpTx = ({
 
   const { fee } = selectUtxos({
     asset,
-    utxos,
+    spendableUtxos,
     feeRate,
     receiveAddress: 'P2WPKH',
     getFeeEstimator,

package/src/fee/fee-estimator.js

@@ -53,17 +53,19 @@ 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 function getSize(
+export const getSizeFactory = ({ ecc }) => (
   asset: Object,
   inputs: Array | UtxoCollection,
   outputs: Array,
   { compressed = true } = {}
-) {
+) => {
+  assert(ecc, 'ecc is required')
   if (inputs instanceof UtxoCollection) {
     inputs = Array.from(inputs).map((utxo) => utxo.script || null)
   }
 
   // other bitcoin-like assets
+  const classifyOutput = scriptClassify.outputFactory({ ecc })
   const baseSize =
     4 + // n_version
     4 + // n_locktime
@@ -74,7 +76,7 @@ export function getSize(
       assert(isHex(script), 'script must be hex string')
 
       const scriptBuffer = Buffer.from(script, 'hex')
-      const scriptType = scriptClassify.output(scriptBuffer)
+      const scriptType = classifyOutput(scriptBuffer)
 
       const supportedTypes = supportedInputTypes[asset.name] || supportedInputTypes.default
       assert(
@@ -103,7 +105,7 @@ export function getSize(
         else if (asset.address.isP2TR && asset.address.isP2TR(output)) scriptType = P2TR
         else if (asset.address.isP2WSH && asset.address.isP2WSH(output)) scriptType = P2WSH
         else {
-          scriptType = scriptClassify.output(asset.address.toScriptPubKey(output))
+          scriptType = classifyOutput(asset.address.toScriptPubKey(output))
         }
       }
       assert(
@@ -121,7 +123,7 @@ export function getSize(
     // witnesses
     inputs.reduce((t, script) => {
       if (!script) return t + 1
-      const utxoScriptType = scriptClassify.output(Buffer.from(script, 'hex'))
+      const utxoScriptType = classifyOutput(Buffer.from(script, 'hex'))
       if ([P2SH, P2WPKH].includes(utxoScriptType)) {
         const pubKeyLength = 33
         const signatureLength = 73 // maximum possible length
@@ -158,4 +160,5 @@ export function getSize(
   return Math.ceil(weight / 4)
 }
 
-export default createDefaultFeeEstimator(getSize)
+const getFeeEstimatorFactory = ({ ecc }) => createDefaultFeeEstimator(getSizeFactory({ ecc }))
+export default getFeeEstimatorFactory

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

@@ -1,8 +1,7 @@
 import assert from 'minimalistic-assert'
-import { getAvailableBalance, getFee } from './utxo-selector'
+import { getUtxosData } from './utxo-selector'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
 import { getSpendableUtxos, getUtxos } from '../utxos-utils'
-import { getExtraFee } from './fee-utils'
 import { canBumpTx } from './can-bump-tx'
 
 export class GetFeeResolver {
@@ -16,13 +15,32 @@ export class GetFeeResolver {
   }
 
   getFee = ({ asset, accountState, txSet, feeData, amount, customFee, isSendAll }) => {
-    assert(asset, 'asset must be provided')
-    assert(feeData, 'feeData must be provided')
-    assert(accountState, 'accountState must be provided')
-    assert(txSet, 'txSet must be provided')
+    const { resolvedFee, extraFee } = this.#getUtxosData({
+      asset,
+      accountState,
+      txSet,
+      feeData,
+      amount,
+      customFee,
+      isSendAll,
+    })
+    return { fee: resolvedFee, extraFee }
+  }
 
-    const utxos = getUtxos({ accountState, asset })
+  getAvailableBalance = ({ asset, accountState, txSet, feeData, amount, customFee, isSendAll }) => {
+    return this.#getUtxosData({
+      asset,
+      accountState,
+      txSet,
+      feeData,
+      customFee,
+      isSendAll,
+      amount,
+    }).availableBalance
+  }
 
+  getSpendableBalance = ({ asset, accountState, txSet, feeData }) => {
+    const utxos = getUtxos({ accountState, asset })
     const spendableUtxos = getSpendableUtxos({
       asset,
       utxos,
@@ -30,36 +48,17 @@ export class GetFeeResolver {
       txSet,
       taprootEnabled: this.#taprootEnabled,
     })
-    const replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
-
-    const receiveAddress = ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name)
-      ? 'P2WSH'
-      : 'P2PKH'
-
-    const feePerKB = customFee || feeData.feePerKB
-    const fee = getFee({
-      asset,
-      utxos: spendableUtxos,
-      replaceableTxs,
-      amount,
-      feeRate: feePerKB,
-      receiveAddress,
-      isSendAll,
-      getFeeEstimator: this.#getFeeEstimator,
-    })
-    const extraFee = asset.currency.baseUnit(
-      getExtraFee({ asset, inputs: spendableUtxos, feePerKB })
-    )
-    return { fee, extraFee }
+    return spendableUtxos.value
   }
 
-  getAvailableBalance = ({ asset, accountState, txSet, feeData, customFee }) => {
+  #getUtxosData = ({ asset, accountState, txSet, feeData, amount, customFee, isSendAll }) => {
     assert(asset, 'asset must be provided')
     assert(feeData, 'feeData must be provided')
     assert(accountState, 'accountState must be provided')
     assert(txSet, 'txSet must be provided')
 
     const utxos = getUtxos({ accountState, asset })
+
     const spendableUtxos = getSpendableUtxos({
       asset,
       utxos,
@@ -72,12 +71,16 @@ export class GetFeeResolver {
     const receiveAddress = ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name)
       ? 'P2WSH'
       : 'P2PKH'
-    return getAvailableBalance({
+
+    const feePerKB = customFee || feeData.feePerKB
+    return getUtxosData({
       asset,
-      utxos: spendableUtxos,
+      spendableUtxos,
       replaceableTxs,
-      feeRate: customFee || feeData.feePerKB,
+      amount,
+      feeRate: feePerKB,
       receiveAddress,
+      isSendAll: isSendAll,
       getFeeEstimator: this.#getFeeEstimator,
     })
   }

package/src/fee/index.js

@@ -1,2 +1,2 @@
 export * from './get-fee-resolver'
-export { default as getFeeEstimator } from './fee-estimator'
+export { default as getFeeEstimatorFactory } from './fee-estimator'

package/src/fee/utxo-selector.js

@@ -1,12 +1,13 @@
 import { UtxoCollection } from '@exodus/models'
 import NumberUnit from '@exodus/currency'
+import assert from 'minimalistic-assert'
+import { getExtraFee } from './fee-utils'
 
 const MIN_RELAY_FEE = 1000
-const AVG_TX_SIZE = 192
 
 export const selectUtxos = ({
   asset,
-  utxos: spendableUtxos,
+  spendableUtxos,
   replaceableTxs,
   amount,
   feeRate,
@@ -16,6 +17,14 @@ export const selectUtxos = ({
   disableReplacement = false,
   mustSpendUtxos,
 }) => {
+  assert(asset, 'asset is required')
+  assert(spendableUtxos, 'spendableUtxos is required')
+  assert(getFeeEstimator, 'getFeeEstimator is required')
+
+  const changeAddressType = ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(asset.name)
+    ? 'P2WPKH'
+    : 'P2PKH'
+
   const feeEstimator = getFeeEstimator(asset, { feePerKB: feeRate })
   const { currency } = asset
   if (!amount) amount = currency.ZERO
@@ -49,7 +58,7 @@ export const selectUtxos = ({
         ? tx.data.sent.map(({ address }) => address)
         : [
             ...tx.data.sent.map(({ address }) => address),
-            tx.data.changeAddress ? tx.data.changeAddress.address : 'P2WPKH',
+            tx.data.changeAddress?.address || changeAddressType,
           ]
       if (receiveAddress) {
         outputs.push(receiveAddress)
@@ -86,9 +95,7 @@ export const selectUtxos = ({
         }
       }
       if (isSendAll || replaceTxAmount.add(additionalUtxos.value).gte(amount.add(fee))) {
-        const chainOutputs = isSendAll
-          ? [receiveAddress]
-          : [receiveAddress, asset.name === 'bitcoin' ? 'P2WPKH' : 'P2PKH']
+        const chainOutputs = isSendAll ? [receiveAddress] : [receiveAddress, changeAddressType]
         const chainFee = feeEstimator({
           inputs: changeUtxos.union(additionalUtxos),
           outputs: chainOutputs,
@@ -98,7 +105,7 @@ export const selectUtxos = ({
         if ((!amount.isZero || tx.data.changeAddress) && fee.sub(tx.feeAmount).gte(chainFee)) {
           continue
         }
-        return { utxos: additionalUtxos, fee, replaceTx: tx }
+        return { selectedUtxos: additionalUtxos, fee, replaceTx: tx }
       }
     }
   }
@@ -116,17 +123,14 @@ export const selectUtxos = ({
   }
 
   const utxosArray = spendableUtxos.union(ourRbfUtxos).toPriorityOrderedArray()
-  if (utxosArray.length === 0) return {}
-
-  const outputs =
-    isSendAll || amount.isZero
-      ? [receiveAddress]
-      : [receiveAddress, asset.name === 'bitcoin' ? 'P2WPKH' : 'P2PKH']
 
   if (isSendAll) {
     const selectedUtxos = UtxoCollection.fromArray(utxosArray, { currency })
-    const fee = feeEstimator({ inputs: selectedUtxos, outputs })
-    return { utxos: selectedUtxos, fee }
+    const fee = feeEstimator({ inputs: selectedUtxos, outputs: [receiveAddress] })
+    if (selectedUtxos.value.lt(amount.add(fee))) {
+      return { fee }
+    }
+    return { selectedUtxos, fee }
   }
 
   // quickly add utxos to get to amount before starting to figure out fees, the minimum place to start is as much as the amount
@@ -149,6 +153,8 @@ export const selectUtxos = ({
   let selectedUtxos = UtxoCollection.fromArray(selectedUtxosArray, { currency })
 
   // start figuring out fees
+  const outputs = amount.isZero ? [changeAddressType] : [receiveAddress, changeAddressType]
+
   let fee = feeEstimator({ inputs: selectedUtxos, outputs })
 
   while (selectedUtxos.value.lt(amount.add(fee))) {
@@ -156,9 +162,6 @@ export const selectUtxos = ({
     if (remainingUtxosArray.length === 0) {
       // Try fee with no change
       fee = feeEstimator({ inputs: selectedUtxos, outputs: [receiveAddress] })
-      if (selectedUtxos.value.lt(amount.add(fee))) {
-        return {}
-      }
       break
     }
 
@@ -166,43 +169,15 @@ export const selectUtxos = ({
     selectedUtxos = selectedUtxos.addUtxo(remainingUtxosArray.shift())
     fee = feeEstimator({ inputs: selectedUtxos, outputs })
   }
-
-  return { utxos: selectedUtxos, fee }
-}
-
-export const getAvailableBalance = ({
-  asset,
-  utxos,
-  replaceableTxs,
-  feeRate,
-  receiveAddress,
-  getFeeEstimator,
-  disableReplacement,
-}) => {
-  const { utxos: selectedUtxos, replaceTx, fee } = selectUtxos({
-    asset,
-    utxos,
-    replaceableTxs,
-    feeRate,
-    receiveAddress,
-    isSendAll: true,
-    getFeeEstimator,
-    disableReplacement,
-  })
-  if (!selectedUtxos) return asset.currency.ZERO
-  if (replaceTx) {
-    return utxos
-      .getTxIdUtxos(replaceTx.txId)
-      .union(selectedUtxos)
-      .value.sub(fee)
-      .add(replaceTx.feeAmount)
+  if (selectedUtxos.value.lt(amount.add(fee))) {
+    return { fee }
   }
-  return selectedUtxos.value.sub(fee)
+  return { selectedUtxos, fee }
 }
 
-export const getFee = ({
+export const getUtxosData = ({
   asset,
-  utxos,
+  spendableUtxos,
   replaceableTxs,
   amount,
   feeRate,
@@ -210,10 +185,11 @@ export const getFee = ({
   isSendAll,
   getFeeEstimator,
   disableReplacement,
+  mustSpendUtxos,
 }) => {
-  const { replaceTx, fee } = selectUtxos({
+  const { selectedUtxos, replaceTx, fee } = selectUtxos({
     asset,
-    utxos,
+    spendableUtxos,
     replaceableTxs,
     amount,
     feeRate,
@@ -221,8 +197,25 @@ export const getFee = ({
     isSendAll,
     getFeeEstimator,
     disableReplacement,
+    mustSpendUtxos,
   })
-  if (!fee) return asset.currency.baseUnit(Math.ceil((feeRate.toBaseNumber() * AVG_TX_SIZE) / 1000))
-  if (!replaceTx) return fee
-  return fee.sub(replaceTx.feeAmount)
+
+  const resolvedFee = replaceTx ? fee.sub(replaceTx.feeAmount) : fee
+
+  const spendableBalance = spendableUtxos.value
+
+  const extraFee = selectedUtxos
+    ? asset.currency.baseUnit(getExtraFee({ asset, inputs: selectedUtxos, feePerKB: feeRate }))
+    : asset.currency.ZERO
+
+  const availableBalance = spendableBalance.sub(resolvedFee).clampLowerZero()
+  return {
+    spendableBalance,
+    availableBalance,
+    selectedUtxos,
+    fee,
+    resolvedFee,
+    replaceTx,
+    extraFee,
+  }
 }

package/src/index.js

@@ -7,9 +7,11 @@ export { default as InsightAPIClient } from './insight-api-client'
 export { default as InsightWSClient } from './insight-api-client/ws'
 export { default as bip44Constants } from './constants/bip44'
 export { default as createGetKeyIdentifier } from './key-identifier'
-
+export * from './tx-send'
+export * from './tx-sign'
 export * from './fee'
 export * from './utxos-utils'
 export * from './tx-log'
 export * from './unconfirmed-ancestor-data'
+export * from './parse-unsigned-tx'
 export * from './insight-api-client/util'

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

@@ -7,6 +7,7 @@ import { updateUnconfirmedAncestorData } from '../unconfirmed-ancestor-data'
 import { BitcoinMonitorScanner } from './bitcoin-monitor-scanner'
 import { normalizeInsightConfig, toWSUrl } from '../insight-api-client/util'
 import ms from 'ms'
+import delay from 'delay'
 
 // NOTE: this is a frankenstein mashup of Exodus desktop
 // assets-refresh/insight action + Neo monitor
@@ -58,6 +59,9 @@ export class Monitor extends BaseMonitor {
       })
 
     this.addHook('after-tick-multiple-wallet-accounts', () => this.#subscribeToNewAddresses())
+    this.addHook('after-stop', async () =>
+      Promise.all(Object.keys(this.#runningByWalletAccount).map(this.#waitForWalletToFinish))
+    )
   }
 
   setServer(assetConfig = {}) {
@@ -180,10 +184,22 @@ export class Monitor extends BaseMonitor {
 
   tick = async ({ walletAccount, refresh }) => {
     assert(walletAccount, 'walletAccount is expected')
-    if (this.#runningByWalletAccount[walletAccount]) return
-    this.#runningByWalletAccount[walletAccount] = true
+    // 1) if no tick is running, any tick runs
+    // 2) if a regular tick is running, a refresh tick waits and runs
+    // 3) if a regular tick is running, a regular tick does not wait and does not run
+    // 4) if a refresh tick is running, a refresh tick does not wait and does not run
+    // 5) if a refresh tick is running, a regular tick does not wait and does not run
+    if (refresh && this.#runningByWalletAccount[walletAccount]?.refresh !== refresh) {
+      await this.#waitForWalletToFinish(walletAccount)
+    }
+    if (this.#runningByWalletAccount[walletAccount]) {
+      this.logger.debug(`Skipping ${walletAccount} tick as previous tick is still running`)
+      return
+    }
+    const promise = this.#syncWalletAccount({ walletAccount, refresh })
+    this.#runningByWalletAccount[walletAccount] = { refresh, promise }
     try {
-      await this.#syncWalletAccount({ walletAccount, refresh })
+      await promise
     } finally {
       delete this.#runningByWalletAccount[walletAccount]
     }
@@ -242,6 +258,20 @@ export class Monitor extends BaseMonitor {
   #logWsStatus = (message, ...args) => {
     // console.debug('btc-like monitor', this.asset.name, message, ...args)
   }
+
+  #waitForWalletToFinish = async (walletAccount) => {
+    const tickState = this.#runningByWalletAccount[walletAccount]
+    if (!tickState) return
+
+    const finished = await Promise.race([
+      tickState.promise.then(() => true),
+      delay(ms('10s')).then(() => false),
+    ])
+
+    if (!finished) {
+      this.logger.warn(`Tick for ${walletAccount} did not finish on time`)
+    }
+  }
 }
 
 export const createBitcoinMonitor = (args) => new Monitor(args)

package/src/tx-send/index.js

@@ -1,5 +1,6 @@
 import assert from 'minimalistic-assert'
-import lodash from 'lodash'
+// Using this notation so it can be mocked by jest
+import shuffle from 'lodash/shuffle'
 
 import { UtxoCollection, Address } from '@exodus/models'
 import { retry } from '@exodus/simple-retry'
@@ -12,11 +13,13 @@ import {
   createInputs as dogecoinCreateInputs,
   createOutput as dogecoinCreateOutput,
 } from './dogecoin'
-import { findUnconfirmedSentTxs } from '../tx-utils'
+import { findUnconfirmedSentRbfTxs } from '../tx-utils'
 import { getSpendableUtxos, getUtxos } from '../utxos-utils'
 
 const ASSETS_SUPPORTED_BIP_174 = [
   'bitcoin',
+  'bitcoinregtest',
+  'bitcointestnet',
   'litecoin',
   'dash',
   'ravencoin',
@@ -86,16 +89,12 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
   const {
     multipleAddressesEnabled,
     feePerKB,
-    hdkey44,
-    hdkey84,
-    hdkey86,
     customFee,
     isSendAll,
     isExchange,
     isBip70,
     bumpTxId,
     isRbfAllowed = true,
-    preBroadcastHook,
   } = options
 
   assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${asset.name}`)
@@ -121,7 +120,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
   const insightClient = asset.baseAsset.insightClient
   const currency = asset.currency
   const feeData = await assetClientInterface.getFeeConfig({ assetName })
-  const utxos = getSpendableUtxos({
+  const spendableUtxos = getSpendableUtxos({
     asset,
     utxos: getUtxos({ accountState, asset }),
     feeData,
@@ -129,7 +128,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     taprootEnabled,
   })
 
-  let replaceableTxs = findUnconfirmedSentTxs(txSet)
+  let replaceableTxs = findUnconfirmedSentRbfTxs(txSet)
 
   if (assetName === 'bcash') {
     address = asset.address.toLegacyAddress(address)
@@ -146,7 +145,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
   if (bumpTxId) {
     const bumpTx = replaceableTxs.find(({ txId }) => txId === bumpTxId)
     if (!bumpTx) {
-      utxosToBump = utxos.getTxIdUtxos(bumpTxId)
+      utxosToBump = spendableUtxos.getTxIdUtxos(bumpTxId)
       if (utxosToBump.size === 0) {
         throw new Error(`Cannot bump transaction ${bumpTxId}`)
       }
@@ -160,9 +159,9 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
   let receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
   const feeRate = feeData.feePerKB
 
-  let { utxos: selected, fee, replaceTx } = selectUtxos({
+  let { selectedUtxos, fee, replaceTx } = selectUtxos({
     asset,
-    utxos,
+    spendableUtxos,
     replaceableTxs,
     amount: sendAmount,
     feeRate: customFee || feeRate,
@@ -172,14 +171,14 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     mustSpendUtxos: utxosToBump,
   })
 
-  if (!selected && !replaceTx) throw new Error('Not enough funds.')
+  if (!selectedUtxos && !replaceTx) throw new Error('Not enough funds.')
 
   // When bumping a tx, we can either replace the tx with RBF or spend its selected change.
   // If there is no selected UTXO or the tx to replace is not the tx we want to bump,
   // then something is wrong because we can't actually bump the tx.
   // This shouldn't happen but might due to either the tx confirming before accelerate was
   // pressed, or if the change was already spent from another wallet.
-  if (bumpTxId && (!selected || (replaceTx && replaceTx.txId !== bumpTxId))) {
+  if (bumpTxId && (!selectedUtxos || (replaceTx && replaceTx.txId !== bumpTxId))) {
     throw new Error(`Unable to bump ${bumpTxId}`)
   }
 
@@ -189,13 +188,13 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     replaceTx.data.sent = replaceTx.data.sent.map((to) => {
       return { ...to, amount: parseCurrency(to.amount, asset.currency) }
     })
-    selected = selected.union(
+    selectedUtxos = selectedUtxos.union(
       UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
     )
   }
 
   // transform UTXO object to raw
-  const inputs = lodash.shuffle(createInputs(assetName, selected.toArray(), rbfEnabled))
+  const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), rbfEnabled))
 
   let outputs
   if (replaceTx) {
@@ -213,7 +212,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     ? replaceTx.data.sent.reduce((total, { amount }) => total.add(amount), sendAmount)
     : sendAmount
 
-  const change = selected.value.sub(totalAmount).sub(fee)
+  const change = selectedUtxos.value.sub(totalAmount).sub(fee)
   const dust = getDustValue(asset)
   let ourAddress = replaceTx?.data?.changeAddress || changeAddress
   if (['bcash'].includes(assetName)) {
@@ -233,7 +232,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     fee = fee.add(change)
   }
 
-  outputs = replaceTx ? outputs : lodash.shuffle(outputs)
+  outputs = replaceTx ? outputs : shuffle(outputs)
   const blockHeight = ['zcash', 'bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)
     ? await insightClient.fetchBlockHeight()
     : 0
@@ -245,24 +244,19 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
       outputs,
     },
     txMeta: {
-      addressPathsMap: selected.getAddressPathsMap(),
+      addressPathsMap: selectedUtxos.getAddressPathsMap(),
       blockHeight,
     },
   }
 
-  const nonWitnessTxs = await getNonWitnessTxs(asset, selected, insightClient)
+  const nonWitnessTxs = await getNonWitnessTxs(asset, selectedUtxos, insightClient)
   Object.assign(unsignedTx.txMeta, { rawTxs: nonWitnessTxs })
-  const { rawTx, txId, tx } = await asset.baseAsset.api.signUnsignedTx(unsignedTx, undefined, {
-    asset,
-    hdkey44,
-    hdkey84,
-    hdkey86,
+  const { rawTx, txId, tx } = await assetClientInterface.signTransaction({
+    assetName,
+    unsignedTx,
+    walletAccount,
   })
 
-  if (preBroadcastHook) {
-    await preBroadcastHook({ txId, unsignedTx })
-  }
-
   const broadcastTxWithRetry = retry(
     async (rawTx) => {
       try {
@@ -293,7 +287,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
       err.txInfo = JSON.stringify({
         amount: sendAmount.toDefaultString({ unit: true }),
         fee: ((fee && fee.toDefaultString({ unit: true })) || 0).toString(), // todo why does 0 not have a unit? Is default unit ok here?
-        allUtxos: utxos.toJSON(),
+        allUtxos: spendableUtxos.toJSON(),
       })
       throw err
     } else {
@@ -312,7 +306,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
     }
   }
 
-  let remainingUtxos = utxos.difference(selected)
+  let remainingUtxos = spendableUtxos.difference(selectedUtxos)
   if (changeUtxoIndex !== -1) {
     const address = Address.create(ourAddress.address, ourAddress.meta)
     const changeUtxo = {
@@ -374,7 +368,7 @@ export const createAndBroadcastTXFactory = ({ getFeeEstimator, taprootEnabled })
           changeAddress: changeOutput ? ourAddress : undefined,
           blockHeight,
           blocksSeen: 0,
-          inputs: selected.toJSON(),
+          inputs: selectedUtxos.toJSON(),
           replacedTxId: replaceTx ? replaceTx.txId : undefined,
         },
       },

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

@@ -3,7 +3,7 @@ import lodash from 'lodash'
 import ECPairFactory from 'ecpair'
 import { Psbt } from '@exodus/bitcoinjs-lib'
 
-import { ecc } from '../bitcoinjs-lib'
+import { toAsyncSigner, tweakSigner } from './taproot'
 
 let ECPair
 
@@ -12,67 +12,88 @@ const _MAXIMUM_FEE_RATES = {
   ravencoin: 1000000,
 }
 
-export function signTx({ asset, unsignedTx, hdkey44, hdkey84, hdkey86 }): Object {
-  assert(asset, 'asset is required')
-  assert(unsignedTx, 'unsignedTx is required')
-  const assetName = asset.name
-  const { privateKeysAddressMap, addressPathsMap, rawTxs } = unsignedTx.txMeta
-  const { inputs, outputs } = unsignedTx.txData
-  const networkInfo = { ...asset.coinInfo.toBitcoinJS(), messagePrefix: '' }
+export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, network, ecc }) => {
+  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 }): Object => {
+    assert(unsignedTx, 'unsignedTx is required')
+    const { privateKeysAddressMap, addressPathsMap, rawTxs } = unsignedTx.txMeta
+    const { inputs, outputs } = unsignedTx.txData
+    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]
+    // 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 })
+    const psbt = new Psbt({ maximumFeeRate, eccLib: ecc, network: networkInfo })
 
-  if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
+    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
 
-  ECPair = ECPair || ECPairFactory(ecc)
+    ECPair = ECPair || ECPairFactory(ecc)
 
-  const getKey = lodash.memoize((address) => {
-    // TODO: Consider using privateKeysAddressMap for other assets
-    if (privateKeysAddressMap) return ECPair.fromWIF(privateKeysAddressMap[address], networkInfo)
-    const path = addressPathsMap[address]
-    const isSegwitAddress = address.startsWith(asset.address.versions.segwit)
-    const isTaprootAddress = address.startsWith(asset.address.versions.taproot)
-    const _hdkey = isSegwitAddress ? hdkey84 : isTaprootAddress ? hdkey86 : hdkey44
-    const privateEncoded = asset.keys.encodePrivate(_hdkey.derive(path).privateKey)
-    return ECPair.fromWIF(privateEncoded, networkInfo)
-  })
+    const getKeyAndPurpose = lodash.memoize((address) => {
+      // TODO: Consider using privateKeysAddressMap for other assets
+      if (privateKeysAddressMap) return ECPair.fromWIF(privateKeysAddressMap[address], networkInfo)
+      const path = addressPathsMap[address]
+      const purpose = resolvePurpose(address)
+      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)
+      return { key: ECPair.fromWIF(privateEncoded, networkInfo), purpose }
+    })
 
-  // Fill tx
-  for (const { txId, vout, address, value, script, sequence } of inputs) {
-    const isSegwitAddress = address.startsWith(asset.address.versions.segwit)
-    const isTaprootAddress = address.startsWith(asset.address.versions.taproot)
-    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 {
-      // non-witness outptus require the full transaction
-      const rawTx = (rawTxs || []).find((t) => t.txId === txId)
-      assert(!!rawTx, 'Non-witness outputs require the full previous transaction.')
-      txIn.nonWitnessUtxo = Buffer.from(rawTx.rawData, 'hex')
+    // Fill tx
+    for (const { txId, vout, address, value, script, sequence } of inputs) {
+      const { purpose } = 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') }
+      } else {
+        // non-witness outptus require the full transaction
+        const rawTx = (rawTxs || []).find((t) => t.txId === txId)
+        assert(!!rawTx, 'Non-witness outputs require the full previous transaction.')
+        txIn.nonWitnessUtxo = Buffer.from(rawTx.rawData, 'hex')
+      }
+      psbt.addInput(txIn)
     }
-    psbt.addInput(txIn)
-  }
 
-  for (const [address, amount] of outputs) {
-    psbt.addOutput({ value: amount, address })
-  }
+    for (const [address, amount] of outputs) {
+      psbt.addOutput({ value: amount, address })
+    }
 
-  // Sign tx
-  inputs.forEach(({ address }, index) => {
-    const key = getKey(address)
-    psbt.signInput(index, key)
-  })
+    // 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]
+      const { key, purpose } = getKeyAndPurpose(address)
+      if (ecc.signSchnorrAsync) {
+        // desktop / BE 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)
+      }
+    }
 
-  // Serialize tx
-  psbt.finalizeAllInputs()
-  const tx = psbt.extractTransaction()
-  const rawTx = tx.toBuffer()
-  const txId = tx.getId()
+    // Serialize tx
+    psbt.finalizeAllInputs()
+    const tx = psbt.extractTransaction()
+    const rawTx = tx.toBuffer()
+    const txId = tx.getId()
 
-  return { rawTx, txId, tx }
+    return { rawTx, txId, tx }
+  }
 }

package/src/tx-sign/index.js

@@ -1 +1 @@
-export { signTx } from './default-create-tx'
+export { signTxFactory } from './default-create-tx'

package/src/tx-sign/taproot.js

@@ -0,0 +1,49 @@
+import { crypto } from '@exodus/bitcoinjs-lib'
+import assert from 'minimalistic-assert'
+
+export function tweakSigner({ signer, ECPair, ecc, 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!')
+  }
+  if (signer.publicKey[0] === 3) {
+    privateKey = ecc.privateNegate(privateKey)
+  }
+
+  const tweakedPrivateKey = ecc.privateAdd(
+    privateKey,
+    tapTweakHash(signer.publicKey.slice(1, 33), tweakHash)
+  )
+  if (!tweakedPrivateKey) {
+    throw new Error('Invalid tweaked private key!')
+  }
+
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network,
+  })
+}
+
+function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
+  return crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]))
+}
+
+/**
+ * Take a sync signer and make it async.
+ */
+export function toAsyncSigner({ keyPair, ecc }) {
+  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)
+  }
+
+  keyPair.signSchnorr = async (h) => {
+    const sig = await ecc.signSchnorrAsync(h, keyPair.privateKey)
+    return Buffer.from(sig)
+  }
+  return keyPair
+}

package/src/utxos-utils.js

@@ -2,6 +2,7 @@
 import { UtxoCollection } from '@exodus/models'
 import { findLargeUnconfirmedTxs } from './tx-utils'
 import assert from 'minimalistic-assert'
+import { mapValues } from '@exodus/basic-utils'
 
 export function getUtxos({ accountState, asset }) {
   return (
@@ -12,9 +13,23 @@ export function getUtxos({ accountState, asset }) {
   )
 }
 
-export function getBalances({ asset, accountState }) {
-  const balance = getUtxos({ asset, accountState }).value
-  return balance.isZero ? null : { balance }
+export const getBalancesFactory = ({ taprootEnabled, feeData }) => {
+  assert(feeData, 'feeData is required')
+  return ({ asset, accountState, txLog }) => {
+    assert(asset, 'asset is required')
+    assert(accountState, 'accountState is required')
+    assert(txLog, 'txLog is required')
+    const utxos = getUtxos({ asset, accountState })
+    const balance = utxos.value
+    const spendableBalance = getSpendableUtxos({
+      asset,
+      utxos,
+      txSet: txLog,
+      feeData,
+      taprootEnabled,
+    }).value
+    return mapValues({ balance, spendableBalance }, (balance) => (balance.isZero ? null : balance))
+  }
 }
 
 const isTaprootUtxo = (asset, utxo) =>