@exodus/ethereum-api 2.8.2 → 2.8.3

package/src/tx-log/__tests__/in-memory-asset-client-interface.js

@@ -0,0 +1,196 @@
+import { pickBy, isEmpty, partition, isObject, bindAll, functions } from 'lodash'
+import assert from 'minimalistic-assert'
+import { Tx, TxSet } from '@exodus/models'
+import { EventEmitter } from 'events'
+
+const getKey = ({ assetName, walletAccount }) => `${walletAccount}:${assetName}`
+const getAssetOnlyKey = ({ assetName }) => assetName
+
+const createTxSet = ({ txs, coinName, assets }) => {
+  const values = txs.map((tx) => Tx.fromJSON({ ...tx, date: tx.date || new Date(), coinName }))
+  return TxSet.fromArray(values, { assets })
+}
+
+const createBatch = () => {
+  const batch = []
+  const push = (promise) => batch.push(promise)
+  const exec = async () => {
+    // enforce sequential execution
+    for (const promise in batch) {
+      await promise
+    }
+  }
+  return { push, exec }
+}
+
+export class InMemoryAssetClientInterface extends EventEmitter {
+  constructor({ assets, logger, walletAccounts, wallet }) {
+    super()
+    assert(assets, 'assets is required')
+    assert(logger, 'logger is required')
+    assert(walletAccounts, 'walletAccounts is required')
+    assert(wallet, 'wallet is required')
+    assert(isObject(assets), 'assets must be an object indexed by asset name')
+    this.assets = assets
+    this.logger = logger
+    this.wallet = wallet
+    this.feeData = Object.values(assets)
+      .filter((asset) => asset.name === asset.baseAsset.name)
+      .filter((asset) => asset.api?.getFeeData)
+      .reduce((acc, asset) => ({ ...acc, [asset.name]: asset.api.getFeeData() }), {})
+    this.walletAccounts = walletAccounts
+    this.txs = {}
+    this.states = {}
+    bindAll(this, functions(this))
+  }
+
+  async getTxLog({ assetName, walletAccount }) {
+    const key = getKey({ assetName, walletAccount })
+    if (!this.txs[key]) {
+      return TxSet.EMPTY
+    }
+    return this.txs[key]
+  }
+
+  async updateTxLogAndNotify({ assetName, walletAccount, txs }) {
+    const batch = this.updateTxLogAndNotifyBatch({
+      assetName,
+      walletAccount,
+      txs,
+    })
+    return batch.exec()
+  }
+
+  updateTxLogAndNotifyBatch({ assetName, walletAccount, txs, batch = createBatch() }) {
+    batch.push(this.updateTxs({ assetName, walletAccount, txs }))
+    return batch
+  }
+
+  async updateTxs({ assetName, walletAccount, txs }) {
+    const currentTxLog = await this.getTxLog({ assetName, walletAccount })
+    const [existingLogItems, newLogItems] = partition(txs, (v) => currentTxLog.get(v.txId))
+    let newTxSet = currentTxLog
+    if (existingLogItems.length > 0) {
+      newTxSet = newTxSet.updateTxsProperties(existingLogItems)
+    }
+    if (newLogItems.length > 0) {
+      newTxSet = newTxSet.union(
+        createTxSet({ txs: newLogItems, coinName: assetName, assets: this.assets })
+      )
+    }
+    const key = getKey({ assetName, walletAccount })
+    if (newTxSet.size > 0) {
+      this.txs[key] = newTxSet
+    }
+  }
+
+  async getAccountState({ assetName, walletAccount }) {
+    const asset = this.assets[assetName]
+    const key = getKey({ assetName, walletAccount })
+
+    if (!this.states[key]) {
+      const accountState = asset.api?.createAccountState?.()?.create()
+      if (!accountState) {
+        throw new Error(`Asset ${asset.name} does not support account state!`)
+      }
+      this.states[key] = accountState
+    }
+    return this.states[key]
+  }
+
+  async updateAccountState({ assetName, walletAccount, newData }) {
+    this.updateAccountStateBatch({
+      assetName,
+      walletAccount,
+      newData,
+    }).exec()
+  }
+
+  updateAccountStateBatch({ assetName, walletAccount, newData, batch = createBatch() }) {
+    batch.push(
+      this._basicUpdateAccountState({
+        assetName,
+        walletAccount,
+        newData,
+      })
+    )
+    return batch
+  }
+
+  async _basicUpdateAccountState({ assetName, walletAccount, newData }) {
+    if (!isEmpty(newData)) {
+      const key = getKey({ assetName, walletAccount })
+      const currentAccountState = await this.getAccountState({ assetName, walletAccount })
+      const newAccountState = currentAccountState.merge(newData)
+      this.states[key] = newAccountState
+    }
+  }
+
+  async getReceiveAddresses({ assetName, walletAccount, chainIndex, addressIndex }) {
+    return [await this.getReceiveAddress({ assetName, walletAccount, chainIndex, addressIndex })]
+  }
+
+  async getReceiveAddress({ assetName, walletAccount, chainIndex, addressIndex }) {
+    const asset = this.assets[assetName]
+    const baseAsset = asset.baseAsset
+    assert(this.walletAccounts[walletAccount], 'Invalid walletAccount')
+    const accountIndex = this.walletAccounts[walletAccount].index
+    const { publicKey } = await this.wallet.genPublicKey({
+      baseAssetName: baseAsset.name,
+      accountIndex,
+      chainIndex,
+      addressIndex,
+    })
+    return asset.keys.encodePublic(publicKey).toString()
+  }
+
+  async getWalletAccountsByAsset() {
+    const baseAssets = Object.values(this.assets).filter(
+      (asset) => asset.name === asset.baseAsset.name
+    )
+    const walletAccountMap = {}
+    for (const baseAsset of baseAssets) {
+      walletAccountMap[baseAsset.name] = Object.keys(this.walletAccounts)
+    }
+    return walletAccountMap
+  }
+
+  async getWalletAccounts({ assetName }) {
+    const walletAccountMap = await this.getWalletAccountsByAsset()
+    const walletAccounts = walletAccountMap[assetName]
+    assert(walletAccounts, `${assetName} is not supported`)
+    return walletAccounts
+  }
+
+  async getAssetsForNetwork({ baseAssetName }) {
+    return pickBy(this.assets, (asset) => asset.baseAsset.name === baseAssetName)
+  }
+
+  async fetchToken({ assetId, baseAssetName }) {
+    throw new Error('implement!')
+  }
+
+  async addToken({ assetId, baseAssetName, allowedStatusList }) {
+    throw new Error('Implement!')
+  }
+
+  async getConfirmationsNumber({ assetName }) {
+    const baseAsset = this.assets[assetName].baseAsset
+    return baseAsset.api?.getConfirmationsNumber ? baseAsset.api.getConfirmationsNumber() : 1
+  }
+
+  async getFeeData({ assetName }) {
+    const feeData = this.feeData[getAssetOnlyKey({ assetName })]
+    if (!feeData) {
+      throw new Error(`Asset ${assetName} does not support fee data`)
+    }
+    return feeData
+  }
+
+  async updateFeeConfig({ assetName, feeConfig }) {
+    const currentFeeData = await this.getFeeData({ assetName })
+    const newFeeData = currentFeeData.update(feeConfig)
+    this.feeData[getAssetOnlyKey({ assetName })] = newFeeData
+    this.emit('fee-config-updated')
+  }
+}

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')
+  }
+}