@exodus/bitcoin-api 1.0.0-alpha.0

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

@@ -0,0 +1,231 @@
+import assert from 'minimalistic-assert'
+import { isEmpty, isEqual } from 'lodash'
+
+import { BaseMonitor } from '@exodus/asset-lib'
+import InsightWSClient from '../insight-api-client/ws'
+import { updateUnconfirmedAncestorData } from '../unconfirmed-ancestor-data'
+import { rescanBlockchainInsight } from './bitcoin-monitor-scanner'
+import { normalizeInsightConfig, toWSUrl } from '../insight-api-client/util'
+import ms from 'ms'
+
+// NOTE: this is a frankenstein mashup of Exodus desktop
+// assets-refresh/insight action + Neo monitor
+
+export class Monitor extends BaseMonitor {
+  #addressesByWalletAccount
+  #runningByWalletAccount
+  #wsInterval
+  #ws
+  #apiUrl
+  #wsUrl
+  #insightClient
+  #yieldToUI
+  #isIos
+
+  constructor({
+    asset,
+    interval = ms('45s'),
+    wsInterval = ms('5m'),
+    assetClientInterface,
+    runner,
+    yieldToUI,
+    logger,
+    flux,
+    insightClient,
+    apiUrl,
+    isIos,
+  }) {
+    super({ asset, interval, assetClientInterface, logger, runner })
+    assert(insightClient, 'insightClient is required!')
+    assert(apiUrl, 'apiUrl is required')
+    assert(yieldToUI, 'yieldToUI is required!')
+    this.#wsInterval = wsInterval
+    this.#ws = null
+    this.#apiUrl = apiUrl
+    this.#yieldToUI = yieldToUI
+    this.#wsUrl = null
+    this.#runningByWalletAccount = {}
+    this.#addressesByWalletAccount = {}
+    this.#insightClient = insightClient
+    this.#isIos = isIos
+    this.addHook('after-tick-multiple-wallet-accounts', () => this.#subscribeToNewAddresses())
+  }
+
+  setServer(assetConfig = {}) {
+    const { apiUrl, wsUrl } = normalizeInsightConfig(assetConfig)
+    if (apiUrl) {
+      this.#insightClient.setBaseUrl(apiUrl)
+    }
+    if (!this.#wsUrl || this.#wsUrl !== wsUrl) {
+      this.#connectWS(wsUrl || this.#wsUrl || toWSUrl(this.#apiUrl))
+    }
+  }
+
+  #getReceiveAddressesByWalletAccount = async () => {
+    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
+    return Object.fromEntries(
+      await Promise.all(
+        walletAccounts.map(async (walletAccount) => [
+          walletAccount,
+          await this.aci.getReceiveAddresses({
+            multiAddressMode: true,
+            assetName: this.asset.name,
+            walletAccount,
+          }),
+        ])
+      )
+    )
+  }
+
+  #connectWS = async (wsUrl) => {
+    const aci = this.aci
+    if (this.#ws) {
+      this.#ws.close()
+      this.#ws = null
+    }
+    this.#wsUrl = wsUrl
+    if (!wsUrl) {
+      return
+    }
+
+    this.#addressesByWalletAccount = await this.#getReceiveAddressesByWalletAccount()
+
+    const addressesArr = Object.values(this.#addressesByWalletAccount).flat()
+
+    if (!addressesArr.length) {
+      this.#logWsStatus('no addressesArr to subscribe')
+      return
+    }
+
+    this.#ws = new InsightWSClient(wsUrl, this.asset.name)
+    this.#ws.connect(addressesArr)
+    this.#ws.on('connect', () => {
+      this.#logWsStatus('connect to addresses', addressesArr)
+      this.timer.setNewInterval(this.#wsInterval)
+    })
+    this.#ws.on('message', ({ address }) => {
+      const walletAccount = Object.keys(this.#addressesByWalletAccount).find((walletAccount) =>
+        this.#addressesByWalletAccount[walletAccount].includes(address)
+      )
+      this.tickWalletAccounts({ walletAccount })
+    })
+    this.#ws.on('block', async () => {
+      await this.#yieldToUI(100)
+      const assetName = this.asset.name
+
+      const walletAccounts = await aci.getWalletAccounts({ assetName })
+      for (const walletAccount of walletAccounts) {
+        const currentTxs = Array.from(await aci.getTxLog({ assetName, walletAccount }))
+        const statuses = await Promise.all(
+          currentTxs.map(async (tx) => {
+            if (tx.dropped || (tx.confirmations && tx.confirmations > 0)) return null
+            const txStatus = await this.#insightClient.fetchTx(tx.txId)
+            if (!txStatus) return null
+            if (txStatus.confirmations <= 0) return null
+            return { txId: tx.txId, confirmations: txStatus.confirmations }
+          })
+        ).then((res) => res.filter((status) => !!status))
+        await aci.updateTxLog({ assetName, walletAccount, txs: statuses })
+
+        const accountState = await aci.getAccountState({ assetName, walletAccount })
+
+        const utxos = accountState.utxos.updateConfirmations(statuses)
+        await aci.updateAccountState({ accountState, assetName, walletAccount, newData: { utxos } })
+
+        if (['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) {
+          updateUnconfirmedAncestorData({
+            asset: this.asset,
+            walletAccount,
+            accountState,
+            insightClient: this.#insightClient,
+          })
+        }
+      }
+    })
+    this.#ws.on('disconnect', () => {
+      this.#logWsStatus('disconnect')
+      this.timer.setNewInterval(this.interval)
+    })
+    this.#ws.on('reconnect', () => {
+      this.#logWsStatus('reconnect')
+      this.tickWalletAccounts()
+    })
+  }
+
+  #subscribeToNewAddresses = async () => {
+    const newAddressesByWalletAccount = await this.#getReceiveAddressesByWalletAccount()
+    if (!isEqual(newAddressesByWalletAccount, this.#addressesByWalletAccount)) {
+      await this.#connectWS(this.#wsUrl)
+    }
+  }
+
+  tick = async ({ walletAccount, refresh }) => {
+    assert(walletAccount, 'walletAccount is expected')
+    if (this.#runningByWalletAccount[walletAccount]) return
+    this.#runningByWalletAccount[walletAccount] = true
+    try {
+      await this.#syncWalletAccount({ walletAccount, refresh })
+    } finally {
+      delete this.#runningByWalletAccount[walletAccount]
+    }
+  }
+
+  #syncWalletAccount = async ({ walletAccount, refresh }) => {
+    const aci = this.aci
+    const assetName = this.asset.name
+    // wait for all wallet accounts to load
+    await aci.getWalletAccounts({ assetName })
+
+    const {
+      txsToAdd,
+      txsToUpdate,
+      utxos,
+      changedUnusedAddressIndexes,
+    } = await rescanBlockchainInsight({
+      asset: this.asset,
+      walletAccount,
+      refresh,
+      assetClientInterface: aci,
+      insightClient: this.#insightClient,
+      yieldToUI: this.#yieldToUI,
+      isIos: this.#isIos,
+    })
+    const accountState = await aci.getAccountState({ assetName, walletAccount })
+
+    if (utxos) await aci.updateAccountState({ assetName, walletAccount, newData: { utxos } })
+
+    if (!isEmpty(changedUnusedAddressIndexes)) {
+      // Only for mobile atm, browser and hydra calculates from the latest txLogs
+      await aci.saveUnusedAddressIndexes({
+        assetName,
+        walletAccount,
+        changedUnusedAddressIndexes,
+      })
+    }
+
+    const txs = [...txsToUpdate, ...txsToAdd]
+
+    if (txs.length) {
+      await this.updateTxLog({
+        assetName,
+        logItems: txs,
+        walletAccount,
+        refresh,
+      })
+    }
+
+    // Move to after tick
+    if (['bitcoin', 'bitcoinregtest', 'bitcointestnet'].includes(assetName)) {
+      updateUnconfirmedAncestorData({
+        asset: this.asset,
+        walletAccount,
+        accountState,
+        insightClient: this.#insightClient,
+      })
+    }
+  }
+
+  #logWsStatus = (message, ...args) => {
+    // console.debug('btc-like monitor', this.asset.name, message, ...args)
+  }
+}

package/src/tx-log/index.js

@@ -0,0 +1 @@
+export * from './bitcoin-monitor'

package/src/unconfirmed-ancestor-data.js

@@ -0,0 +1,51 @@
+import { getUtxos } from './utxos-utils'
+
+const dataMap = new Map()
+
+export async function updateUnconfirmedAncestorData({
+  asset,
+  walletAccount,
+  accountState,
+  insightClient,
+}) {
+  for (const [txId, stored] of dataMap) {
+    if (stored.walletAccount === walletAccount) dataMap.delete(txId)
+  }
+
+  const utxos = getUtxos({ accountState, asset })
+    .toArray()
+    .filter((data) => {
+      return !data.confirmations || data.confirmations <= 0
+    })
+  const txIds = new Set(utxos.map(({ txId }) => txId))
+  for (const txId of txIds) {
+    try {
+      const { size, fees } = await insightClient.fetchUnconfirmedAncestorData(txId)
+      if (size !== 0) {
+        dataMap.set(txId, { assetName: asset.name, walletAccount, size, fees })
+      }
+    } catch (e) {
+      console.warn(e)
+    }
+  }
+}
+
+function getUnconfirmedAncestorData({ txId, assetName }) {
+  const stored = dataMap.get(txId)
+  if (stored?.assetName === assetName) {
+    return { size: stored.size, fees: stored.fees }
+  }
+  return undefined
+}
+
+export function resolveExtraFeeOfTx({ assetName, feeRate, txId }) {
+  const data = getUnconfirmedAncestorData({ assetName, txId })
+  if (!data) return 0
+  const { fees, size } = data
+  // Get the difference in fee rate between ancestors and current estimate
+  const feeRateDiff = feeRate - fees / size
+  // If the diff is negative, ancestors already pay more than current estimate
+  if (feeRateDiff <= 0) return 0
+  // Calculate enough fee to bring the fee rate of ancestors to current estimate
+  return feeRateDiff * size
+}

package/src/utxos-utils.js

@@ -0,0 +1,15 @@
+import { UtxoCollection } from '@exodus/models'
+
+export function getUtxos({ accountState, asset }) {
+  return (
+    accountState?.utxos ||
+    UtxoCollection.createEmpty({
+      currency: asset.currency,
+    })
+  )
+}
+
+export function getBalances({ asset, accountState }) {
+  const balance = getUtxos({ asset, accountState }).value
+  return balance.isZero ? null : { balance }
+}