@exodus/ethereum-api 2.24.3 → 2.24.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.24.3",
+  "version": "2.24.5",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -16,7 +16,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.5.4",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.21.2",
+    "@exodus/ethereum-lib": "^2.21.4",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.2.1",
     "@exodus/simple-retry": "^0.0.6",
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "0c9784a5eba8cec14a1907a77d5343c2eefa4f64"
+  "gitHead": "2ad238fc652010aa759fcee58c6bbad707ec940d"
 }

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

@@ -1,5 +1,7 @@
 /* @flow */
 import { getServer } from '@exodus/ethereum-api'
+import { isRpcBalanceAsset, getAssetAddresses } from '@exodus/ethereum-lib'
+
 import {
   type PendingTransactionsDictionary,
   checkPendingTransactions,
@@ -7,9 +9,7 @@ import {
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
-  isRpcBalanceAsset,
-  getAssetAddresses,
-} from '@exodus/ethereum-lib'
+} from './monitor-utils'
 
 import {
   enableWSUpdates,

package/src/tx-log/monitor-utils/check-pending-transactions.js

@@ -0,0 +1,39 @@
+// @flow
+import getSenderNonceKey from './get-sender-nonce-key'
+import getFeeAmount from './get-fee-amount'
+import type { PendingTransactionsDictionary } from './types'
+
+export default function checkPendingTransactions({
+  pendingTransactionsGroupedByAddressAndNonce = {},
+  pendingTransactionsToCheck = {},
+  txlist,
+  ourWalletAddress,
+  asset,
+}: {
+  pendingTransactionsGroupedByAddressAndNonce: PendingTransactionsDictionary,
+  pendingTransactionsToCheck: PendingTransactionsDictionary,
+  txlist: Array<Object>,
+  ourWalletAddress: string,
+  asset: Object,
+}): PendingTransactionsDictionary {
+  for (const tx of txlist) {
+    delete pendingTransactionsToCheck[tx.txId || tx.hash] // Found this transaction, do not mark it as dropped
+
+    // check if this TX replaces another pending TX
+    const replacedTx =
+      pendingTransactionsGroupedByAddressAndNonce[getSenderNonceKey(tx, ourWalletAddress)]
+    if (replacedTx && tx.hash !== replacedTx.tx.txId) {
+      // if a pending TX with lower fees comes from the server, don't add it
+      if (
+        replacedTx.tx.sent &&
+        replacedTx.tx.feeAmount.gt(getFeeAmount(asset, tx)) &&
+        tx.confirmations === 0
+      ) {
+        continue
+      }
+      replacedTx.replaced = true
+    }
+  }
+
+  return { pendingTransactionsGroupedByAddressAndNonce, pendingTransactionsToCheck }
+}

package/src/tx-log/monitor-utils/get-all-log-items-by-asset.js

@@ -0,0 +1,32 @@
+import getLogItemsFromServerTx from './get-log-items-from-server-tx'
+
+// Iterates through an array of server transactions and formats them into log item
+// objects (in Tx class fields format). It returns an object of arrays of log
+// items, keyed by asset name.
+
+export default function getAllLogItemsByAsset({
+  allTransactionsFromServer,
+  ourWalletAddress,
+  asset,
+  tokensByAddress,
+  assets,
+}) {
+  const allAssets = [asset, ...tokensByAddress.values()]
+  const logItemsByAsset = Object.fromEntries(allAssets.map((asset) => [asset.name, []]))
+
+  allTransactionsFromServer.forEach((serverTx) => {
+    const logItemsByAssetForServerTx = getLogItemsFromServerTx({
+      serverTx,
+      ourWalletAddress,
+      tokensByAddress,
+      asset,
+      assets,
+    })
+
+    Object.entries(logItemsByAssetForServerTx).forEach(([assetName, logItem]) => {
+      logItemsByAsset[assetName].push(logItem)
+    })
+  })
+
+  return logItemsByAsset
+}

package/src/tx-log/monitor-utils/get-derive-data-needed-for-tick.js

@@ -0,0 +1,14 @@
+// A super-selector that returns all the current data needed for a tick of the ETH monitor.
+
+export default function getDeriveDataNeededForTick(aci) {
+  return async function({ assetName, walletAccount }) {
+    const receiveAddress = await aci.getReceiveAddress({ assetName, walletAccount })
+    const currentAccountState = await aci.getAccountState({ assetName, walletAccount })
+    const minimumConfirmations = await aci.getConfirmationsNumber({ assetName })
+    return {
+      ourWalletAddress: receiveAddress.toLowerCase(),
+      currentAccountState,
+      minimumConfirmations,
+    }
+  }
+}

package/src/tx-log/monitor-utils/get-derive-transactions-to-check.js

@@ -0,0 +1,51 @@
+import ms from 'ms'
+import getSenderNonceKey from './get-sender-nonce-key'
+
+const UNCONFIRMED_TX_LIMIT = ms('5m')
+
+const mapToObject = (map) => Object.fromEntries([...map.entries()]) // only for string keys
+
+export default function getDeriveTransactionsToCheck({ getTxLog }) {
+  return async ({ assetName: _assetName, walletAccount, tokens, ourWalletAddress }) => {
+    const pendingTransactionsToCheck = new Map()
+    const pendingTransactionsGroupedByAddressAndNonce = new Map()
+    const simulatedTransactions = new Map()
+    const now = Date.now()
+
+    for (const assetName of [_assetName, ...tokens.map(({ name }) => name)]) {
+      const txSet = await getTxLog({ assetName, walletAccount })
+      for (const tx of txSet) {
+        // ERC20 sends have an entry in ETH and one in the ERC20 log so we just want the ETH one
+        if (
+          !pendingTransactionsToCheck.has(tx.txId) &&
+          tx.pending &&
+          now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT
+        ) {
+          pendingTransactionsToCheck.set(tx.txId, { tx, assetName })
+        }
+        if (tx.meta.simulated) simulatedTransactions.set(tx.txId, tx)
+
+        const senderNonceKey = getSenderNonceKey(tx, ourWalletAddress)
+        if (
+          tx.pending &&
+          !pendingTransactionsGroupedByAddressAndNonce.has(senderNonceKey) &&
+          !tx.dropped
+        ) {
+          pendingTransactionsGroupedByAddressAndNonce.set(senderNonceKey, {
+            tx,
+            replaced: false,
+            assetName,
+          })
+        }
+      }
+    }
+
+    return {
+      pendingTransactionsToCheck: mapToObject(pendingTransactionsToCheck),
+      pendingTransactionsGroupedByAddressAndNonce: mapToObject(
+        pendingTransactionsGroupedByAddressAndNonce
+      ),
+      simulatedTransactions: mapToObject(simulatedTransactions),
+    }
+  }
+}

package/src/tx-log/monitor-utils/get-fee-amount.js

@@ -0,0 +1,14 @@
+// Returns the amount of ethereum used for a transaction
+// from the server, as a number unit.
+
+export default function getFeeAmount(asset, serverTx) {
+  const { gas: gasLimit, gasUsed, gasPrice } = serverTx
+
+  // genesis, coinbase, uncles
+  if (!gasPrice) return asset.currency.ZERO
+
+  return asset.currency
+    .baseUnit(gasUsed || gasLimit)
+    .mul(gasPrice)
+    .toDefault()
+}

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

@@ -0,0 +1,43 @@
+import isConfirmedServerTx from './is-confirmed-server-tx'
+
+// 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 = 0
+  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

@@ -0,0 +1,141 @@
+import getValueOfTransfers from './get-value-of-transfers'
+import getTransfersByTokenName from './get-transfers-by-token-name'
+import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx'
+import getFeeAmount from './get-fee-amount'
+import isConsideredSentTokenTx from './is-considered-sent-token-tx'
+import isConfirmedServerTx from './is-confirmed-server-tx'
+import lodash from 'lodash'
+
+// This function takes a server transaction object fetched from magnifier,
+// and transforms it into Tx models to update the exodus state.
+
+export default function getLogItemsFromServerTx({
+  serverTx,
+  asset,
+  ourWalletAddress,
+  tokensByAddress,
+  assets,
+}) {
+  const confirmations = isConfirmedServerTx(serverTx) ? 1 : 0
+  const date = parseServerTxDate(serverTx.timestamp) // 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 logItemCommonProperties = {
+    confirmations,
+    date,
+    error,
+    feeAmount: ourWalletWasSender ? feeAmount : undefined,
+    txId,
+    dropped: false,
+  }
+
+  const logItemsForServerTxEntries = []
+
+  {
+    const sendingTransferPresent = ethereumTransfers.some(({ from }) => from === ourWalletAddress)
+    const receivingTransferPresent = ethereumTransfers.some(({ to }) => to === ourWalletAddress)
+
+    if (sendingTransferPresent || receivingTransferPresent) {
+      const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
+      const selfSend = isSelfSendTx({
+        coinAmount,
+        ourWalletWasSender,
+        sendingTransferPresent,
+        receivingTransferPresent,
+      })
+      logItemsForServerTxEntries.push([
+        asset.name,
+        {
+          ...logItemCommonProperties,
+          coinAmount,
+          coinName: asset.name,
+          data: {
+            data: serverTx.data || '0x',
+            nonce,
+            gasLimit,
+          },
+          from: ourWalletWasSender ? [] : [serverTx.from],
+          to: ourWalletWasSender ? toAddress : undefined,
+          selfSend,
+          tokens: getNamesOfTokensTransferredByServerTx({
+            asset,
+            tokensByAddress,
+            serverTx,
+            ourWalletAddress,
+          }),
+        },
+      ])
+    }
+  }
+  // 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)
+    const coinAmount = getValueOfTransfers(
+      ourWalletAddress,
+      token,
+      lodash.filter(tokenTransfers, { events: confirmations > 0 })
+    )
+    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: { nonce, gasLimit },
+        from: isConsideredSent ? [] : tokenFromAddresses,
+        to: isConsideredSent ? tokenTransferToAddress : undefined,
+        selfSend,
+      },
+    ])
+  })
+
+  return Object.fromEntries(logItemsForServerTxEntries)
+}
+
+const tryFindExternalRecipient = (transfers, ourWalletAddress) =>
+  transfers.find(({ to }) => to !== ourWalletAddress)?.to || ourWalletAddress
+
+// If the timestamp is in the future, use the current time.
+const parseServerTxDate = (timestamp) =>
+  new Date(Math.min(Date.now(), parseInt(timestamp, 16) * 1000))
+
+function isSelfSendTx({
+  coinAmount,
+  ourWalletWasSender,
+  sendingTransferPresent,
+  receivingTransferPresent,
+}) {
+  return (
+    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
+  )
+}

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

@@ -0,0 +1,39 @@
+import lodash from 'lodash'
+import getValueOfTransfers from './get-value-of-transfers'
+import { FEE_PAYMENT_PREFIX } from '@exodus/ethereum-lib'
+
+// 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)
+}

package/src/tx-log/monitor-utils/get-sender-nonce-key.js

@@ -0,0 +1,11 @@
+export default function getSenderNonceKey(tx, ourWalletAddress): string {
+  if (Array.isArray(tx.from)) {
+    // Tx class. we don't define the 'from' address if our wallet was the sender.
+    const from = tx.from[0] || ourWalletAddress
+    return `${from}:${tx.data.nonce}`
+  }
+
+  // ethereum tx json object from magnifier
+  const txnonce = parseInt(tx.nonce, 16)
+  return `${tx.from}:${txnonce}`
+}

package/src/tx-log/monitor-utils/get-transfers-by-token-name.js

@@ -0,0 +1,16 @@
+import lodash from 'lodash'
+
+// Sorts an array of token transfer events into an object of transfer event arrays,
+// whose keys are the names of the tokens which are being transferred in the corresponding array.
+// Transfers whose token addresses are not present in the tokensByAddress map are ignored.
+//
+// i.e. [{ address: '0x1', from, to, value }, { address: '0x2', from, to, value }]
+//   -> { token1: [{ address: '0x1', from, to, value }], token2: [{ address: '0x2', from, to, value }] }
+
+export default function getTransfersByTokenName(transfers, tokensByAddress) {
+  const transfersByTokenName = lodash.groupBy(
+    transfers,
+    (transfer) => tokensByAddress.get(transfer.address.toLowerCase())?.name || 'UNKNOWN'
+  )
+  return lodash.omit(transfersByTokenName, 'UNKNOWN')
+}

package/src/tx-log/monitor-utils/get-value-of-transfers.js

@@ -0,0 +1,22 @@
+// Transfer events for ETH or ERC20 tokens have the structure { from, to, value }.
+// This determines the relative amount of a given asset that has been transfered in
+// or out of ourWalletAddress as a number unit, assuming each item in the `transfers`
+// array is a transfer for that asset. If we sent more than we received, the value is negative.
+
+export default function getValueOfTransfers(ourWalletAddress, asset, transfers) {
+  return transfers
+    .reduce((balanceDifference, { from, to, value }) => {
+      const transferAmount = asset.currency.baseUnit(value)
+
+      if (from === ourWalletAddress) {
+        balanceDifference = balanceDifference.sub(transferAmount)
+      }
+
+      if (to === ourWalletAddress) {
+        balanceDifference = balanceDifference.add(transferAmount)
+      }
+
+      return balanceDifference
+    }, asset.currency.ZERO)
+    .to(asset.ticker)
+}

package/src/tx-log/monitor-utils/index.js

@@ -0,0 +1,7 @@
+export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick'
+export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset'
+export { default as getHistoryFromServer } from './get-history-from-server'
+export { default as checkPendingTransactions } from './check-pending-transactions'
+export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check'
+
+export type { PendingTransactionsDictionary } from './types'

package/src/tx-log/monitor-utils/is-confirmed-server-tx.js

@@ -0,0 +1,6 @@
+// NOTE: serverTx.confirmations actually counts the number of blocks AFTER
+// the TX was confirmed, so we must check for the precense of blockNumber instead.
+
+export default function isConfirmedServerTx(serverTx) {
+  return serverTx.blockNumber != null
+}

package/src/tx-log/monitor-utils/is-considered-sent-token-tx.js

@@ -0,0 +1,25 @@
+// Token transactions are provided with either .from or .to address properties based this logic:
+// - First, try to decide based on whether the token amount transferred is positive or negative.
+// - If the amount is zero, try to decide based on whether the token transfer array
+//   contained only send or only receive type events.
+// - Finally, if the value is zero and both receiving and sending transfer events
+//   exist, consider the TX as sent if our wallet was the TX initiator.
+
+export default function isConsideredSentTokenTx({
+  coinAmount,
+  ourWalletWasSender,
+  sendingTransferPresent,
+  receivingTransferPresent,
+}) {
+  if (coinAmount.isNegative) return true
+  if (coinAmount.isPositive) return false
+
+  // if the token TX's coinAmount is zero, the TX probably failed, so check
+  // whether the failed transfers were solely out of, or solely in to ourWalletAddress
+  if (sendingTransferPresent && !receivingTransferPresent) return true
+  if (!sendingTransferPresent && receivingTransferPresent) return false
+
+  // A rare edgecase which could only occur if somehow a token TX
+  // transferred out exactly as much as our wallet received.
+  return ourWalletWasSender
+}

package/src/tx-log/monitor-utils/types.js

@@ -0,0 +1,11 @@
+import type { Tx } from '@exodus/models'
+
+export type PendingTransactionsDictionary =
+  | {
+      [string]: {
+        tx: Tx,
+        replaced?: boolean,
+        assetName: string,
+      },
+    }
+  | {}