@exodus/ethereum-api 9.0.2 → 10.0.0

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

@@ -1,351 +0,0 @@
-import { BaseMonitor } from '@exodus/asset-lib'
-import { getAssetAddresses } from '@exodus/ethereum-lib'
-import lodash from 'lodash'
-
-import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
-import { fromHexToString } from '../number-utils.js'
-import {
-  checkPendingTransactions,
-  excludeUnchangedTokenBalances,
-  getAllLogItemsByAsset,
-  getDeriveDataNeededForTick,
-  getDeriveTransactionsToCheck,
-  getHistoryFromServer,
-  getLogItemsFromServerTx,
-  isUnverifiablePendingTxExpired,
-  verifyRpcPendingTxStatusBatch,
-} from './monitor-utils/index.js'
-import {
-  enableWSUpdates,
-  subscribeToGasPriceNotifications,
-  subscribeToWSNotifications,
-} from './ws-updates.js'
-
-const { isEmpty } = lodash
-
-// 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, rpcBalanceAssetNames, webSocketEnabled = true, ...args }) {
-    super(args)
-    this.server = server
-    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()
-    this._webSocketEnabled = webSocketEnabled
-    this.rpcBalanceAssetNames = rpcBalanceAssetNames
-  }
-
-  setServer(config = {}) {
-    const uri = config?.serverv1 || this.server.defaultUri
-
-    if (uri === this.server.getURL()) {
-      return
-    }
-
-    this.server.setURL(uri)
-  }
-
-  async deriveData({ assetSource, tokens }) {
-    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) {
-    const {
-      pendingTransactionsToCheck,
-      pendingTransactionsGroupedByAddressAndNonce,
-      recentPendingTransactions,
-    } = checkPendingTransactions(params)
-    const txsToRemove = []
-    const {
-      assetSource: { walletAccount },
-    } = params
-
-    const updateTx = (tx, asset, { isTxConfirmed, remove, preserve }) => {
-      if (remove) {
-        txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
-      } else if (preserve) {
-        params.logItemsByAsset[asset].push(tx)
-      } else {
-        params.logItemsByAsset[asset].push({
-          ...tx,
-          ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-        })
-      }
-
-      // 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)) {
-          // Optional: the stored tx may name a token since removed from the registry
-          params.logItemsByAsset[assetName]?.push(
-            preserve
-              ? tokenTxSet.get(tx.txId)
-              : {
-                  ...tokenTxSet.get(tx.txId),
-                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-                }
-          )
-        }
-      })
-
-      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]
-        delete recentPendingTransactions[tx.txId]
-      }
-    }
-
-    // Batch verify all pending txs with a single RPC call
-    const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = await verifyRpcPendingTxStatusBatch({
-      server: this.server,
-      logger: this.logger,
-      txIds,
-    })
-
-    for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
-      const txStatus = statuses[tx.txId]
-      if (txStatus?.status === 'confirmed') {
-        await updateTx(tx, assetName, { isTxConfirmed: true })
-      } else if (txStatus?.status === 'dropped') {
-        if (params.refresh) {
-          await updateTx(tx, assetName, { remove: true })
-        } else {
-          await updateTx(tx, assetName, { isTxConfirmed: false })
-        }
-      } else if (params.refresh) {
-        // No txStatus at all means the whole verification batch failed - evidence
-        // about nothing, so preserve unconditionally; the age ceiling only applies
-        // to a per-entry 'unknown' verdict (evidence about that one hash).
-        if (!txStatus || txStatus.status === 'pending' || !isUnverifiablePendingTxExpired(tx)) {
-          // Still in the mempool (or not verifiable yet) but missing from the history
-          // server response: re-add it so the refresh overwrite cannot wipe it and
-          // break tx-log-based nonce resolution.
-          await updateTx(tx, assetName, { preserve: true })
-        } else {
-          // Unverifiable past the age ceiling: purge so a hash the node keeps
-          // erroring on cannot pin nonce derivation forever.
-          await updateTx(tx, assetName, { remove: true })
-        }
-      }
-      // non-refresh: 'pending' or unknown - tx still in mempool, do nothing
-    }
-
-    if (params.refresh) {
-      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
-      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
-        await updateTx(tx, assetName, { preserve: true })
-      }
-    }
-
-    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 derivedIndex = derivedData.currentAccountState?.index
-
-    const { allTransactionsFromServer, index } = await getHistoryFromServer({
-      server: this.server,
-      ourWalletAddress: derivedData.ourWalletAddress,
-      minimumConfirmations: derivedData.minimumConfirmations,
-      index: refresh ? 0 : (derivedIndex ?? 0),
-    })
-    const hasNewIndex = !derivedIndex || index > derivedIndex
-
-    const logItemsByAsset = getAllLogItemsByAsset({
-      getLogItemsFromServerTx,
-      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,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-
-    const newData = { ...accountState, ...(hasNewIndex && { index }) }
-    await this.updateAccountState({ newData, walletAccount })
-    await this.removeFromTxLog(txsToRemove)
-    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
-
-    if (refresh || hasNewIndex) {
-      const unknownTokenAddresses = this.getUnknownTokenAddresses({
-        transactions: allTransactionsFromServer,
-        tokensByAddress,
-      })
-      if (unknownTokenAddresses.length > 0) {
-        this.emit('unknown-tokens', unknownTokenAddresses)
-      }
-    }
-  }
-
-  async updateGasPrice(fetchedGasPrices) {
-    try {
-      await executeEthLikeFeeMonitorUpdate({
-        assetClientInterface: this.aci,
-        feeAsset: this.asset,
-        fetchedGasPrices,
-      })
-    } catch (e) {
-      this.logger.warn('error updating gasPrice', e)
-    }
-  }
-
-  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
-    const asset = this.asset
-    const newAccountState = Object.create(null)
-    const server = this.server
-    if (this.rpcBalanceAssetNames.includes(asset.name)) {
-      const result = await server.getBalanceProxied(ourWalletAddress)
-      const balance = fromHexToString(result)
-      newAccountState.balance = asset.currency.baseUnit(balance)
-    }
-
-    const tokenBalancePairs = await Promise.all(
-      tokens
-        .filter((token) => this.rpcBalanceAssetNames.includes(token.name) && token.contract.address)
-        .map(async (token) => {
-          const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
-          const value = token.currency.baseUnit(confirmed[token.contract.address] || 0)
-          return [token.name, value]
-        })
-    )
-
-    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalancePairs)
-    if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
-    return newAccountState
-  }
-
-  async getReceiveAddressesByWalletAccount() {
-    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
-    const addressesByAccount = Object.create(null)
-    for (const walletAccount of walletAccounts) {
-      addressesByAccount[walletAccount] = await this.aci.getReceiveAddresses({
-        assetName: this.asset.name,
-        walletAccount,
-        useCache: true,
-      })
-    }
-
-    return addressesByAccount
-  }
-
-  async _subscribeToWSNotifications() {
-    if (this._webSocketEnabled === false) return
-
-    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
-    subscribeToWSNotifications({
-      addressesByWalletAccount,
-      tick: (...args) => this.tick(...args),
-      server: this.server,
-    })
-  }
-
-  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
-    const set = transactions.reduce((acc, txn) => {
-      const transfers = txn.erc20 || []
-      transfers.forEach((transfer) => {
-        const addr = transfer.address.toLowerCase()
-        if (!tokensByAddress.has(addr)) {
-          acc.add(addr)
-        }
-      })
-      return acc
-    }, new Set())
-    return [...set]
-  }
-
-  async beforeStart() {
-    await this._enableWSUpdates()
-  }
-
-  async _enableWSUpdates() {
-    if (this._webSocketEnabled === false) return
-
-    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
-    enableWSUpdates({
-      interval: this.interval,
-      server: this.server,
-      timer: this.timer,
-      tick: (...args) => this.tick(...args),
-      tickWalletAccounts: () => this.tickWalletAccounts(),
-      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/monitor-utils/get-history-from-server.js

@@ -1,43 +0,0 @@
-import isConfirmedServerTx from './is-confirmed-server-tx.js'
-
-// Fetches JSON transaction history from the given Ethereum server
-// object (from @exodus/ethereum-api). Starts fetching from the given
-// block cursor and returns the latest cursor and all transactions
-// fetched in the process. minimumConfirmations determines how many
-// confirmations a transaction must have for the cursor to be moved
-// to that transaction's block.
-
-export default async function getHistoryFromServer({
-  server,
-  ourWalletAddress,
-  index,
-  minimumConfirmations,
-  limit = 1000,
-}) {
-  if (limit === 0) return []
-  const allTransactionsFromServer = []
-
-  let isEndOfAddressHistory = false
-  let newIndex = index
-  while (true) {
-    const transactions = await server.getHistoryV2(ourWalletAddress, {
-      index,
-      limit, // the server returns the number of TXs that's less or equal to the limit
-    })
-
-    if (transactions.length === 0) isEndOfAddressHistory = true
-    for (const transaction of transactions) {
-      allTransactionsFromServer.push(transaction)
-      index = transaction.addressIndex + 1 // this index is used to fetch a next page of TXs
-      if (transaction.confirmations >= minimumConfirmations) newIndex = transaction.addressIndex + 1 // this index is used to return from the function
-      if (!isConfirmedServerTx(transaction)) isEndOfAddressHistory = true
-    }
-
-    if (isEndOfAddressHistory) {
-      return {
-        allTransactionsFromServer,
-        index: newIndex,
-      }
-    }
-  }
-}

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -1,203 +0,0 @@
-import lodash from 'lodash'
-
-import getFeeAmount from './get-fee-amount.js'
-import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx.js'
-import getRawTransferAmount from './get-raw-transfer-amount.js'
-import getTransfersByTokenName from './get-transfers-by-token-name.js'
-import getValueOfTransfers from './get-value-of-transfers.js'
-import isConfirmedServerTx from './is-confirmed-server-tx.js'
-import isConsideredSentTokenTx from './is-considered-sent-token-tx.js'
-
-// This function takes a server transaction object fetched from magnifier,
-// and transforms it into Tx models to update the exodus state.
-
-const tryFindExternalRecipient = (transfers, ourWalletAddress) =>
-  transfers.find(({ to }) => to !== ourWalletAddress)?.to || ourWalletAddress
-
-function isSelfSendTx({
-  coinAmount,
-  ourWalletWasSender,
-  sendingTransferPresent,
-  receivingTransferPresent,
-}) {
-  return (
-    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
-  )
-}
-
-function isNftTransfer({ serverTx, ourWalletAddress }) {
-  if (!Array.isArray(serverTx.erc721) || serverTx.erc721.length === 0) return false
-
-  return serverTx.erc721.some(
-    (transfer) => transfer.to === ourWalletAddress || transfer.from === ourWalletAddress
-  )
-}
-
-export default function getLogItemsFromServerTx({
-  serverTx,
-  asset,
-  ourWalletAddress,
-  tokensByAddress,
-  assets,
-}) {
-  const confirmations = isConfirmedServerTx(serverTx) ? 1 : 0
-  const date = new Date(parseInt(serverTx.timestamp, 16) * 1000) // included even for unconfirmed txs
-  const txId = serverTx.hash
-  const nonce = parseInt(serverTx.nonce, 16)
-  const gasLimit = parseInt(serverTx.gas, 16)
-  const error = serverTx.error || (serverTx.status === false ? 'Failed' : null)
-  const feeAmount = getFeeAmount(asset, serverTx)
-  const ethereumTransfers = [serverTx, ...(serverTx.internal || [])]
-  const tokenTransfersByTokenName = getTransfersByTokenName(serverTx.erc20 || [], tokensByAddress)
-  const toAddress = tryFindExternalRecipient(ethereumTransfers, ourWalletAddress)
-  const ourWalletWasSender = serverTx.from === ourWalletAddress
-  const METHOD_ID_LENGTH = 10
-  const methodId = serverTx.data && {
-    methodId: serverTx.data.slice(0, Math.max(0, METHOD_ID_LENGTH)),
-  }
-  const data = serverTx.data || '0x'
-  const logItemCommonProperties = {
-    confirmations,
-    date,
-    error,
-    txId,
-    dropped: false,
-  }
-
-  const logItemsForServerTxEntries = []
-
-  {
-    const sendingTransferPresent = ethereumTransfers.some(({ from }) => from === ourWalletAddress)
-    const receivingTransferPresent = ethereumTransfers.some(({ to }) => to === ourWalletAddress)
-    const nftTransferPresent = isNftTransfer({ serverTx, ourWalletAddress })
-
-    if (sendingTransferPresent || receivingTransferPresent || nftTransferPresent) {
-      const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
-      // `rawCoinAmount` mirrors the field written by `getOptimisticTxLogEffects`
-      // and is consumed by the bump path (`tx-create.js`) to recover the
-      // user-signed on-chain `value` when accelerating a self-send (where
-      // `coinAmount` is zero). For the base-asset entry the raw amount is the
-      // top-level `value` field of the tx itself, not the sum of internal
-      // transfers — that's what the user signed and what we must restore on
-      // bump.
-      const rawCoinAmount = getRawTransferAmount({
-        ourWalletAddress,
-        asset,
-        transfers: [serverTx],
-      }).toBaseString()
-      const selfSend = isSelfSendTx({
-        coinAmount,
-        ourWalletWasSender,
-        sendingTransferPresent,
-        receivingTransferPresent,
-      })
-      let sent
-      if (sendingTransferPresent) {
-        sent = serverTx.internal
-          .map(({ from, to, value }) => {
-            if (from === ourWalletAddress) {
-              const amount = asset.currency.baseUnit(value).toDefaultString({ unit: true })
-              return { address: to, amount }
-            }
-          })
-          .filter(Boolean)
-      }
-
-      logItemsForServerTxEntries.push([
-        asset.name,
-        {
-          ...logItemCommonProperties,
-          coinAmount,
-          coinName: asset.name,
-          data: {
-            data,
-            nonce,
-            gasLimit,
-            rawCoinAmount,
-            ...methodId,
-            ...(sent?.length > 0 ? { sent } : undefined),
-          },
-          ...(ourWalletWasSender
-            ? { from: [], to: toAddress, feeAmount, feeCoinName: asset.feeAsset.name }
-            : { from: [serverTx.from] }),
-          selfSend,
-          tokens: getNamesOfTokensTransferredByServerTx({
-            asset,
-            tokensByAddress,
-            serverTx,
-            ourWalletAddress,
-          }),
-          currencies: {
-            [asset.name]: asset.currency,
-            [asset.feeAsset.name]: asset.feeAsset.currency,
-          },
-        },
-      ])
-    }
-  }
-
-  // handle erc20
-  Object.entries(tokenTransfersByTokenName).forEach(([tokenName, tokenTransfers]) => {
-    const sendingTransferPresent = tokenTransfers.some(({ from }) => from === ourWalletAddress)
-    const receivingTransferPresent = tokenTransfers.some(({ to }) => to === ourWalletAddress)
-    if (!sendingTransferPresent && !receivingTransferPresent) return
-
-    const token = assets[tokenName]
-    const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
-    // Transfers from this reader's server source are tagged with
-    // `events: true` once the tx is included in a block (event-log derived)
-    // and `events: false` while still pending (tx-data derived). Only one
-    // flavor is real for a given lifecycle state; filtering avoids
-    // double-counting if both ever coexist for the same transfer. Both
-    // `coinAmount` and `rawCoinAmount` must see the same set so they stay
-    // consistent.
-    const filteredTokenTransfers = lodash.filter(tokenTransfers, {
-      events: confirmations > 0,
-    })
-    const coinAmount = getValueOfTransfers(ourWalletAddress, token, filteredTokenTransfers)
-    // See base-entry comment above; for token entries the raw amount is the
-    // absolute total tokens our wallet moved in this tx (sum of outgoing, or
-    // incoming for receive-only entries).
-    const rawCoinAmount = getRawTransferAmount({
-      ourWalletAddress,
-      asset: token,
-      transfers: filteredTokenTransfers,
-    }).toBaseString()
-    const tokenFromAddresses = lodash.uniq(
-      tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
-    )
-
-    const isConsideredSent = isConsideredSentTokenTx({
-      coinAmount,
-      ourWalletWasSender,
-      sendingTransferPresent,
-      receivingTransferPresent,
-    })
-    const selfSend = isSelfSendTx({
-      coinAmount,
-      ourWalletWasSender,
-      sendingTransferPresent,
-      receivingTransferPresent,
-    })
-
-    logItemsForServerTxEntries.push([
-      tokenName,
-      {
-        ...logItemCommonProperties,
-        coinAmount,
-        coinName: tokenName,
-        data: { data, nonce, gasLimit, rawCoinAmount, ...methodId },
-        ...(isConsideredSent
-          ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
-          : { from: tokenFromAddresses }),
-        selfSend,
-        currencies: {
-          [token.name]: token.currency,
-          [token.feeAsset.name]: token.feeAsset.currency,
-        },
-      },
-    ])
-  })
-
-  return Object.fromEntries(logItemsForServerTxEntries)
-}

package/src/tx-log/monitor-utils/get-names-of-tokens-transferred-by-server-tx.js

@@ -1,40 +0,0 @@
-import { FEE_PAYMENT_PREFIX } from '@exodus/ethereum-lib'
-import lodash from 'lodash'
-
-import getValueOfTransfers from './get-value-of-transfers.js'
-
-// For ETH transactions, we store an array of token names inside
-// the TX model. This array is used to display text in the UI for
-// transactions which pay fees for ERC20 token transfers. This
-// function is used to determine that array, choosing which
-// tokens a transaction ostensibly 'paid fees' for.
-
-export default function getNamesOfTokensTransferredByServerTx({
-  asset,
-  tokensByAddress,
-  ourWalletAddress,
-  serverTx,
-}) {
-  // Treat smart contract ETH transfer transactions as ETH transfers, not token transfers
-  if (!getValueOfTransfers(ourWalletAddress, asset, serverTx.internal || []).isZero) {
-    return []
-  }
-
-  const tokenAddresses = (serverTx.erc20 || []).map((event) => event.address)
-  if (
-    tokenAddresses.length === 0 &&
-    serverTx.data &&
-    serverTx.data !== '0x' &&
-    !serverTx.data.startsWith(FEE_PAYMENT_PREFIX)
-  ) {
-    // We may still be transacting with tokens even though we found no `tokenAddresses`. This includes
-    // failed token transactions as well as other transactions sent to a token contract. If we do not
-    // recognize the `to` address in the next step, then we will not treat it as a token contract address.
-    tokenAddresses.push(serverTx.to)
-  }
-
-  return lodash
-    .uniq(tokenAddresses)
-    .map((address) => tokensByAddress.get(address)?.name)
-    .filter(Boolean)
-}