@exodus/bitcoin-api 2.6.8-hiro.2 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.6.8-hiro.2",
+  "version": "2.7.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -42,5 +42,6 @@
     "@scure/base": "^1.1.3",
     "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
-  }
+  },
+  "gitHead": "5c306496cb4086ff823640e8eadb0d9750ac3683"
 }

package/src/tx-sign/common.js

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

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

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

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

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

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

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

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

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

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

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

package/src/tx-sign/index.js

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

package/src/tx-sign/taproot.js

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