@exodus/bitcoin-api 2.4.1 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -22,13 +22,13 @@
     "@exodus/basic-utils": "^2.0.1",
     "@exodus/bip-schnorr": "0.6.6-fork-1",
     "@exodus/bip44-constants": "^195.0.0",
-    "@exodus/bitcoinjs-lib": "6.0.2-beta.5",
     "@exodus/models": "^8.10.4",
     "@exodus/secp256k1": "4.0.2-exodus.0",
     "@exodus/simple-retry": "0.0.6",
     "@exodus/timer": "^1.0.0",
     "@noble/secp256k1": "~1.5.3",
     "bech32": "^1.1.3",
+    "bitcoinjs-lib": "^6.1.5",
     "coininfo": "5.1.0",
     "delay": "4.0.1",
     "ecpair": "2.0.1",
@@ -39,6 +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": "d7b87308c1645a96ba4451f0b40b08ae3c1c29e5"
 }

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

@@ -1,4 +1,5 @@
 import secp256k1 from '@exodus/secp256k1'
+import { toXOnly } from '../ecc-utils'
 
 /**
  * Common ecc functions between mobile and desktop. Once mobile accepts @noble/secp256k1, we can unify both
@@ -24,7 +25,7 @@ export const common = {
       const t = secp256k1.publicKeyTweakAdd(toPubKey(p), tweak)
       return {
         parity: t[0] === 0x02 ? 0 : 1,
-        xOnlyPubkey: t.slice(1, 33),
+        xOnlyPubkey: toXOnly(t),
       }
     } catch (err) {
       return null

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

@@ -1,4 +1,4 @@
-import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
+import { TinySecp256k1Interface, initEccLib } from 'bitcoinjs-lib'
 import { Point, schnorr, sign } from '@noble/secp256k1'
 import { common, toPubKey } from './common'
 
@@ -48,3 +48,5 @@ export const desktopEcc: TinySecp256k1Interface = {
   pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
     Point.fromHex(p).toRawBytes(compressed),
 }
+
+initEccLib(desktopEcc)

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

@@ -1,4 +1,4 @@
-import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
+import { TinySecp256k1Interface, initEccLib } from 'bitcoinjs-lib'
 import secp256k1 from '@exodus/secp256k1'
 // TODO: temp import until '@noble/secp256k1' can be used
 import { isPoint } from 'tiny-secp256k1'
@@ -56,3 +56,5 @@ export const mobileEcc: TinySecp256k1Interface = {
   pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
     secp256k1.publicKeyConvert(p, compressed),
 }
+
+initEccLib(mobileEcc)

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 '@exodus/bitcoinjs-lib'
-import assert from 'minimalistic-assert'
+import { payments } from 'bitcoinjs-lib'
 
 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

@@ -2,20 +2,18 @@ import bs58check from 'bs58check'
 import * as bech32 from 'bech32'
 import assert from 'minimalistic-assert'
 import { identity, pickBy } from 'lodash'
-import * as bitcoinjsOriginal from '@exodus/bitcoinjs-lib'
+import * as bitcoinjsOriginal from 'bitcoinjs-lib'
 
 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

@@ -3,9 +3,11 @@ import wif from 'wif'
 import * as bech32 from 'bech32'
 import assert from 'minimalistic-assert'
 import { identity, pickBy } from 'lodash'
-import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
+import * as defaultBitcoinjsLib from 'bitcoinjs-lib'
 import secp256k1 from 'secp256k1'
 import { hash160 } from './hash-utils'
+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)])
@@ -15,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,
@@ -90,10 +91,7 @@ export const createBtcLikeKeys = ({
     (useBip86
       ? (publicKey: Buffer): string => {
           const network = coinInfo.toBitcoinJS()
-          return bitcoinjsLib.payments.p2tr(
-            { internalPubkey: publicKey.slice(1, 33), 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,5 @@ 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'

package/src/parse-unsigned-tx.js

@@ -2,7 +2,7 @@ import assert from 'minimalistic-assert'
 import BIPPath from 'bip32-path'
 import BN from 'bn.js'
 import lodash from 'lodash'
-import { Transaction as BitcoinTransactionClass } from '@exodus/bitcoinjs-lib'
+import { Transaction as BitcoinTransactionClass } from 'bitcoinjs-lib'
 
 export const parseUnsignedTxFactory = ({ Transaction = BitcoinTransactionClass } = {}) => async ({
   asset,

package/src/tx-send/index.js

@@ -16,7 +16,7 @@ import {
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
 import { getOrdinalsUtxos, getUsableUtxos, getUtxos } from '../utxos-utils'
 
-import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
+import * as defaultBitcoinjsLib from 'bitcoinjs-lib'
 
 const ASSETS_SUPPORTED_BIP_174 = [
   'bitcoin',
@@ -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

@@ -1,12 +1,14 @@
 import assert from 'minimalistic-assert'
 import lodash from 'lodash'
 import ECPairFactory from 'ecpair'
-import { payments, Psbt, Transaction } from '@exodus/bitcoinjs-lib'
+import { payments, Psbt, Transaction } from 'bitcoinjs-lib'
 import { getOwnProperty } from '@exodus/basic-utils'
 
 import secp256k1 from 'secp256k1'
 
+import { toXOnly } from '../bitcoinjs-lib/ecc-utils'
 import { toAsyncSigner, tweakSigner } from './taproot'
+import { 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)
@@ -63,7 +108,8 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
         const privateKey = getOwnProperty(privateKeysAddressMap, address, 'string')
         assert(privateKey, `there is no private key for address ${address}`)
         const key = ECPair.fromWIF(privateKey, networkInfo)
-        return { key, purpose }
+        const publicKey = secp256k1.publicKeyCreate(key.privateKey, true)
+        return { key, purpose, publicKey }
       }
       const path = addressPathsMap[address]
       assert(hdkeys, 'hdkeys must be provided')
@@ -72,51 +118,39 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
       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 }
+      const key = ECPair.fromWIF(privateEncoded, networkInfo)
+      const publicKey = derivedhdkey.publicKey
+      return { key, publicKey, purpose }
     })
 
-    // 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 {
-        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)
-    }
+    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
 
-    for (const [address, amount] of outputs) {
-      psbt.addOutput({ value: amount, address })
-    }
+    if (!['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) psbt.setVersion(1)
+
+    const inputsToSign = isPsbtBufferPassed ? unsignedTx.txMeta.inputsToSign : inputs
 
     // The Taproot SIGHASH flag includes all previous outputs,
     // so signing is only done AFTER all inputs have been updated
-    for (let index = 0; index < inputs.length; index++) {
-      const { address } = inputs[index]
-      const { key, purpose } = getKeyAndPurpose(address)
+    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) {
         // If spending from a P2SH address, we assume the address is P2SH wrapping
         // P2WPKH. Exodus doesn't use P2SH addresses so we should only ever be
         // signing a P2SH input if we are importing a private key
         // BIP143: As a default policy, only compressed public keys are accepted in P2WPKH and P2WSH
-        const publicKey = secp256k1.publicKeyCreate(key.privateKey, true)
         const p2wpkh = payments.p2wpkh({ pubkey: publicKey })
         const p2sh = payments.p2sh({ redeem: p2wpkh })
         psbt.updateInput(index, {
@@ -124,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 '@exodus/bitcoinjs-lib'
+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!')
@@ -16,7 +19,7 @@ export function tweakSigner({ signer, ECPair, ecc, tweakHash, network }) {
 
   const tweakedPrivateKey = ecc.privateAdd(
     privateKey,
-    tapTweakHash(signer.publicKey.slice(1, 33), tweakHash)
+    tapTweakHash(toXOnly(signer.publicKey), tweakHash)
   )
   if (!tweakedPrivateKey) {
     throw new Error('Invalid tweaked private key!')
@@ -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)