@exodus/bitcoin-api 2.9.2 → 2.9.3-hotfix

package/src/parse-unsigned-tx.js

@@ -4,95 +4,94 @@ import BN from 'bn.js'
 import lodash from 'lodash'
 import { Transaction as BitcoinTransactionClass } from '@exodus/bitcoinjs-lib'
 
-export const parseUnsignedTxFactory = ({ Transaction = BitcoinTransactionClass } = {}) => async ({
-  asset,
-  unsignedTx,
-  getAddress,
-}) => {
-  const assetName = asset.name
-
-  const toNumberUnit = (value) => {
-    const parsedValue = Buffer.isBuffer(value) ? new BN(value, 10, 'le') : value // handle Dogecoin buffer values
-    return asset.currency.baseUnit(parsedValue).toDefault()
-  }
+export const parseUnsignedTxFactory =
+  ({ Transaction = BitcoinTransactionClass } = {}) =>
+  async ({ asset, unsignedTx, getAddress }) => {
+    const assetName = asset.name
+
+    const toNumberUnit = (value) => {
+      const parsedValue = Buffer.isBuffer(value) ? new BN(value, 10, 'le') : value // handle Dogecoin buffer values
+      return asset.currency.baseUnit(parsedValue).toDefault()
+    }
 
-  const parseAddress = assetName === 'bcash' ? asset.address.toCashAddress : (address) => address
+    const parseAddress = assetName === 'bcash' ? asset.address.toCashAddress : (address) => address
 
-  const { inputs, outputs } = unsignedTx.txData
+    const { inputs, outputs } = unsignedTx.txData
 
-  const from = lodash.uniq(inputs.map(({ address }) => parseAddress(address)))
-  const outputAddresses = lodash.uniq(outputs.map(([address]) => address))
-  const inputTxIds = lodash.uniq(inputs.map(({ txId }) => txId))
-  const insightClient = asset.baseAsset.insightClient
-  const inputTxsRaw = await Promise.all(inputTxIds.map((txId) => insightClient.fetchRawTx(txId)))
-  const inputTxsById = new Map(
-    inputTxsRaw.map((hex) => {
-      const tx = Transaction.fromHex(hex)
-      return [tx.getId(), tx]
+    const from = lodash.uniq(inputs.map(({ address }) => parseAddress(address)))
+    const outputAddresses = lodash.uniq(outputs.map(([address]) => address))
+    const inputTxIds = lodash.uniq(inputs.map(({ txId }) => txId))
+    const insightClient = asset.baseAsset.insightClient
+    const inputTxsRaw = await Promise.all(inputTxIds.map((txId) => insightClient.fetchRawTx(txId)))
+    const inputTxsById = new Map(
+      inputTxsRaw.map((hex) => {
+        const tx = Transaction.fromHex(hex)
+        return [tx.getId(), tx]
+      })
+    )
+
+    inputs.forEach(({ txId, vout, value }) => {
+      const tx = inputTxsById.get(txId)
+      const output = tx.outs[vout]
+      const expected = assetName === 'dogecoin' ? output.valueBuffer : output.value
+      assert(
+        lodash.isEqual(expected, value),
+        `${txId} tx input has invalid value. Expected: ${expected} , Actual: ${value}`
+      )
     })
-  )
-
-  inputs.forEach(({ txId, vout, value }) => {
-    const tx = inputTxsById.get(txId)
-    const output = tx.outs[vout]
-    const expected = assetName === 'dogecoin' ? output.valueBuffer : output.value
-    assert(
-      lodash.isEqual(expected, value),
-      `${txId} tx input has invalid value. Expected: ${expected} , Actual: ${value}`
+
+    const { addressPathsMap } = unsignedTx.txMeta
+    const [changeOutputAddresses, toOutputAddresses] = lodash.partition(
+      outputAddresses,
+      (address) => {
+        const path = addressPathsMap[address]
+        if (!path) return false
+
+        const [chain, index] = BIPPath.fromString(path).path
+        const isOurs = getAddress({ chain, index }).toString() === address
+        return isOurs && chain === 1
+      }
     )
-  })
-
-  const { addressPathsMap } = unsignedTx.txMeta
-  const [changeOutputAddresses, toOutputAddresses] = lodash.partition(
-    outputAddresses,
-    (address) => {
-      const path = addressPathsMap[address]
-      if (!path) return false
-
-      const [chain, index] = BIPPath.fromString(path).path
-      const isOurs = getAddress({ chain, index }).toString() === address
-      return isOurs && chain === 1
+
+    // the user is explicitly sending to a change address, so take a wild guess
+    if (toOutputAddresses.length === 0) {
+      toOutputAddresses.push(changeOutputAddresses.pop())
     }
-  )
 
-  // the user is explicitly sending to a change address, so take a wild guess
-  if (!toOutputAddresses.length) {
-    toOutputAddresses.push(changeOutputAddresses.pop())
-  }
+    const [changeOutputs, sendOutputs] = lodash.partition(outputs, ([address]) =>
+      changeOutputAddresses.includes(address)
+    )
 
-  const [changeOutputs, sendOutputs] = lodash.partition(outputs, ([address]) =>
-    changeOutputAddresses.includes(address)
-  )
-
-  const sum = (arr) => arr.reduce((a, b) => a.add(b), asset.currency.ZERO)
-  const sumOutputs = (outputs) => sum(outputs.map(([_, value]) => toNumberUnit(value)))
-
-  // sum(inputs) = intendedSendAmount + fee + change
-  // sum(outputs) = intendedSendAmount + change
-
-  const inputsNF = inputs.map(({ value }) => toNumberUnit(value))
-  const outputsNF = outputs.map(([_, value]) => toNumberUnit(value))
-  const changeAmount = sumOutputs(changeOutputs)
-  const amount = sumOutputs(sendOutputs)
-
-  const inputsTotal = sum(inputsNF)
-  const outputsTotal = sum(outputsNF)
-  const fee = inputsTotal.sub(outputsTotal)
-
-  const changeAddress = changeOutputAddresses.length ? parseAddress(changeOutputAddresses[0]) : null
-  // TODO: return entire toOutputAddresses array
-  assert(toOutputAddresses.length === 1, 'multiple outputs not supported yet in 2fa mode')
-
-  const to = parseAddress(toOutputAddresses[0])
-  return {
-    asset,
-    from,
-    to,
-    amount,
-    changeAddress,
-    changeAmount,
-    fee,
+    const sum = (arr) => arr.reduce((a, b) => a.add(b), asset.currency.ZERO)
+    const sumOutputs = (outputs) => sum(outputs.map(([_, value]) => toNumberUnit(value)))
+
+    // sum(inputs) = intendedSendAmount + fee + change
+    // sum(outputs) = intendedSendAmount + change
+
+    const inputsNF = inputs.map(({ value }) => toNumberUnit(value))
+    const outputsNF = outputs.map(([_, value]) => toNumberUnit(value))
+    const changeAmount = sumOutputs(changeOutputs)
+    const amount = sumOutputs(sendOutputs)
+
+    const inputsTotal = sum(inputsNF)
+    const outputsTotal = sum(outputsNF)
+    const fee = inputsTotal.sub(outputsTotal)
+
+    const changeAddress =
+      changeOutputAddresses.length > 0 ? parseAddress(changeOutputAddresses[0]) : null
+    // TODO: return entire toOutputAddresses array
+    assert(toOutputAddresses.length === 1, 'multiple outputs not supported yet in 2fa mode')
+
+    const to = parseAddress(toOutputAddresses[0])
+    return {
+      asset,
+      from,
+      to,
+      amount,
+      changeAddress,
+      changeAmount,
+      fee,
+    }
   }
-}
 
 export const parseUnsignedTx = parseUnsignedTxFactory()

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

@@ -71,14 +71,15 @@ export class BitcoinMonitorScanner {
 
     const currentStoredUtxos = storedUtxos.union(storedOrdinalUtxos)
 
-    const currentTime = new Date().getTime()
-    const unconfirmedTxsToCheck = Array.from(currentTxs).reduce((txs, tx) => {
-      if (tx.pending) {
-        // Don't check sent tx that is younger than 2 minutes, because server might not have indexed it yet
-        if (!tx.sent || !tx.date || currentTime - tx.date.getTime() > SENT_TIME_TO_DROP) {
-          txs[tx.txId] = tx
-        }
+    const currentTime = Date.now()
+    const unconfirmedTxsToCheck = [...currentTxs].reduce((txs, tx) => {
+      if (
+        tx.pending && // Don't check sent tx that is younger than 2 minutes, because server might not have indexed it yet
+        (!tx.sent || !tx.date || currentTime - tx.date.getTime() > SENT_TIME_TO_DROP)
+      ) {
+        txs[tx.txId] = tx
       }
+
       return txs
     }, Object.create(null))
 
@@ -139,7 +140,7 @@ export class BitcoinMonitorScanner {
 
     const aggregateAddresses = async (chainObjects) => {
       const promises = []
-      for (let chainObject of chainObjects) {
+      for (const chainObject of chainObjects) {
         const { purpose, chainIndex, startAddressIndex, endAddressIndex } = chainObject
         for (let addressIndex = startAddressIndex; addressIndex < endAddressIndex; addressIndex++) {
           promises.push(
@@ -165,6 +166,7 @@ export class BitcoinMonitorScanner {
           )
         }
       }
+
       const addresses = []
       const result = await Promise.all(promises)
       result.forEach(({ address, purpose }) => {
@@ -192,13 +194,12 @@ export class BitcoinMonitorScanner {
         promises.push(promise)
       }
 
-      const insightTxs = (await Promise.all(promises)).reduce(
-        (total, some) => total.concat(some),
-        []
-      )
+      const listOfTxs = await Promise.all(promises)
+      const insightTxs = listOfTxs.flat()
       if (!this.#ordinalsEnabled) {
         return insightTxs
       }
+
       return Promise.all(
         insightTxs.map((tx) => {
           try {
@@ -232,8 +233,8 @@ export class BitcoinMonitorScanner {
     let allTxs = []
 
     for (let fetchCount = 0; ; fetchCount++) {
-      const chainObjects = gapSearchParameters
-        .map(({ purpose, chain, startAddressIndexes, endAddressIndexes }) => {
+      const chainObjects = gapSearchParameters.flatMap(
+        ({ purpose, chain, startAddressIndexes, endAddressIndexes }) => {
           return chain.map((_, chainIndex) => {
             return {
               purpose,
@@ -242,8 +243,8 @@ export class BitcoinMonitorScanner {
               endAddressIndex: endAddressIndexes[chainIndex],
             }
           })
-        })
-        .flat()
+        }
+      )
 
       if (
         fetchCount === 0 &&
@@ -277,7 +278,7 @@ export class BitcoinMonitorScanner {
 
       const txs = await fetchAllTxs(addresses)
       if (txs.length === 0) break
-      allTxs = allTxs.concat(txs)
+      allTxs = [...allTxs, ...txs]
 
       // Update chains to see if we need to fetch more
       txs.forEach((tx) =>
@@ -307,6 +308,7 @@ export class BitcoinMonitorScanner {
             console.warn(`${assetName}: Cannot resolve purpose from address ${addressString}`)
             return
           }
+
           const chainToUpgrade = newChains.find((newChain) => newChain.purpose === purposeToUpdate)
           if (!chainToUpgrade) {
             console.log(
@@ -314,12 +316,14 @@ export class BitcoinMonitorScanner {
             )
             return
           }
+
           if (chainToUpgrade.chain[metaChainIndex] === undefined) {
             console.log(
               `${assetName}: There is no chain info for purpose ${purposeToUpdate}, address ${addressString} and chain index ${metaChainIndex}`
             )
             return
           }
+
           chainToUpgrade.chain[metaChainIndex] = Math.max(
             metaAddressIndex + 1,
             chainToUpgrade.chain[metaChainIndex]
@@ -328,7 +332,9 @@ export class BitcoinMonitorScanner {
       )
 
       gapSearchParameters.forEach((indexData) => {
+        // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
         indexData.startAddressIndexes = [...indexData.endAddressIndexes]
+        // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
         indexData.endAddressIndexes = indexData.chain.map((addressIndex) => {
           const resolvedGapLimit = refresh ? this.#refreshGapLimit : this.#gapLimit
           return addressIndex + resolvedGapLimit
@@ -343,14 +349,14 @@ export class BitcoinMonitorScanner {
 
     // post process TX data
     // NOTE: this can be optimized
-    let vinTxids = Object.create(null)
+    const vinTxids = Object.create(null)
     let utxos = []
     const utxosToRemove = []
-    let newTxs = []
-    let existingTxs = []
+    const newTxs = []
+    const existingTxs = []
 
     allTxs.forEach((txItem) => {
-      let txLogItem = {
+      const txLogItem = {
         txId: txItem.txid,
         coinAmount: currency.ZERO,
         date: txItem.time ? new Date(txItem.time * 1000) : new Date(),
@@ -406,7 +412,7 @@ export class BitcoinMonitorScanner {
 
         // this is only used to exclude the utxos in the reducer which is why we don't care about the other fields
         utxosToRemove.push({
-          address: address,
+          address,
           txId: vin.txid,
           vout: vin.vout,
           value: currency.defaultUnit(vin.value || 0),
@@ -459,6 +465,7 @@ export class BitcoinMonitorScanner {
             const sentDisplayAddress = asset.address.displayAddress?.(sentAddress) || sentAddress
             txLogItem.data.sent.push({ address: sentDisplayAddress, amount: val })
           }
+
           return
         }
 
@@ -481,7 +488,7 @@ export class BitcoinMonitorScanner {
         }
 
         // it was sent to us...
-        let val = currency.defaultUnit(vout.value)
+        const val = currency.defaultUnit(vout.value)
         txLogItem.coinAmount = txLogItem.coinAmount.add(val)
 
         const output = {
@@ -502,6 +509,7 @@ export class BitcoinMonitorScanner {
         if (this.#shouldExcludeVoutUtxo({ asset, output, txItem, vout })) {
           return
         }
+
         if (vout.spentTxId) return
         utxos.push(output) // but save the unspent ones for state.utxos
       })
@@ -510,6 +518,7 @@ export class BitcoinMonitorScanner {
         if (txLogItem.to) {
           txLogItem.to = asset.address.displayAddress(txLogItem.to)
         }
+
         from = from.map(asset.address.displayAddress)
       }
 
@@ -557,17 +566,18 @@ export class BitcoinMonitorScanner {
     // Keep new utxos when they intersect with the stored utxos.
     utxoCol = utxoCol.union(currentStoredUtxos).difference(utxosToRemoveCol)
 
-    for (let tx of Object.values(unconfirmedTxsToCheck)) {
+    for (const tx of Object.values(unconfirmedTxsToCheck)) {
       existingTxs.push({ ...tx, dropped: true }) // TODO: this will decrease the chain index, it shouldn't be an issue considering the gap limit
       utxoCol = utxoCol.difference(utxoCol.getTxIdUtxos(tx.txId))
       const utxosToAdd = []
       if (tx.data.inputs) {
         const prevUtxos = UtxoCollection.fromJSON(tx.data.inputs, { currency })
-        for (let utxo of prevUtxos.toArray()) {
+        for (const utxo of prevUtxos.toArray()) {
           if (vinTxids[`${utxo.txId}-${utxo.vout}`]) {
             // This utxo was already spent in another tx
             continue
           }
+
           const tx = await insightClient.fetchTx(utxo.txId)
           if (tx) {
             // previously spent tx still exists, readd utxo
@@ -575,6 +585,7 @@ export class BitcoinMonitorScanner {
           }
         }
       }
+
       utxoCol = utxoCol.union(UtxoCollection.fromArray(utxosToAdd, { currency }))
     }
 
@@ -626,7 +637,7 @@ export class BitcoinMonitorScanner {
     const storedOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
     const allStoredUtxos = storedUtxos.union(storedOrdinalsUtxos)
 
-    const currentTxs = Array.from(await aci.getTxLog({ assetName, walletAccount }))
+    const currentTxs = [...(await aci.getTxLog({ assetName, walletAccount }))]
 
     const unconfirmedTxIds = uniq([
       ...storedUtxos
@@ -636,17 +647,17 @@ export class BitcoinMonitorScanner {
       ...currentTxs.filter((tx) => !tx.dropped && !tx.confirmations).map((tx) => tx.txId),
     ])
 
-    const confirmationsList = (
-      await Promise.all(
-        unconfirmedTxIds.map(async (txId) => {
-          const txStatus = await this.#insightClient.fetchTx(txId)
-          if (!txStatus?.confirmations) {
-            return undefined
-          }
-          return { txId, confirmations: txStatus.confirmations }
-        })
-      )
-    ).filter(Boolean)
+    const maybeConfirmationList = await Promise.all(
+      unconfirmedTxIds.map(async (txId) => {
+        const txStatus = await this.#insightClient.fetchTx(txId)
+        if (!txStatus?.confirmations) {
+          return
+        }
+
+        return { txId, confirmations: txStatus.confirmations }
+      })
+    )
+    const confirmationsList = maybeConfirmationList.filter(Boolean)
 
     const updatedPropertiesTxs = currentTxs
       .map((tx) => {
@@ -655,6 +666,7 @@ export class BitcoinMonitorScanner {
         if (!tx.dropped && !tx.confirmations && confirmations > 0) {
           updatedProperties.confirmations = confirmations
         }
+
         return { txId: tx.txId, ...updatedProperties }
       })
       .filter((tx) => Object.keys(tx).length > 1)
@@ -672,7 +684,7 @@ export class BitcoinMonitorScanner {
     const { utxos, ordinalsUtxos } = partitionUtxos({
       allUtxos: txConfirmedUtxos,
       ordinalsEnabled: this.#ordinalsEnabled,
-      ordinalAddress: ordinalAddress,
+      ordinalAddress,
       knownBalanceUtxoIds: latestAccountState.knownBalanceUtxoIds,
       mustAvoidUtxoIds: latestAccountState.mustAvoidUtxoIds,
       additionalInscriptions: latestAccountState.additionalInscriptions,

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

@@ -72,6 +72,7 @@ export class Monitor extends BaseMonitor {
     if (apiUrl) {
       this.#insightClient.setBaseUrl(apiUrl)
     }
+
     if (!this.#wsUrl || this.#wsUrl !== wsUrl) {
       this.#connectWS(wsUrl || this.#wsUrl || toWSUrl(this.#apiUrl))
     }
@@ -101,10 +102,12 @@ export class Monitor extends BaseMonitor {
     if (!this.#webSocketEnabled) {
       return
     }
+
     if (this.#ws) {
       this.#ws.close()
       this.#ws = null
     }
+
     this.#wsUrl = wsUrl
     if (!wsUrl) {
       return
@@ -114,7 +117,7 @@ export class Monitor extends BaseMonitor {
 
     const addressesArr = Object.values(this.#addressesByWalletAccount).flat()
 
-    if (!addressesArr.length) {
+    if (addressesArr.length === 0) {
       this.#logWsStatus('no addressesArr to subscribe')
       return
     }
@@ -167,7 +170,7 @@ export class Monitor extends BaseMonitor {
         )
       }
 
-      if (txsToUpdate.length) {
+      if (txsToUpdate.length > 0) {
         await this.updateTxLog({ assetName, walletAccount, logItems: txsToUpdate })
         if (utxos && ['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) {
           const unconfirmedTxAncestor = await resolveUnconfirmedAncestorData({
@@ -177,6 +180,7 @@ export class Monitor extends BaseMonitor {
           newData.mem = { unconfirmedTxAncestor }
         }
       }
+
       await aci.updateAccountState({
         assetName,
         walletAccount,
@@ -202,10 +206,12 @@ export class Monitor extends BaseMonitor {
     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 {
@@ -221,16 +227,11 @@ export class Monitor extends BaseMonitor {
     // wait for all wallet accounts to load
     await aci.getWalletAccounts({ assetName })
 
-    const {
-      txsToAdd,
-      txsToUpdate,
-      utxos,
-      ordinalsUtxos,
-      changedUnusedAddressIndexes,
-    } = await this.#scanner.rescanBlockchainInsight({
-      walletAccount,
-      refresh,
-    })
+    const { txsToAdd, txsToUpdate, utxos, ordinalsUtxos, changedUnusedAddressIndexes } =
+      await this.#scanner.rescanBlockchainInsight({
+        walletAccount,
+        refresh,
+      })
 
     const newData = {}
     if (utxos || ordinalsUtxos)
@@ -256,7 +257,7 @@ export class Monitor extends BaseMonitor {
 
     const txs = [...txsToUpdate, ...txsToAdd]
 
-    if (txs.length) {
+    if (txs.length > 0) {
       await this.updateTxLog({
         assetName,
         logItems: txs,

package/src/tx-log/ordinals-indexer-utils.js

@@ -26,6 +26,8 @@ export const indexOutputs = ({ tx, currency }) => {
       .map((i) => ({ ...i, offset: i.offset.sub(outputOffset).toBaseNumber() }))
     outputOffset = outputOffset.add(value)
   }
+
+  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
   tx.inscriptionsMemoryIndexed = true // avoids btc being spent even when the mempool index was done in memory
   return tx
 }
@@ -35,6 +37,7 @@ export const cachedIndexOrdinalUnconfirmedTx = memoizeLruCache(
     if (tx.inscriptionsIndexed || tx.inscriptionsMemoryIndexed) {
       return tx
     }
+
     const copyTx = cloneDeep(tx)
     await Promise.all(
       copyTx.vin.map(async (vin) => {
@@ -46,6 +49,8 @@ export const cachedIndexOrdinalUnconfirmedTx = memoizeLruCache(
         if (!outputTx.inscriptionsIndexed && !outputTx.inscriptionsMemoryIndexed) {
           throw new Error(`Cannot index ${tx.txid}. Input tx ${outputTx.txid} is not indexed. `)
         }
+
+        // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
         vin.inscriptions = outputTx.vout[vin.vout].inscriptions
       })
     )
@@ -59,6 +64,7 @@ export const indexOrdinalUnconfirmedTx = ({ insightClient, currency, tx }) => {
   if (tx.inscriptionsIndexed) {
     return tx
   }
+
   return cachedIndexOrdinalUnconfirmedTx({
     insightClient,
     currency,

package/src/tx-send/dogecoin.js

@@ -3,10 +3,10 @@ export function createInputs(utxos) {
     txId: utxo.txId,
     vout: utxo.vout,
     address: utxo.address.toString(),
-    value: utxo.value._number.toArrayLike(Buffer, 'le', 8),
+    value: utxo.value.toBaseBufferLE(8),
   }))
 }
 
 export function createOutput(address, sendAmount) {
-  return [address, sendAmount._number.toArrayLike(Buffer, 'le', 8)]
+  return [address, sendAmount.toBaseBufferLE(8)]
 }