@exodus/ethereum-api 2.8.2 → 2.8.4

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

@@ -0,0 +1,271 @@
+/* @flow */
+import { getServer } from '@exodus/ethereum-api'
+import {
+  type PendingTransactionsDictionary,
+  checkPendingTransactions,
+  getAllLogItemsByAsset,
+  getDeriveDataNeededForTick,
+  getDeriveTransactionsToCheck,
+  getHistoryFromServer,
+  isRpcBalanceAsset,
+  getAssetAddresses,
+} from '@exodus/ethereum-lib'
+
+import {
+  enableWSUpdates,
+  subscribeToGasPriceNotifications,
+  subscribeToWSNotifications,
+} from './ws-updates'
+
+import { isEmpty } from 'lodash'
+
+import { type Tx } from '@exodus/models'
+
+import { BaseMonitor } from '@exodus/asset-lib'
+
+export type { AssetSource } from '@exodus/models/lib/types'
+
+type DerivedData = {
+  ourWalletAddress: string,
+  currentAccountState: Object,
+  minimumConfirmations: number,
+  unconfirmedTransactions: PendingTransactionsDictionary,
+  pendingTransactionsGroupedByAddressAndNonce: PendingTransactionsDictionary,
+  simulatedTransactions: any,
+}
+// The base ethereum monitor class handles listening for, fetching,
+// formatting, and populating-to-state all ETH/ETC/ERC20 transactions.
+
+export class EthereumMonitor extends BaseMonitor {
+  constructor({ server, config, ...args }) {
+    super(args)
+    this.server = server || getServer(this.asset)
+    this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
+    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
+    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
+      getTxLog: (...args) => this.aci.getTxLog(...args),
+    })
+    this.subscribedToWalletAccountNotificationsMap = new Map()
+    this.addHook('before-start', (...args) => this.beforeStart(...args))
+    this.addHook('after-stop', (...args) => this.afterStop(...args))
+    this.subscribedToGasPriceMap = new Map()
+  }
+
+  setServer(config = {}) {
+    if (config.serverv1 && this.server.getURL() !== config.serverv1) {
+      this.server.setURL(config.serverv1)
+    }
+  }
+
+  async deriveData({ assetSource, tokens }: Object): DerivedData {
+    const { asset: assetName, walletAccount } = assetSource
+
+    const {
+      ourWalletAddress,
+      currentAccountState,
+      minimumConfirmations,
+    } = await this.deriveDataNeededForTick({ assetName, walletAccount })
+    const transactionsToCheck = await this.deriveTransactionsToCheck({
+      assetName,
+      walletAccount,
+      tokens,
+      ourWalletAddress,
+    })
+
+    return {
+      ourWalletAddress,
+      currentAccountState,
+      minimumConfirmations,
+      ...transactionsToCheck,
+    }
+  }
+
+  // eslint-disable-next-line no-undef
+  async checkPendingTransactions(params): { txsToRemove: { tx: Tx, assetSource: AssetSource }[] } {
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+    } = checkPendingTransactions(params)
+    const txsToRemove = []
+    const {
+      assetSource: { walletAccount },
+    } = params
+
+    const updateTx = (tx, asset, { error, remove }) => {
+      if (remove) {
+        txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else {
+        params.logItemsByAsset[asset].push({
+          ...tx,
+          dropped: true,
+          error,
+        })
+      }
+
+      // in case this is an ETH fee tx that has associated ERC20 send txs
+      const promises = tx.tokens.map(async (assetName) => {
+        const tokenTxSet = await this.aci.getTxLog({ assetName, walletAccount })
+        if (remove) {
+          txsToRemove.push({
+            tx: tokenTxSet.get(tx.txId),
+            assetSource: { asset: assetName, walletAccount },
+          })
+        } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
+          params.logItemsByAsset[assetName].push({
+            ...tokenTxSet.get(tx.txId),
+            error,
+            dropped: true,
+          })
+        }
+      })
+      return Promise.all(promises)
+    }
+
+    for (const { tx, assetName, replaced = false } of Object.values(
+      pendingTransactionsGroupedByAddressAndNonce
+    )) {
+      if (replaced) {
+        await updateTx(tx, assetName, { remove: true })
+        delete pendingTransactionsToCheck[tx.txId]
+      }
+    }
+
+    for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
+      if (params.refresh) await updateTx(tx, assetName, { remove: true })
+      else await updateTx(tx, assetName, { error: 'Dropped' })
+    }
+
+    return {
+      txsToRemove,
+    }
+  }
+
+  async tick({ refresh, walletAccount }) {
+    await this._subscribeToWSNotifications() // checks if it's a new walletAccount
+
+    const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
+    const tokens = Object.values(assets).filter((asset) => asset.baseAsset.name !== asset.name)
+    const tokensByAddress = tokens.reduce((map, token) => {
+      const addresses = getAssetAddresses(token)
+      for (const address of addresses) map.set(address.toLowerCase(), token)
+      return map
+    }, new Map())
+    const assetSource = { asset: this.asset.name, walletAccount }
+
+    const derivedData = await this.deriveData({ assetSource, tokens })
+
+    const { allTransactionsFromServer, index } = await getHistoryFromServer({
+      server: this.server,
+      ourWalletAddress: derivedData.ourWalletAddress,
+      minimumConfirmations: derivedData.minimumConfirmations,
+      index: refresh ? 0 : derivedData.currentAccountState?.index ?? 0,
+    })
+
+    const logItemsByAsset = getAllLogItemsByAsset({
+      ourWalletAddress: derivedData.ourWalletAddress,
+      allTransactionsFromServer,
+      asset: this.asset,
+      tokensByAddress,
+      assets,
+    })
+
+    const { txsToRemove } = await this.checkPendingTransactions({
+      txlist: allTransactionsFromServer,
+      assetSource,
+      refresh,
+      logItemsByAsset,
+      asset: this.asset,
+      ...derivedData,
+    })
+
+    const accountState = await this.getNewAccountState({
+      tokens,
+      ourWalletAddress: derivedData.ourWalletAddress,
+    })
+    await this.updateAccountState({ newData: { index, ...accountState }, walletAccount })
+
+    await this.removeFromTxLog(txsToRemove)
+    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
+  }
+
+  async updateGasPrice(newGasPrice) {
+    try {
+      const feeConfig = { gasPrice: `${parseInt(newGasPrice, 16)} wei` }
+      this.logger.debug(`Update ${this.asset.name} gas price: ${feeConfig.gasPrice}`)
+      await this.aci.updateFeeConfig({ assetName: this.asset.name, feeConfig })
+    } catch (e) {
+      this.logger.warn('error updating gasPrice', e)
+    }
+  }
+
+  async getNewAccountState({ tokens, ourWalletAddress }) {
+    const asset = this.asset
+    const newAccountState = {}
+    const server = this.server
+    if (isRpcBalanceAsset(asset)) {
+      const { confirmed } = await server.getBalance(ourWalletAddress)
+      newAccountState.balance = asset.currency.baseUnit(confirmed.value)
+    }
+    const tokenBalances = Object.assign(
+      {},
+      ...(await Promise.all(
+        tokens
+          .filter((token) => isRpcBalanceAsset(token) && token.contract.address)
+          .map(async (token) => {
+            const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
+            const value = confirmed[token.contract.address]
+            const balance = token.currency.baseUnit(value || 0)
+            return { [token.name]: balance }
+          })
+      ))
+    )
+    if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
+    return newAccountState
+  }
+
+  async getReceiveAddressesByWalletAccount() {
+    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
+    const addressesByAccount = {}
+    for (const walletAccount of walletAccounts) {
+      addressesByAccount[walletAccount] = await this.aci.getReceiveAddresses({
+        assetName: this.asset.name,
+        walletAccount,
+      })
+    }
+    return addressesByAccount
+  }
+
+  async _subscribeToWSNotifications() {
+    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
+    subscribeToWSNotifications({
+      addressesByWalletAccount,
+      tick: (...args) => this.tick(...args),
+      server: this.server,
+    })
+  }
+
+  async beforeStart() {
+    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
+    enableWSUpdates({
+      interval: this.interval,
+      server: this.server,
+      timer: this.timer,
+      tick: (...args) => this.tick(...args),
+      tickAllWalletAccounts: () => this.tickAllWalletAccounts(),
+      addressesByWalletAccount,
+      beforeStart: true,
+    })
+
+    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
+      subscribeToGasPriceNotifications({
+        server: this.server,
+        updateGasPrice: (newGasPrice) => this.updateGasPrice(newGasPrice),
+        subscribedToGasPriceMap: this.subscribedToGasPriceMap,
+      })
+    }
+  }
+
+  async afterStop() {
+    await this.server.stop()
+  }
+}

package/src/tx-log/index.js

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

package/src/tx-log/ws-updates.js

@@ -0,0 +1,75 @@
+import ms from 'ms'
+
+const subscribedToAddressNotificationsMap = new Map()
+
+const UPDATE_LOOP_INTERVAL = ms('5m')
+
+export function subscribeToWSNotifications({
+  addressesByWalletAccount,
+  tick,
+  getState,
+  server,
+  beforeStart = false,
+}) {
+  Object.entries(addressesByWalletAccount).forEach(([walletAccount, addresses]) => {
+    const address = String(Array.from(addresses)[0]).toLowerCase() // Only check m/0/0
+    const mapKey = `${server.getURL()}:${address}` // different chains might have the same addresses
+    if (subscribedToAddressNotificationsMap.has(mapKey)) return
+
+    server.ws.watch(address)
+    server.ws.events.on(`address-${address}`, () => {
+      tick({ refresh: false, getState, walletAccount })
+    })
+    subscribedToAddressNotificationsMap.set(mapKey, true)
+    if (!beforeStart) {
+      // tick for a new wallet account
+      tick({ refresh: false, getState, walletAccount })
+    }
+  })
+}
+
+export function subscribeToGasPriceNotifications({
+  server,
+  updateGasPrice,
+  subscribedToGasPriceMap,
+}) {
+  const mapKey = server.getURL()
+  if (subscribedToGasPriceMap.has(mapKey)) return
+  server.ws.events.on('gasprice', updateGasPrice)
+  subscribedToGasPriceMap.set(mapKey, true)
+}
+
+export function enableWSUpdates({
+  interval,
+  server,
+  timer,
+  dispatch,
+  getState,
+  tickAllWalletAccounts,
+  tick,
+  addressesByWalletAccount,
+  beforeStart = false,
+}) {
+  const defaultInterval = interval
+
+  subscribeToWSNotifications({
+    server,
+    getState,
+    beforeStart,
+    tick,
+    addressesByWalletAccount,
+  })
+
+  server.ws.events.on('open', () => {
+    if (timer.isRunning) {
+      timer.setNewInterval(UPDATE_LOOP_INTERVAL)
+    }
+  })
+  server.ws.events.on('close', async () => {
+    if (timer.isRunning) {
+      await timer.setNewInterval(defaultInterval)
+      return tickAllWalletAccounts({ dispatch, getState })
+    }
+  })
+  server.ws.open()
+}

package/src/websocket/index.js

@@ -1,3 +1,23 @@
-import WebSocket from 'ws'
-
-export default WebSocket
+/**
+ * This is a "light" version of @exodus/core resolution to select the native WebSocket on BE
+ * It's a workaround until https://github.com/ExodusMovement/assets/pull/72 is merged.
+ *
+ * Based on https://github.com/ExodusMovement/fetch/blob/master/core.js , note that chooses native on Desktop
+ */
+if (
+  typeof process !== 'undefined' &&
+  process &&
+  (process.type === 'renderer' || process.type === 'worker')
+) {
+  // THIS IS FOR DESKTOP
+  module.exports = require('ws')
+} else {
+  // eslint-disable-next-line no-undef
+  if (global.window?.WebSocket) {
+    // THIS IS FOR BE
+    module.exports = global.window?.WebSocket
+  } else {
+    // THIS IS FOR UNIT TESTING.
+    module.exports = require('ws')
+  }
+}