@exodus/bitcoin-api 2.6.2 → 2.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "@exodus/basic-utils": "^2.1.0",
     "@exodus/bip-schnorr": "0.6.6-fork-1",
     "@exodus/bip44-constants": "^195.0.0",
-    "@exodus/models": "^10.1.0",
+    "@exodus/models": "^11.0.0",
     "@exodus/secp256k1": "4.0.2-exodus.0",
     "@exodus/simple-retry": "0.0.6",
     "@exodus/timer": "^1.0.0",
@@ -38,10 +38,10 @@
     "url-join": "4.0.0"
   },
   "devDependencies": {
-    "@exodus/bitcoin-meta": "^1.0.1",
+    "@exodus/bitcoin-meta": "^1.0.2",
     "@scure/base": "^1.1.3",
     "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
   },
-  "gitHead": "a9f5e8c6f0ac0655cdd2721cf20813f86a373678"
+  "gitHead": "33c832c0c550fa4a885aee9b34f7649bfb5fa464"
 }

package/src/address-utils.js

@@ -1,10 +1,10 @@
 import assert from 'minimalistic-assert'
 
-export function isReceiveAddress(address): boolean {
+export function isReceiveAddress(address) {
   return parsePath(address)[0] === 0
 }
 
-export function isChangeAddress(address): boolean {
+export function isChangeAddress(address) {
   return parsePath(address)[0] === 1
 }
 

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

@@ -5,24 +5,48 @@ import { toXOnly } from '../ecc-utils'
  * 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),
+  /**
+   *
+   * @param msg32 {Uint8Array} the message
+   * @param seckey {Uint8Array} the private key
+   * @param data {Uint8Array} the data to sign
+   */
+  sign: (msg32, seckey, data) => secp256k1.ecdsaSign(msg32, seckey, { data }).signature,
 
-  privateAdd: (d: Uint8Array, tweak: Uint8Array): Uint8Array | null =>
+  /**
+   *
+   * @param msg32 {Uint8Array} the message to verify
+   * @param publicKey {Uint8Array} the public key
+   * @param signature {Uint8Array} the signature
+   * @returns {boolean}
+   */
+  verify: (msg32, publicKey, signature) => secp256k1.ecdsaVerify(signature, msg32, publicKey),
+
+  /**
+   *
+   * @param seckey {Uint8Array}
+   * @param tweak {Uint8Array}
+   */
+  privateAdd: (seckey, tweak) =>
     // cloning input. secp256k1 modifies it and it cannot be reused/cached
-    secp256k1.privateKeyTweakAdd(Buffer.from(d), tweak),
+    secp256k1.privateKeyTweakAdd(Buffer.from(seckey), tweak),
 
-  privateNegate: (d: Uint8Array): Uint8Array =>
+  /**
+   * @param seckey {Uint8Array} the public key
+   */
+  privateNegate: (seckey) =>
     // cloning input. secp256k1 modifies it and it cannot be reused/cached
-    secp256k1.privateKeyNegate(Buffer.from(d)),
+    secp256k1.privateKeyNegate(Buffer.from(seckey)),
 
-  xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array) => {
+  /**
+   *
+   * @param publicKey {Uint8Array}
+   * @param tweak {Uint8Array}
+   * @returns {{parity: (number), xOnlyPubkey}|null}
+   */
+  xOnlyPointAddTweak: (publicKey, tweak) => {
     try {
-      const t = secp256k1.publicKeyTweakAdd(toPubKey(p), tweak)
+      const t = secp256k1.publicKeyTweakAdd(toPubKey(publicKey), tweak)
       return {
         parity: t[0] === 0x02 ? 0 : 1,
         xOnlyPubkey: toXOnly(t),
@@ -32,12 +56,24 @@ export const common = {
     }
   },
 
-  isPrivate: (d: Uint8Array): boolean => secp256k1.privateKeyVerify(d),
-  pointFromScalar: (d: Uint8Array, compressed?: boolean): Uint8Array | null =>
-    secp256k1.publicKeyCreate(d, compressed),
+  /**
+   * @param seckey {Uint8Array}
+   * @returns {boolean}
+   */
+  isPrivate: (seckey) => secp256k1.privateKeyVerify(seckey),
+  /**
+   * @param seckey {Uint8Array}
+   * @param compressed {boolean}
+   */
+  pointFromScalar: (seckey, compressed) => secp256k1.publicKeyCreate(seckey, compressed),
 }
 
-export const toPubKey = (xOnly: Uint8Array) => {
+/**
+ *
+ * @param xOnly {Uint8Array}
+ * @returns {Uint8Array}
+ */
+export const toPubKey = (xOnly) => {
   const p = new Uint8Array(33)
   p.set([0x02])
   p.set(xOnly, 1)

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

@@ -1,4 +1,4 @@
-import { TinySecp256k1Interface, initEccLib } from 'bitcoinjs-lib'
+import { initEccLib } from 'bitcoinjs-lib'
 import { Point, schnorr, sign } from '@noble/secp256k1'
 import { common, toPubKey } from './common'
 
@@ -6,20 +6,39 @@ 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 = {
+export const desktopEcc = {
   ...common,
 
-  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
-    sign(h, d, {
+  /**
+   * @param message {Uint8Array}
+   * @param privateKey {Uint8Array}
+   * @param extraEntropy {Uint8Array}
+   * @returns {Promise<Uint8Array>}
+   */
+  signAsync: async (message, privateKey, extraEntropy) =>
+    sign(message, privateKey, {
       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),
+  /**
+   * @param message {Uint8Array}
+   * @param privateKey {Uint8Array}
+   * @param extraEntropy {Uint8Array}
+   * @returns {Promise<Uint8Array>}
+   */
+  signSchnorrAsync: async (message, privateKey, extraEntropy) =>
+    schnorr.sign(message, privateKey, extraEntropy),
+
+  /**
+   * @param message {Uint8Array}
+   * @param publicKey {Uint8Array}
+   * @param signature {Uint8Array}
+   * @returns {Promise<boolean>}
+   */
+  verifySchnorrAsync: async (message, publicKey, signature) =>
+    schnorr.verify(signature, message, publicKey),
 
   // The underlying library does not expose sync functions for Schnorr sign and verify.
   // These function are explicitly defined here as `null` for documentation purposes.
@@ -27,26 +46,38 @@ export const desktopEcc: TinySecp256k1Interface = {
   signSchnorr: null,
   verifySchnorr: null,
 
-  isPoint: (p: Uint8Array): boolean => {
+  /**
+   * @param publicKey {Uint8Array}
+   * @returns {boolean}
+   */
+  isPoint: (publicKey) => {
     try {
-      Point.fromHex(p).assertValidity()
+      Point.fromHex(publicKey).assertValidity()
       return true
     } catch {
       return false
     }
   },
 
-  isXOnlyPoint: (p: Uint8Array): boolean => {
+  /**
+   * @param publicKey {Uint8Array}
+   * @returns {boolean}
+   */
+  isXOnlyPoint: (publicKey) => {
     try {
-      Point.fromHex(toPubKey(p)).assertValidity()
+      Point.fromHex(toPubKey(publicKey)).assertValidity()
       return true
     } catch {
       return false
     }
   },
 
-  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
-    Point.fromHex(p).toRawBytes(compressed),
+  /**
+   * @param publicKey {Uint8Array}
+   * @param compressed {boolean}
+   * @returns {Uint8Array}
+   */
+  pointCompress: (publicKey, compressed) => Point.fromHex(publicKey).toRawBytes(compressed),
 }
 
 initEccLib(desktopEcc)

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

@@ -1,4 +1,4 @@
-import { TinySecp256k1Interface, initEccLib } from 'bitcoinjs-lib'
+import { initEccLib } from 'bitcoinjs-lib'
 import secp256k1 from '@exodus/secp256k1'
 // TODO: temp import until '@noble/secp256k1' can be used
 import { isPoint } from 'tiny-secp256k1'
@@ -11,50 +11,92 @@ import schnorr from '@exodus/bip-schnorr'
  *
  */
 
-export const mobileEcc: TinySecp256k1Interface = {
+export const mobileEcc = {
   ...common,
 
-  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
-    secp256k1.ecdsaSign(h, d, { data: extraEntropy }).signature,
+  /**
+   *
+   * @param message  {Uint8Array}
+   * @param seckey  {Uint8Array}
+   * @param extraEntropy {Uint8Array}
+   * @returns {Promise<(function(*): Uint8Array)|*>}
+   */
+  signAsync: async (message, seckey, extraEntropy) =>
+    secp256k1.ecdsaSign(message, seckey, { data: extraEntropy }).signature,
 
-  signSchnorr: (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
-    schnorr.sign(d.toString('hex'), h, e),
+  /**
+   *
+   * @param message {Uint8Array}
+   * @param privateKey {Uint8Array}
+   * @param extraEntropy {Uint8Array}
+   * @returns {Buffer}
+   */
+  signSchnorr: (message, privateKey, extraEntropy) =>
+    schnorr.sign(privateKey.toString('hex'), message, extraEntropy),
 
-  signSchnorrAsync: async (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
-    mobileEcc.signSchnorr(h, d, e),
+  /**
+   * @param message  {Uint8Array}
+   * @param privateKey {Uint8Array}
+   * @param extraEntropy {Uint8Array}
+   * @returns {Promise<Buffer>}
+   */
+  signSchnorrAsync: async (message, privateKey, extraEntropy) =>
+    mobileEcc.signSchnorr(message, privateKey, extraEntropy),
 
-  verifySchnorr: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean => {
+  /**
+   * @param publicKey {Uint8Array}
+   * @param message {Uint8Array}
+   * @param signature {Uint8Array}
+   * @returns {boolean}
+   */
+  verifySchnorr: (publicKey, message, signature) => {
     try {
-      schnorr.verify(Q, h, signature)
+      schnorr.verify(message, publicKey, signature)
       return true
     } catch (e) {
       return false
     }
   },
 
-  verifySchnorrAsync: async (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean =>
-    mobileEcc.verifySchnorr(h, Q, signature),
+  /**
+   * @param publicKey {Uint8Array}
+   * @param message {Uint8Array}
+   * @param signature {Uint8Array}
+   * @returns {Promise<boolean>}
+   */
+  verifySchnorrAsync: async (publicKey, message, signature) =>
+    mobileEcc.verifySchnorr(publicKey, message, signature),
 
-  isPoint: (p: Uint8Array): boolean => {
+  /**
+   * @param publicKey {Uint8Array}
+   * @returns {boolean}
+   */
+  isPoint: (publicKey) => {
     try {
       // temp solution secp256k1 does not actually verify the value range, only the data length
-      return isPoint(Buffer.from(p))
+      return isPoint(Buffer.from(publicKey))
     } catch (err) {
       return false
     }
   },
 
-  isXOnlyPoint: (p: Uint8Array): boolean => {
+  /**
+   * @param publicKey {Uint8Array}
+   * @returns {boolean}
+   */
+  isXOnlyPoint: (publicKey) => {
     try {
       // temp solution secp256k1 does not actually verify the value range, only the data length
-      return isPoint(Buffer.from(toPubKey(p)))
+      return isPoint(Buffer.from(toPubKey(publicKey)))
     } catch (err) {
       return false
     }
   },
 
-  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
-    secp256k1.publicKeyConvert(p, compressed),
+  /**
+   * @param publicKey {Uint8Array}
+   */
+  pointCompress: (publicKey, compressed) => secp256k1.publicKeyConvert(publicKey, compressed),
 }
 
 initEccLib(mobileEcc)

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

@@ -1,7 +1,7 @@
 import { payments } from 'bitcoinjs-lib'
 
-function isPaymentFactory(payment: any): (script: Buffer, eccLib?: any) => boolean {
-  return (script: Buffer, eccLib?: any): boolean => {
+function isPaymentFactory(payment) {
+  return (script, eccLib) => {
     try {
       payment({ output: script }, { eccLib })
       return true
@@ -30,7 +30,7 @@ const types = {
   NONSTANDARD: 'nonstandard',
 }
 
-const outputFactory = () => (script: Buffer) => {
+const outputFactory = () => (script) => {
   if (isP2WPKH(script)) return types.P2WPKH
   if (isP2TR(script)) return types.P2TR
   if (isP2PKH(script)) return types.P2PKH

package/src/btc-like-keys.js

@@ -89,7 +89,7 @@ export const createBtcLikeKeys = ({
   const encodePublicTaproot =
     encodePublicTaprootCustom ||
     (useBip86
-      ? (publicKey: Buffer): string => {
+      ? (publicKey) => {
           const network = coinInfo.toBitcoinJS()
           return bitcoinjsLib.payments.p2tr({ internalPubkey: toXOnly(publicKey), network }).address
         }

package/src/fee/fee-estimator.js

@@ -1,4 +1,3 @@
-// @flow
 import assert from 'minimalistic-assert'
 import * as varuint from 'varuint-bitcoin'
 import { UtxoCollection } from '@exodus/models'
@@ -59,12 +58,7 @@ export const getSizeFactory = ({ defaultOutputType, addressApi }) => {
 
   const scriptClassifier = scriptClassifierFactory({ addressApi })
 
-  return (
-    asset: Object,
-    inputs: Array | UtxoCollection,
-    outputs: Array,
-    { compressed = true } = {}
-  ) => {
+  return (asset, inputs, outputs, { compressed = true } = {}) => {
     if (inputs instanceof UtxoCollection) {
       inputs = Array.from(inputs).map((utxo) => utxo.script || null)
     }

package/src/fee/fee-utils.js

@@ -1,11 +1,9 @@
-// @flow
-
-import NumberUnit, { isNumberUnit, UnitType } from '@exodus/currency'
+import { isNumberUnit, UnitType } from '@exodus/currency'
 import { resolveExtraFeeOfTx } from '../unconfirmed-ancestor-data'
 import { UtxoCollection } from '@exodus/models'
 import assert from 'minimalistic-assert'
 
-export const isHex = (s: string) => typeof s === 'string' && /[0-9a-f]*/.test(s.toLowerCase())
+export const isHex = (s) => typeof s === 'string' && /[0-9a-f]*/.test(s.toLowerCase())
 
 export function getExtraFee({ asset, inputs, feePerKB }) {
   let extraFee = 0
@@ -27,19 +25,19 @@ export function getExtraFee({ asset, inputs, feePerKB }) {
   return extraFee
 }
 
-export default function createDefaultFeeEstimator(getSize: () => number) {
+export default function createDefaultFeeEstimator(getSize) {
   return (asset, feePerKB, options) => {
-    return ({ inputs = options.inputs, outputs = options.outputs } = {}): NumberUnit => {
+    return ({ inputs = options.inputs, outputs = options.outputs } = {}) => {
       const extraFee = getExtraFee({ asset, inputs, feePerKB })
       // Yes, it's suppose to be '1000' and not '1024'
       // https://bitcoin.stackexchange.com/questions/24000/a-fee-is-added-per-kilobyte-of-data-that-means-1000-bytes-or-1024
-      const size: number = getSize(asset, inputs, outputs, options)
-      const feeRaw: number = Math.ceil((feePerKB.toBaseNumber() * size) / 1000)
+      const size = getSize(asset, inputs, outputs, options)
+      const feeRaw = Math.ceil((feePerKB.toBaseNumber() * size) / 1000)
       return asset.currency.baseUnit(feeRaw + extraFee)
     }
   }
 }
-export function parseCurrency(val: string | Object, currency: Object) {
+export function parseCurrency(val, currency) {
   assert(currency instanceof UnitType, 'Currency must be supples as a UnitType')
 
   if (isNumberUnit(val)) return val // TODO: consider checking if the unitType.equals(currency) (if currency is object)

package/src/insight-api-client/index.js

@@ -1,4 +1,3 @@
-/* @flow */
 /* global fetch */
 import urlJoin from 'url-join'
 import qs from 'querystring'
@@ -102,7 +101,7 @@ export default class InsightAPIClient {
     }))
   }
 
-  async fetchTx(txId: string) {
+  async fetchTx(txId) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/tx/${encodedTxId}`)
     const response = await fetch(url)
@@ -114,14 +113,14 @@ export default class InsightAPIClient {
     return response.json()
   }
 
-  async fetchRawTx(txId: string) {
+  async fetchRawTx(txId) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/rawtx/${encodedTxId}`)
     const { rawtx } = await fetchJson(url)
     return rawtx
   }
 
-  async fetchTxData(addrs: Array, options = {}) {
+  async fetchTxData(addrs, options = {}) {
     if (!Array.isArray(addrs) || addrs.length === 0) return { items: [], totalItems: 0 }
 
     options = { noScriptSig: 1, noAsm: 1, noSpent: 0, from: 0, to: 10, ...options }
@@ -157,7 +156,7 @@ export default class InsightAPIClient {
     return txs
   }
 
-  async fetchUnconfirmedAncestorData(txId: string) {
+  async fetchUnconfirmedAncestorData(txId) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/unconfirmed_ancestor/${encodedTxId}`)
     return fetchJson(url)

package/src/insight-api-client/util.js

@@ -17,7 +17,7 @@ import { groupBy, sortBy } from 'lodash'
 
   A B C  check A, no inputs
 */
-export function orderTxs(txs: Array) {
+export function orderTxs(txs) {
   if (txs.length === 1) return [...txs]
 
   // filter duplicates

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

@@ -1,4 +1,3 @@
-/* @flow */
 import { orderTxs } from '../insight-api-client/util'
 import { Address, UtxoCollection } from '@exodus/models'
 import { isEqual, compact, uniq } from 'lodash'
@@ -20,7 +19,8 @@ export class BitcoinMonitorScanner {
   #yieldToUI
   #ordinalsEnabled
   #ordinalChainIndex
-
+  #gapLimit
+  #refreshGapLimit
   constructor({
     asset,
     assetClientInterface,
@@ -30,6 +30,8 @@ export class BitcoinMonitorScanner {
     txFetchLimitResolver = ({ refresh }) => (refresh ? 50 : 10),
     ordinalsEnabled,
     ordinalChainIndex,
+    gapLimit = 10,
+    refreshGapLimit = 10,
   }) {
     assert(asset, 'asset is required!')
     assert(assetClientInterface, 'assetClientInterface is required!')
@@ -37,6 +39,8 @@ export class BitcoinMonitorScanner {
     assert(typeof yieldToUI === 'function', 'yieldToUI must be a function')
     assert(typeof txFetchLimitResolver === 'function', 'txFetchLimitResolver must be a function')
     assert(typeof shouldExcludeVoutUtxo === 'function', 'shouldExcludeVoutUtxo must be a function')
+    assert(typeof gapLimit === 'number', 'gapLimit must be a number')
+    assert(typeof refreshGapLimit === 'number', 'refreshGapLimit must be a number')
 
     this.#asset = asset
     this.#insightClient = insightClient
@@ -45,6 +49,8 @@ export class BitcoinMonitorScanner {
     this.#shouldExcludeVoutUtxo = shouldExcludeVoutUtxo
     this.#ordinalsEnabled = ordinalsEnabled
     this.#ordinalChainIndex = ordinalChainIndex
+    this.#gapLimit = gapLimit
+    this.#refreshGapLimit = refreshGapLimit
   }
 
   async rescanBlockchainInsight({ walletAccount, refresh }) {
@@ -188,18 +194,13 @@ export class BitcoinMonitorScanner {
       return txArrays.reduce((total, some) => total.concat(some), [])
     }
 
-    const receiveGapLimit = 10
-    const restoreGapLimit = 10
-    const changeGapLimit = 10
-    const gapLimits = [receiveGapLimit, changeGapLimit]
     const gapSearchParameters = newChains.map(({ purpose, chain }) => {
       return {
         purpose,
         chain,
         startAddressIndexes: chain.map(() => 0),
         endAddressIndexes: chain.map(
-          (addressIndex, chainIndex) =>
-            refresh ? restoreGapLimit : addressIndex + (gapLimits[chainIndex] || receiveGapLimit) // right of the || should never happen
+          (addressIndex) => (refresh ? this.#refreshGapLimit : addressIndex + this.#gapLimit) // right of the || should never happen
         ),
       }
     })
@@ -303,13 +304,9 @@ export class BitcoinMonitorScanner {
 
       gapSearchParameters.forEach((indexData) => {
         indexData.startAddressIndexes = [...indexData.endAddressIndexes]
-        indexData.endAddressIndexes = indexData.chain.map((addressIndex, chainIndex) => {
-          return (
-            addressIndex +
-            (refresh && addressIndex === indexData.endAddressIndexes[chainIndex]
-              ? restoreGapLimit
-              : gapLimits[chainIndex] || receiveGapLimit)
-          )
+        indexData.endAddressIndexes = indexData.chain.map((addressIndex) => {
+          const resolvedGapLimit = refresh ? this.#refreshGapLimit : this.#gapLimit
+          return addressIndex + resolvedGapLimit
         })
       })
 

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

@@ -94,7 +94,7 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
   assert(keys, 'keys is required')
   assert(coinInfo, 'coinInfo is required')
 
-  return async ({ unsignedTx, hdkeys, privateKeysAddressMap }): Object => {
+  return async ({ unsignedTx, hdkeys, privateKeysAddressMap }) => {
     assert(unsignedTx, 'unsignedTx is required')
     assert(hdkeys || privateKeysAddressMap, 'hdkeys or privateKeysAddressMap is required')
     const { addressPathsMap } = unsignedTx.txMeta
@@ -143,10 +143,11 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
       // dApps request to sign only specific transaction inputs.
       if (!inputInfo) continue
       const { address, sigHash } = inputInfo
-      const sigHashTypes = sigHash ? [sigHash] : undefined
+      const sigHashTypes = sigHash !== undefined ? [sigHash || Transaction.SIGHASH_ALL] : undefined
       const { key, purpose, publicKey } = getKeyAndPurpose(address)
 
-      if (purpose === 49) {
+      // 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

package/src/tx-sign/taproot.js

@@ -9,7 +9,7 @@ const ecc = eccFactory()
 export function tweakSigner({ signer, ECPair, tweakHash, network }) {
   assert(signer, 'signer is required')
   assert(ECPair, 'ECPair is required')
-  let privateKey: Uint8Array | undefined = signer.privateKey
+  let privateKey = signer.privateKey
   if (!privateKey) {
     throw new Error('Private key is required for tweaking signer!')
   }
@@ -30,7 +30,7 @@ export function tweakSigner({ signer, ECPair, tweakHash, network }) {
   })
 }
 
-function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
+function tapTweakHash(pubKey, h) {
   return crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]))
 }