@exodus/bitcoin-api 2.20.0 → 2.21.0

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.21.0](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@2.20.1...@exodus/bitcoin-api@2.21.0) (2024-07-19)
+
+
+### Features
+
+* **BTC:** create batch tx from array of recipients ([#2881](https://github.com/ExodusMovement/assets/issues/2881)) ([440d5d5](https://github.com/ExodusMovement/assets/commit/440d5d5879c902ef10ff7644c92a5092bb868872))
+
+
+### Bug Fixes
+
+* **bitcoin-api:** stop ws connection on monitor stop ([#2851](https://github.com/ExodusMovement/assets/issues/2851)) ([e52f4c2](https://github.com/ExodusMovement/assets/commit/e52f4c23e7635cc3116c876ad35fbbab4a70c32b))
+
+
+
+## [2.20.1](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@2.20.0...@exodus/bitcoin-api@2.20.1) (2024-07-15)
+
+**Note:** Version bump only for package @exodus/bitcoin-api
+
+
+
+
+
 ## [2.20.0](https://github.com/ExodusMovement/assets/compare/@exodus/bitcoin-api@2.19.0...@exodus/bitcoin-api@2.20.0) (2024-07-09)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.20.0",
+  "version": "2.21.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -14,7 +14,7 @@
     "access": "restricted"
   },
   "scripts": {
-    "test": "run -T jest",
+    "test": "run -T exodus-test --jest --esbuild",
     "lint": "run -T eslint .",
     "lint:fix": "yarn lint --fix"
   },
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "0dc141fc6a249ac051a5ca591d46cbc81096a4f3"
+  "gitHead": "ba7439e1b8ae182a2a95ffd0ea09b8bc3330f2f6"
 }

package/src/account-state.js

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

package/src/balances.js

@@ -13,6 +13,20 @@ export const getBalancesFactory = ({ feeData, getSpendableBalance, ordinalsEnabl
     assert(asset, 'asset is required')
     assert(accountState, 'accountState is required')
     assert(txLog, 'txLog is required')
+
+    if (accountState.magicEdenApiFungibleBalances) {
+      const validBalances = accountState.magicEdenApiFungibleBalances.filter(
+        (fungibleBalance) => fungibleBalance.asset.ticker === asset.ticker
+      )
+      const parsedBalances = validBalances.map(({ balance }) =>
+        asset.currency.defaultUnit(balance.balance)
+      )
+      const totalBalance = asset.currency.defaultUnit(
+        parsedBalances.reduce((sum, item) => sum.add(item), asset.currency.ZERO)
+      )
+      return { balance: totalBalance }
+    }
+
     const utxos = getUtxos({ asset, accountState })
     const balance = utxos.value
     const spendableBalance = getSpendableBalance({

package/src/btc-like-keys.js

@@ -4,7 +4,7 @@ import * as bech32 from 'bech32'
 import assert from 'minimalistic-assert'
 import { identity, pickBy } from 'lodash'
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
-import * as secp256k1 from 'secp256k1'
+import secp256k1 from 'secp256k1'
 import { hash160 } from './hash-utils'
 import { toXOnly } from './bitcoinjs-lib/ecc-utils'
 import { ecc } from './bitcoinjs-lib/ecc'

package/src/fee/utxo-selector.js

@@ -27,6 +27,7 @@ export const selectUtxos = ({
   amount,
   feeRate,
   receiveAddress, // it could be null
+  receiveAddresses = [],
   isSendAll,
   getFeeEstimator,
   disableReplacement = false,
@@ -44,10 +45,9 @@ export const selectUtxos = ({
     inscriptionIds,
   })
 
-  const receiveAddresses = []
   if (inscriptionIds) {
     receiveAddresses.push(...inscriptionIds.map(() => resolvedReceiveAddresses))
-  } else {
+  } else if (receiveAddresses.length === 0) {
     receiveAddresses.push(resolvedReceiveAddresses)
   }
 

package/src/index.js

@@ -14,6 +14,8 @@ export * from './utxos-utils'
 export * from './tx-log'
 export * from './unconfirmed-ancestor-data'
 export * from './parse-unsigned-tx'
+export { getCreateBatchTransaction } from './tx-send/batch-tx'
+export { createPsbtToUnsignedTx } from './psbt-utils'
 export * from './insight-api-client/util'
 export * from './move-funds'
 export { createEncodeMultisigContract } from './multisig-address'

package/src/move-funds.js

@@ -2,7 +2,7 @@ import wif from 'wif'
 import { UtxoCollection, Address } from '@exodus/models'
 import { createInputs, createOutput, getNonWitnessTxs } from './tx-send'
 import assert from 'minimalistic-assert'
-import * as secp256k1 from 'secp256k1'
+import secp256k1 from 'secp256k1'
 
 const isValidPrivateKey = (privateKey) => {
   try {

package/src/psbt-utils.js

@@ -0,0 +1,61 @@
+import BipPath from 'bip32-path'
+import lodash from 'lodash'
+
+export const createPsbtToUnsignedTx =
+  ({ assetClientInterface, assetName }) =>
+  async ({ psbt, walletAccount, purpose = 86 }) => {
+    const addressPathsMap = {}
+    const inputsToSign = []
+
+    const addressOpts = {
+      walletAccount: walletAccount.toString(),
+      assetName,
+      purpose,
+      chainIndex: 0,
+      addressIndex: 0,
+    }
+
+    // Need to have all input derivations
+    for (const i of lodash.range(psbt.inputCount)) {
+      const input = psbt.data.inputs[i]
+
+      const derivation = input.tapBip32Derivation
+      if (!derivation) {
+        throw new Error('Invalid input in psbt, no derivation for input found')
+      }
+
+      const [chainIndex, addressIndex] = BipPath.fromString(derivation[0].path).toPathArray()
+
+      addressOpts.chainIndex = chainIndex
+      addressOpts.addressIndex = addressIndex
+
+      const address = await assetClientInterface.getAddress(addressOpts)
+
+      addressPathsMap[address.toString()] = derivation[0].path
+      inputsToSign.push({ address: address.toString() })
+    }
+
+    // If we have output derivations then it's our change
+    for (const i of lodash.range(psbt.txOutputs.length)) {
+      const output = psbt.data.outputs[i]
+
+      const derivation = output.tapBip32Derivation
+      if (!derivation) continue
+      const [chainIndex, addressIndex] = BipPath.fromString(derivation[0].path).toPathArray()
+
+      addressOpts.chainIndex = chainIndex
+      addressOpts.addressIndex = addressIndex
+      const address = await assetClientInterface.getAddress(addressOpts)
+
+      addressPathsMap[address.toString()] = derivation[0].path
+    }
+
+    return {
+      txData: { psbtBuffer: psbt.toBuffer() },
+      txMeta: {
+        addressPathsMap,
+        inputsToSign,
+        accountIndex: walletAccount.index,
+      },
+    }
+  }

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

@@ -0,0 +1,78 @@
+import { Monitor as BitcoinMonitor } from './bitcoin-monitor'
+import fetchFlagrEvaluation from './me-flagr'
+
+const FLAGR_KEY = 'bitcoin-balance-api'
+
+export class MagicEdenBitcoinMonitor extends BitcoinMonitor {
+  constructor(args) {
+    super(args)
+    this.useMagicEdenMonitor = false
+  }
+
+  async setServer(assetConfig = {}) {
+    super.setServer(assetConfig)
+
+    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
+    const address = await this.aci.getReceiveAddress({
+      assetName: this.asset.name,
+      walletAccount: walletAccounts[0],
+      useCache: true,
+    })
+    await this.initFlagr(address)
+  }
+
+  async initFlagr(address) {
+    if (this.useMagicEdenMonitor) return
+    try {
+      const response = await fetchFlagrEvaluation(address, FLAGR_KEY)
+      if (response.variantKey === 'on') {
+        this.useMagicEdenMonitor = true
+      }
+    } catch (error) {
+      console.error('Failed to fetch useMagicEdenMonitor config:', error)
+    }
+  }
+
+  async fetchFungibleBalances(walletAccount) {
+    if (!this.useMagicEdenMonitor) return
+
+    const purposes = await this.aci.getSupportedPurposes({
+      assetName: this.asset.name,
+      walletAccount,
+    })
+
+    const addresses = await Promise.all(
+      purposes.map((purpose) =>
+        this.aci.getReceiveAddress({
+          assetName: this.asset.name,
+          walletAccount,
+          useCache: true,
+          purpose,
+        })
+      )
+    )
+
+    const response = await fetch('https://api-mainnet.magiceden.io/v1/wallet/balances/fungible', {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(
+        addresses.map((address) => ({ address, chain: this.asset.baseAssetName }))
+      ),
+    })
+
+    if (!response.ok) {
+      throw new Error(
+        `Unable to fetch bitcoin fungible balanes: API returned ${response.status}: ${response.statusText || 'Unknown Status Text'}`
+      )
+    }
+
+    const { balances } = await response.json()
+
+    return balances
+  }
+}
+
+export const createMagicEdenBitcoinMonitor = (args) => new MagicEdenBitcoinMonitor(args)

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

@@ -62,6 +62,12 @@ export class Monitor extends BaseMonitor {
       })
 
     this.addHook('after-tick-multiple-wallet-accounts', () => this.#subscribeToNewAddresses())
+    this.addHook('before-stop', () => {
+      if (this.#ws) {
+        this.#ws.close()
+        this.#ws = null
+      }
+    })
     this.addHook('after-stop', async () =>
       Promise.all(Object.keys(this.#runningByWalletAccount).map(this.#waitForWalletToFinish))
     )
@@ -281,6 +287,12 @@ export class Monitor extends BaseMonitor {
       newData.mem = { unconfirmedTxAncestor }
     }
 
+    if (this.fetchFungibleBalances) {
+      try {
+        newData.magicEdenApiFungibleBalances = await this.fetchFungibleBalances(walletAccount)
+      } catch {}
+    }
+
     await aci.updateAccountState({
       assetName,
       walletAccount,

package/src/tx-log/index.js

@@ -1,2 +1,3 @@
 export * from './bitcoin-monitor'
+export * from './magic-eden-bitcoin-monitor'
 export * from './bitcoin-monitor-scanner'

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

@@ -0,0 +1,86 @@
+import { Monitor as BitcoinMonitor } from './bitcoin-monitor'
+import fetchFlagrEvaluation from './me-flagr'
+
+const FLAGR_KEY = 'bitcoin-balance-api'
+
+export class MagicEdenBitcoinMonitor extends BitcoinMonitor {
+  constructor(args) {
+    super(args)
+    this.useMagicEdenMonitor = false
+  }
+
+  async setServer(assetConfig = {}) {
+    super.setServer(assetConfig)
+
+    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
+    const address = await this.aci.getReceiveAddress({
+      assetName: this.asset.name,
+      walletAccount: walletAccounts[0],
+      useCache: true,
+    })
+    await this.initFlagr(address)
+  }
+
+  async initFlagr(address) {
+    if (this.useMagicEdenMonitor) return
+    try {
+      const response = await fetchFlagrEvaluation(address, FLAGR_KEY)
+      if (response.variantKey === 'on') {
+        this.useMagicEdenMonitor = true
+      }
+    } catch (error) {
+      console.error('Failed to fetch useMagicEdenMonitor config:', error)
+    }
+  }
+
+  async fetchFungibleBalances(walletAccount) {
+    if (!this.useMagicEdenMonitor) return
+
+    const purposes = await this.aci.getSupportedPurposes({
+      assetName: this.asset.name,
+      walletAccount,
+    })
+
+    const addresses = await Promise.all(
+      purposes.map((purpose) =>
+        this.aci.getReceiveAddress({
+          assetName: this.asset.name,
+          walletAccount,
+          useCache: true,
+          purpose,
+        })
+      )
+    )
+
+    const response = await fetch('https://api-mainnet.magiceden.io/v1/wallet/balances/fungible', {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(
+        addresses.map((address) => ({ address, chain: this.asset.baseAssetName }))
+      ),
+    })
+
+    if (!response.ok) {
+      throw new Error(
+        `Unable to fetch bitcoin fungible balanes: API returned ${response.status}: ${response.statusText || 'Unknown Status Text'}`
+      )
+    }
+
+    const { balances } = await response.json()
+
+    const metadata = new Map()
+    balances.forEach((balance) => {
+      if (balance.asset?.id && balance.image) {
+        metadata.set(balance.asset.id, { imageURL: balance.image })
+      }
+    })
+    this.emit('token-metadata', { source: 'bitcoin', metadata })
+
+    return balances
+  }
+}
+
+export const createMagicEdenBitcoinMonitor = (args) => new MagicEdenBitcoinMonitor(args)

package/src/tx-log/me-flagr.js

@@ -0,0 +1,22 @@
+const FLAGR_URL = 'https://flagr-w.magiceden.io/api/v1/evaluation'
+
+const fetchFlagrEvaluation = async (wallet, flagKey) => {
+  const response = await fetch(FLAGR_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ entityContext: { wallet }, flagKey }),
+  })
+
+  if (!response.ok) {
+    throw new Error(
+      `${FLAGR_URL} returned ${response.status}: ${response.statusText || 'Unknown Status Text'}`
+    )
+  }
+
+  return response.json()
+}
+
+export default fetchFlagrEvaluation

package/src/tx-send/batch-tx.js

@@ -0,0 +1,206 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import BIP32 from '@exodus/bip32'
+import { Psbt } from '@exodus/bitcoinjs-lib'
+import BipPath from 'bip32-path'
+// Using this notation so it can be mocked by jest
+import doShuffle from 'lodash/shuffle'
+import assert from 'minimalistic-assert'
+
+import { selectUtxos } from '../fee/utxo-selector'
+import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data'
+import { getUsableUtxos, getUtxos } from '../utxos-utils'
+
+const DUST_VALUES = {
+  P2WPKH: 294,
+  P2TR: 330,
+}
+
+export const getCreateBatchTransaction = ({
+  getFeeEstimator,
+  assetClientInterface,
+  changeAddressType,
+}) => {
+  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx`)
+
+  return async ({ assetName, walletAccount, recipients, options = {} }) => {
+    const stuff = await assetClientInterface.getAssetsForNetwork({ baseAssetName: assetName })
+    const asset = stuff[assetName]
+
+    const {
+      feeData = await assetClientInterface.getFeeConfig({ assetName }),
+      taprootInputWitnessSize,
+    } = options
+
+    const accountState = await assetClientInterface.getAccountState({ assetName, walletAccount })
+
+    const txSet = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
+    const usableUtxos = getUsableUtxos({
+      asset,
+      utxos: getUtxos({ accountState, asset }),
+      feeData,
+      txSet,
+      unconfirmedTxAncestor,
+    })
+
+    const amount = recipients.reduce((acc, curr) => acc.add(curr.amount), asset.currency.ZERO)
+    const receiveAddresses = recipients.map((recipient) => recipient.address)
+
+    const { selectedUtxos, fee } = selectUtxos({
+      asset,
+      usableUtxos,
+      amount,
+      feeRate: feeData.feePerKB,
+      receiveAddresses,
+      getFeeEstimator: (asset, { feePerKB, ...options }) =>
+        getFeeEstimator(asset, feePerKB, options),
+      unconfirmedTxAncestor,
+      taprootInputWitnessSize,
+      changeAddressType,
+      allowUnconfirmedRbfEnabledUtxos: false,
+    })
+
+    if (!selectedUtxos) throw new Error('Not enough funds.')
+
+    const addressPathsMap = selectedUtxos.getAddressPathsMap()
+
+    const psbt = new Psbt({ network: asset.coinInfo.toBitcoinJS() })
+
+    for (const utxo of doShuffle(selectedUtxos.toArray())) {
+      const path = addressPathsMap[utxo.address]
+      if (!path) {
+        throw new Error(`Path missing for input address ${utxo.address}`)
+      }
+
+      const [chainIndex, addressIndex] = BipPath.fromString(path).toPathArray()
+      const addressOpts = {
+        walletAccount,
+        assetName,
+        chainIndex: 0,
+        addressIndex: 0,
+      }
+      addressOpts.chainIndex = chainIndex
+      addressOpts.addressIndex = addressIndex
+      addressOpts.purpose = utxo.address.meta.purpose
+
+      const [address, xpub] = await Promise.all([
+        assetClientInterface.getAddress(addressOpts),
+        assetClientInterface.getExtendedPublicKey(addressOpts),
+      ])
+      assert(String(address) === String(utxo.address))
+
+      const hdkey = BIP32.fromXPub(xpub)
+      const masterFingerprint = Buffer.alloc(4)
+      masterFingerprint.writeUint32BE(hdkey.fingerprint)
+
+      const input = {
+        hash: utxo.txId,
+        index: utxo.vout,
+        witnessUtxo: {
+          value: parseInt(utxo.value.toBaseString(), 10),
+          script: Buffer.from(utxo.script, 'hex'),
+        },
+      }
+
+      if (address.meta.spendingInfo) {
+        const { witness, redeem } = address.meta.spendingInfo
+        input.tapLeafScript = [
+          {
+            leafVersion: redeem.redeemVersion,
+            script: redeem.output,
+            controlBlock: witness[witness.length - 1],
+          },
+        ]
+      }
+
+      psbt.addInput(input)
+
+      const pubkey = hdkey.derive(path).publicKey.slice(1)
+      const index = psbt.data.inputs.length - 1
+      psbt.data.inputs[index].tapBip32Derivation = [
+        {
+          path,
+          leafHashes: [],
+          masterFingerprint,
+          pubkey,
+        },
+      ]
+    }
+
+    const change = selectedUtxos.value.sub(amount).sub(fee)
+    if (change.gte(asset.currency.baseUnit(DUST_VALUES[changeAddressType]))) {
+      const changeAddress = await assetClientInterface.getNextChangeAddress({
+        assetName,
+        walletAccount,
+      })
+
+      const output = { address: String(changeAddress), amount: change }
+
+      const path = changeAddress.meta.path
+
+      const xpub = await assetClientInterface.getExtendedPublicKey({ walletAccount, assetName })
+      const hdkey = BIP32.fromXPub(xpub)
+      const masterFingerprint = Buffer.alloc(4)
+      masterFingerprint.writeUint32BE(hdkey.fingerprint)
+
+      const pubkey = hdkey.derive(path).publicKey.slice(1)
+      output.tapBip32Derivation = [
+        {
+          path,
+          leafHashes: [],
+          masterFingerprint,
+          pubkey,
+        },
+      ]
+
+      recipients.push(output)
+    }
+
+    for (const recipient of doShuffle(recipients)) {
+      psbt.addOutput({
+        address: recipient.address,
+        value: parseInt(recipient.amount.toBaseString(), 10),
+        unknownKeyVals: [],
+      })
+
+      const index = psbt.data.outputs.length - 1
+      if (recipient.tapBip32Derivation) {
+        psbt.data.outputs[index].tapBip32Derivation = recipient.tapBip32Derivation
+      }
+
+      if (recipient.name) {
+        psbt.data.outputs[index].unknownKeyVals.push({
+          key: Buffer.from('name', 'utf8'),
+          value: Buffer.from(recipient.name, 'utf8'),
+        })
+      }
+
+      if (recipient.email) {
+        psbt.data.outputs[index].unknownKeyVals.push({
+          key: Buffer.from('email', 'utf8'),
+          value: Buffer.from(recipient.email, 'utf8'),
+        })
+      }
+
+      if (recipient.description) {
+        psbt.data.outputs[index].unknownKeyVals.push({
+          key: Buffer.from('description', 'utf8'),
+          value: Buffer.from(recipient.description, 'utf8'),
+        })
+      }
+
+      if (recipient.fiatAmount) {
+        psbt.data.outputs[index].unknownKeyVals.push({
+          key: Buffer.from('fiatAmount', 'utf8'),
+          value: Buffer.from(recipient.fiatAmount.toDefaultString(), 'utf8'),
+        })
+      }
+    }
+
+    const blockHeight = await asset.baseAsset.insightClient.fetchBlockHeight()
+
+    psbt.setLocktime(blockHeight)
+
+    return psbt
+  }
+}

package/src/tx-send/index.js

@@ -1,6 +1,5 @@
 import assert from 'minimalistic-assert'
-// Using this notation so it can be mocked by jest
-import doShuffle from 'lodash/shuffle'
+import lodash from 'lodash'
 
 import { UtxoCollection, Address } from '@exodus/models'
 import { retry } from '@exodus/simple-retry'
@@ -268,7 +267,8 @@ export const getPrepareSendTransaction =
     )
 
     const shuffle = (list) => {
-      return inscriptionIds ? list : doShuffle(list) // don't shuffle when sending ordinal!!!!
+      // Using full lodash.shuffle notation so it can be mocked with spyOn in tests
+      return inscriptionIds ? list : lodash.shuffle(list) // don't shuffle when sending ordinal!!!!
     }
 
     assert(
@@ -335,7 +335,11 @@ export const getPrepareSendTransaction =
     }
 
     const sendAmount = bumpTxId || transferOrdinalsUtxos ? asset.currency.ZERO : amount
-    const receiveAddress = bumpTxId ? (replaceableTxs.length > 0 ? null : 'P2WPKH') : address
+    const receiveAddress = bumpTxId
+      ? replaceableTxs.length > 0
+        ? null
+        : changeAddressType
+      : address
     const feeRate = feeData.feePerKB
     const resolvedIsSendAll = (!rbfEnabled && feePerKB) || transferOrdinalsUtxos ? false : isSendAll
 

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

@@ -6,7 +6,7 @@ import KeyIdentifier from '@exodus/key-identifier'
 
 import { getECPair } from '../bitcoinjs-lib'
 
-import * as secp256k1 from 'secp256k1'
+import secp256k1 from 'secp256k1'
 
 const ECPair = getECPair()
 

package/src/tx-sign/default-entropy.cjs

@@ -0,0 +1,6 @@
+// extension point so tests can assert signatures deterministically
+// this has to be CJS to still be mockable once we migrate to ESM world
+
+function getSchnorrEntropy() {}
+
+module.exports = { getSchnorrEntropy }

package/src/tx-sign/taproot.js

@@ -1,7 +1,7 @@
 import { crypto } from '@exodus/bitcoinjs-lib'
 import assert from 'minimalistic-assert'
 
-import { getSchnorrEntropy } from './default-entropy'
+import defaultEntropy from './default-entropy.cjs'
 import { ecc } from '../bitcoinjs-lib/ecc'
 import { getECPair } from '../bitcoinjs-lib'
 
@@ -59,7 +59,8 @@ export function toAsyncSigner({ keyPair, isTaprootKeySpend, network }) {
 
   // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
   keyPair.signSchnorr = async (h) => {
-    const sig = ecc.signSchnorr(h, keyPair.privateKey, getSchnorrEntropy())
+    // defaultEntropy.getSchnorrEntropy() is mockable with jest.spyOn
+    const sig = ecc.signSchnorr(h, keyPair.privateKey, defaultEntropy.getSchnorrEntropy())
     return Buffer.from(sig)
   }
 
@@ -94,7 +95,8 @@ export async function toAsyncBufferSigner({ signer, purpose, keyId, isTaprootKey
         keyId,
         signatureType: 'schnorr',
         tweak,
-        extraEntropy: getSchnorrEntropy(),
+        // defaultEntropy.getSchnorrEntropy() is mockable with jest.spyOn
+        extraEntropy: defaultEntropy.getSchnorrEntropy(),
       })
     },
     publicKey,

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

@@ -1,2 +0,0 @@
-// extension point so tests can assert signatures deterministically
-export function getSchnorrEntropy() {}