@exodus/ethereum-api 3.3.1 → 3.3.4-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "3.3.1",
+  "version": "3.3.4-alpha.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -17,7 +17,7 @@
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/bip32": "^1.0.0",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.24.1",
+    "@exodus/ethereum-lib": "^2.24.3-alpha.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.2.1",
     "@exodus/key-utils": "^1.0.0",
@@ -30,6 +30,7 @@
     "make-concurrent": "4.0.0",
     "minimalistic-assert": "^1.0.1",
     "ms": "^2.1.1",
+    "socket.io-client": "^4.5.4",
     "url": "0.10.3",
     "url-join": "4.0.0",
     "ws": "^6.1.0"
@@ -37,5 +38,5 @@
   "devDependencies": {
     "@exodus/models": "^8.10.4"
   },
-  "gitHead": "d4953e5b81e4638d0d8b715bbb81f41c7dc9e970"
+  "gitHead": "1309eea2af6fa13a3e9e36e6aa615f863ab73012"
 }

package/src/exodus-eth-server/clarity.js

@@ -0,0 +1,302 @@
+import { bufferToHex } from '@exodus/ethereumjs-util'
+import SolidityContract from '@exodus/solidity-contract'
+import EventEmitter from 'events'
+import { io } from 'socket.io-client'
+import { ASSET_NAMESPACES } from '@exodus/ethereum-lib'
+
+export default class ClarityServer extends EventEmitter {
+  constructor({ baseAssetName, uri }) {
+    super()
+    this.baseAssetName = baseAssetName
+    this.uri = uri
+    this.baseNamespace = `/v1/${ASSET_NAMESPACES[this.baseAssetName]}`
+    this.sockets = {}
+    this.id = 0
+  }
+
+  setURI(uri) {
+    this.dispose()
+    this.uri = uri
+  }
+
+  connectTransactions({ walletAccount, address }) {
+    const namespace = this.formatTransactionsNamespace(address)
+    if (!this.sockets[namespace]) {
+      this.sockets[namespace] = this.createSocket(namespace)
+      this.sockets[namespace].on('transaction', (isPending, transaction) => {
+        this.emit('transaction', { walletAccount, isPending, transaction })
+      })
+    }
+    return this.sockets[namespace]
+  }
+
+  connectRpc() {
+    const namespace = this.formatRpcNamespace()
+    if (!this.sockets[namespace]) {
+      this.sockets[namespace] = this.createSocket(namespace)
+    }
+    return this.sockets[namespace]
+  }
+
+  connectFee() {
+    const namespace = this.formatFeeNamespace()
+    if (!this.sockets[namespace]) {
+      this.sockets[namespace] = this.createSocket(namespace)
+      this.sockets[namespace].on('feeUpdated', (fee) => this.emit('feeUpdated', fee))
+    }
+    return this.sockets[namespace]
+  }
+
+  createSocket(namespace) {
+    return io(`${this.uri}${namespace}`)
+  }
+
+  disconnectTransactions(address) {
+    const namespace = this.formatTransactionsNamespace(address)
+    this.disconnectSocket(namespace)
+  }
+
+  disconnectRpc() {
+    this.disconnectSocket(this.rpcNamespace)
+  }
+
+  disconnectFee() {
+    this.disconnectSocket(this.feeNamespace)
+  }
+
+  disconnectSocket(namespace) {
+    if (this.sockets[namespace]) {
+      this.sockets[namespace].disconnect()
+      delete this.sockets[namespace]
+    }
+  }
+
+  dispose() {
+    const namespaces = Object.keys(this.sockets)
+    for (const namespace of namespaces) {
+      this.disconnectSocket(namespace)
+    }
+  }
+
+  async getAllTransactions(params) {
+    const transactions = { pending: [], confirmed: [] }
+    const cursor = await this.getTransactions({
+      ...params,
+      onChunk: (isPending, chunk) => {
+        if (isPending) {
+          transactions.pending.push(...chunk)
+        } else {
+          transactions.confirmed.push(...chunk)
+        }
+      },
+    })
+    return { cursor, transactions }
+  }
+
+  async getTransactions({ walletAccount, address, cursor, onChunk }) {
+    const socket = this.connectTransactions({ walletAccount, address })
+    const listener = (isPending, chunk, callback) => {
+      onChunk(isPending, chunk)
+      callback()
+    }
+    socket.on('transactionsChunk', listener)
+    return new Promise((resolve) => {
+      socket.emit('getTransactions', cursor, (nextCursor) => {
+        resolve(nextCursor)
+      })
+    })
+      .catch((error) => console.error(error))
+      .finally(() => socket.off('transactionsChunk', listener))
+  }
+
+  async getFee() {
+    const socket = this.connectFee()
+    return new Promise((resolve, reject) => {
+      socket.timeout(30000).emit('getFee', (fee) => {
+        if (!fee) {
+          const error = new Error('Unable to get fee')
+          return reject(error)
+        }
+        resolve(fee)
+      })
+    })
+  }
+
+  async sendRpcRequest(rpcRequest) {
+    const rpcSocket = this.connectRpc()
+    return new Promise((resolve, reject) => {
+      rpcSocket.timeout(30000).emit('request', rpcRequest, (error, response) => {
+        if (error) {
+          return reject(error)
+        }
+        resolve(response)
+      })
+    })
+  }
+
+  async sendBatchRequest(batch) {
+    const responses = await this.sendRpcRequest(batch)
+    const isValid = responses.every((response) => {
+      return !isNaN(response?.id) && response?.result
+    })
+    if (responses.length !== batch.length || !isValid) {
+      throw new Error('Bad Response')
+    }
+    const keyed = responses.reduce((acc, response) => {
+      return { ...acc, [`${response.id}`]: response.result }
+    }, {})
+    return batch.map((request) => keyed[`${request.id}`])
+  }
+
+  async sendRequest(request) {
+    const response = await this.sendRpcRequest(request)
+    if (!response?.result) {
+      throw new Error('Bad Response')
+    }
+    return response.result
+  }
+
+  buildRequest({ method, params = [] }) {
+    return { jsonrpc: '2.0', id: this.id++, method, params }
+  }
+
+  balanceOfRequest(address, tokenAddress, tag = 'latest') {
+    const contract = SolidityContract.simpleErc20(tokenAddress)
+    const callData = contract.balanceOf.build(address)
+    const data = {
+      data: bufferToHex(callData),
+      to: tokenAddress,
+    }
+    return this.ethCallRequest(data, tag)
+  }
+
+  getBalanceRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getBalance', params: [address, tag] })
+  }
+
+  gasPriceRequest() {
+    return this.buildRequest({ method: 'eth_gasPrice' })
+  }
+
+  estimateGasRequest(data, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_estimateGas', params: [data, tag] })
+  }
+
+  sendRawTransactionRequest(data) {
+    const hex = data.startsWith('0x') ? data : '0x' + data
+    return this.buildRequest({ method: 'eth_sendRawTransaction', params: [hex] })
+  }
+
+  getCodeRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getCode', params: [address, tag] })
+  }
+
+  getTransactionCountRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getTransactionCount', params: [address, tag] })
+  }
+
+  getTransactionByHashRequest(hash) {
+    return this.buildRequest({ method: 'eth_getTransactionByHash', params: [hash] })
+  }
+
+  getTransactionReceiptRequest(txhash) {
+    return this.buildRequest({ method: 'eth_getTransactionReceipt', params: [txhash] })
+  }
+
+  ethCallRequest(data, tag) {
+    return this.buildRequest({ method: 'eth_call', params: [data, tag] })
+  }
+
+  blockNumberRequest() {
+    return this.buildRequest({ method: 'eth_blockNumber' })
+  }
+
+  getBlockByNumberRequest(numberHex, isFullTxs = false) {
+    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
+  }
+
+  simulateRawTransactionRequest(rawTx, applyPending = true) {
+    const replaced = rawTx.replace('0x', '')
+    return this.buildRequest({
+      method: 'debug_simulateRawTransaction',
+      params: [replaced, applyPending],
+    })
+  }
+
+  async balanceOf(...params) {
+    const request = this.balanceOfRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBalance(...params) {
+    const request = this.getBalanceRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async gasPrice(...params) {
+    const request = this.gasPriceRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async estimateGas(...params) {
+    const request = this.estimateGasRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async sendRawTransaction(...params) {
+    const request = this.sendRawTransactionRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getCode(...params) {
+    const request = this.getCodeRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionCount(...params) {
+    const request = this.getTransactionCountRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionByHash(...params) {
+    const request = this.getTransactionByHashRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionReceipt(...params) {
+    const request = this.getTransactionReceiptRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async ethCall(...params) {
+    const request = this.ethCallRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async blockNumber(...params) {
+    const request = this.blockNumberRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBlockByNumber(...params) {
+    const request = this.getBlockByNumberRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async simulateRawTransaction(...params) {
+    const request = this.simulateRawTransactionRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  formatTransactionsNamespace(address) {
+    return `${this.baseNamespace}/addresses/${address}/transactions`
+  }
+
+  formatRpcNamespace() {
+    return `${this.baseNamespace}/rpc`
+  }
+
+  formatFeeNamespace() {
+    return `${this.baseNamespace}/fee`
+  }
+}

package/src/exodus-eth-server/index.js

@@ -1,11 +1,14 @@
 import { DEFAULT_SERVER_URLS, ETHEREUM_LIKE_ASSETS } from '@exodus/ethereum-lib'
 
 import { create } from './api'
+import ClarityServer from './clarity'
 
 const serverMap = Object.fromEntries(
   ETHEREUM_LIKE_ASSETS.map((assetName) => [
     assetName,
-    create(DEFAULT_SERVER_URLS[assetName], assetName),
+    DEFAULT_SERVER_URLS[assetName].includes('clarity')
+      ? new ClarityServer({ baseAssetName: assetName, uri: DEFAULT_SERVER_URLS[assetName] })
+      : create(DEFAULT_SERVER_URLS[assetName], assetName),
   ])
 )
 

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

@@ -0,0 +1,327 @@
+import BN from 'bn.js'
+import { BaseMonitor } from '@exodus/asset-lib'
+import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
+import { isEmpty } from 'lodash'
+
+import {
+  type PendingTransactionsDictionary,
+  getAllLogItemsByAsset,
+  checkPendingTransactions,
+  getDeriveTransactionsToCheck,
+} from './monitor-utils'
+import { getLogItemsFromServerTx, getDeriveDataNeededForTick, filterEffects } from './clarity-utils'
+
+import { type Tx } from '@exodus/models'
+
+type DerivedData = {
+  ourWalletAddress: string,
+  currentAccountState: Object,
+  unconfirmedTransactions: PendingTransactionsDictionary,
+  pendingTransactionsGroupedByAddressAndNonce: PendingTransactionsDictionary,
+  simulatedTransactions: any,
+}
+
+export class ClarityMonitor extends BaseMonitor {
+  constructor({ server, config, ...args }) {
+    super(args)
+    this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
+    this.server = server
+    this.getAllLogItemsByAsset = getAllLogItemsByAsset
+    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
+    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
+      getTxLog: (...args) => this.aci.getTxLog(...args),
+    })
+    this.addHook('before-start', (...args) => this.beforeStart(...args))
+    this.addHook('after-stop', (...args) => this.afterStop(...args))
+  }
+
+  setServer(config) {
+    if (config.server === this.server.uri) {
+      return
+    }
+    this.server.setURI(config.server)
+    this.subscribeWalletAddresses()
+    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
+      this.server.connectFee()
+    }
+  }
+
+  async deriveData({ assetName, walletAccount, tokens }: Object): DerivedData {
+    const { ourWalletAddress, currentAccountState } = await this.deriveDataNeededForTick({
+      assetName,
+      walletAccount,
+    })
+    const transactionsToCheck = await this.deriveTransactionsToCheck({
+      assetName,
+      walletAccount,
+      tokens,
+      ourWalletAddress,
+    })
+
+    return {
+      ourWalletAddress,
+      currentAccountState,
+      ...transactionsToCheck,
+    }
+  }
+
+  // eslint-disable-next-line no-undef
+  async checkPendingTransactions(params): { txsToRemove: { tx: Tx, assetSource: AssetSource }[] } {
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+    } = checkPendingTransactions(params)
+    const txsToRemove = []
+    const { 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({ walletAccount, refresh }) {
+    await this.subscribeWalletAddresses()
+
+    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 assetName = this.asset.name
+
+    const derivedData = await this.deriveData({ assetName, walletAccount, tokens })
+    const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
+    const allTxs = [...response.transactions.pending, ...response.transactions.confirmed]
+    const hasNewTxs = allTxs.length > 0
+
+    const logItemsByAsset = this.getAllLogItemsByAsset({
+      getLogItemsFromServerTx,
+      ourWalletAddress: derivedData.ourWalletAddress,
+      allTransactionsFromServer: allTxs,
+      asset: this.asset,
+      tokensByAddress,
+      assets,
+    })
+
+    const { txsToRemove } = await this.checkPendingTransactions({
+      txlist: allTxs,
+      walletAccount,
+      refresh,
+      logItemsByAsset,
+      asset: this.asset,
+      ...derivedData,
+    })
+
+    const nextCursorBuff = response.cursor ? Buffer.from(response.cursor) : null
+    const nextCursorBase64 = nextCursorBuff?.toString?.('base64') || null
+
+    const accountState = await this.getNewAccountState({
+      tokens,
+      ourWalletAddress: derivedData.ourWalletAddress,
+    })
+    await this.updateAccountState({
+      walletAccount,
+      newData: { cursor: nextCursorBase64, ...accountState },
+    })
+
+    await this.removeFromTxLog(txsToRemove)
+    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
+    if (refresh || hasNewTxs) {
+      const unknownTokenAddresses = this._getUnknownTokenAddresses({
+        transactions: allTxs,
+        tokensByAddress,
+      })
+      if (unknownTokenAddresses.length > 0) {
+        this.emit('unknown-tokens', unknownTokenAddresses)
+      }
+    }
+  }
+
+  async deriveDataNeededForTick({ assetName, walletAccount }) {
+    const receiveAddress = await this.aci.getReceiveAddress({ assetName, walletAccount })
+    const currentAccountState = await this.aci.getAccountState({ assetName, walletAccount })
+    return {
+      ourWalletAddress: receiveAddress.toLowerCase(),
+      currentAccountState,
+    }
+  }
+
+  async getNewAccountState({ tokens, ourWalletAddress }) {
+    const asset = this.asset
+    const newAccountState = {}
+    const balances = await this.getBalances({ tokens, ourWalletAddress })
+    if (isRpcBalanceAsset(asset)) {
+      const balance = balances[asset.name]
+      newAccountState.balance = asset.currency.baseUnit(balance)
+    }
+    const tokenBalancePairs = Object.entries(balances).filter((entry) => entry[0] !== asset.name)
+    const entries = tokenBalancePairs
+      .map((pair) => {
+        const token = tokens.find((token) => token.name === pair[0])
+        const value = token.currency.baseUnit(pair[1] || 0)
+        return value.isZero ? null : [token.name, value]
+      })
+      .filter((pair) => pair)
+    const tokenBalances = Object.fromEntries(entries)
+    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 subscribeWalletAddresses() {
+    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
+    Object.entries(addressesByWalletAccount).forEach(([walletAccount, addresses]) => {
+      const address = String(Array.from(addresses)[0]).toLowerCase() // Only check m/0/0
+      this.server.connectTransactions({ walletAccount, address })
+    })
+  }
+
+  async getBalances({ tokens, ourWalletAddress }) {
+    const batch = {}
+    if (isRpcBalanceAsset(this.asset)) {
+      const request = this.server.getBalanceRequest(ourWalletAddress)
+      batch[this.asset.name] = request
+    }
+    for (const token of tokens) {
+      if (isRpcBalanceAsset(token) && token.contract.address) {
+        const request = this.server.balanceOfRequest(ourWalletAddress, token.contract.address)
+        batch[token.name] = request
+      }
+    }
+    const pairs = Object.entries(batch)
+    if (!pairs.length) {
+      return {}
+    }
+    const requests = pairs.map((pair) => pair[1])
+    const responses = await this.server.sendBatchRequest(requests)
+    const entries = pairs.map((pair, idx) => {
+      const balanceHex = responses[idx]
+      const name = pair[0]
+      const hex = balanceHex.startsWith('0x') ? balanceHex.slice(2) : balanceHex
+      const balance = new BN(hex, 'hex').toString()
+      return [name, balance]
+    })
+    return Object.fromEntries(entries)
+  }
+
+  _getUnknownTokenAddresses({ transactions, tokensByAddress }) {
+    const set = transactions.reduce((acc, txn) => {
+      const transfers = filterEffects(txn.effects, 'erc20') || []
+      transfers.forEach((transfer) => {
+        const addr = transfer.address.toLowerCase()
+        if (!tokensByAddress.has(addr)) {
+          acc.add(addr)
+        }
+      }, acc)
+      return acc
+    }, new Set())
+    return Array.from(set)
+  }
+
+  async updateGasPrice({ gasPrice, baseFeePerGas }) {
+    try {
+      const gasPriceHex = gasPrice?.startsWith('0x') ? gasPrice.slice(2) : gasPrice
+      const feeConfig = { gasPrice: `${new BN(gasPriceHex, 'hex').toString()} wei` }
+      if (baseFeePerGas) {
+        const baseFeePerGasHex = baseFeePerGas?.startsWith('0x')
+          ? baseFeePerGas.slice(2)
+          : baseFeePerGas
+        feeConfig.baseFeePerGas = `${new BN(baseFeePerGasHex, 'hex').toString()} wei`
+      }
+
+      this.logger.debug(
+        `Update ${this.asset.name} gas price: ${feeConfig.gasPrice}, baseFeePerGas: ${feeConfig.baseFeePerGas}`
+      )
+      await this.aci.updateFeeConfig({ assetName: this.asset.name, feeConfig })
+    } catch (e) {
+      this.logger.warn('error updating gasPrice', e)
+    }
+  }
+
+  async onTransaction({ walletAccount }) {
+    return this.tick({ walletAccount })
+  }
+
+  async onFeeUpdated(fee) {
+    return this.updateGasPrice(fee)
+  }
+
+  async beforeStart() {
+    this.listenToServerEvents()
+    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
+      this.server.connectFee()
+    }
+    return this.subscribeWalletAddresses()
+  }
+
+  async afterStop() {
+    this.server.dispose()
+  }
+
+  async getHistoryFromServer({ walletAccount, derivedData, refresh }) {
+    const address = derivedData.ourWalletAddress
+    const cursorBase64 = derivedData.currentAccountState?.cursor
+    const cursor = cursorBase64 && !refresh ? Buffer.from(cursorBase64, 'base64') : null
+    return this.server.getAllTransactions({ walletAccount, address, cursor })
+  }
+
+  listenToServerEvents() {
+    this.server.on('transaction', (...args) => this.onTransaction(...args))
+    this.server.on('feeUpdated', (...args) => this.onFeeUpdated(...args))
+  }
+}

package/src/tx-log/clarity-utils/filter-effects.js

@@ -0,0 +1,3 @@
+export default function filterEffects(effects, type) {
+  return effects?.filter((eff) => eff.effect === type)
+}

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

@@ -0,0 +1,12 @@
+// 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 })
+    return {
+      ourWalletAddress: receiveAddress.toLowerCase(),
+      currentAccountState,
+    }
+  }
+}

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

@@ -0,0 +1,143 @@
+import getValueOfTransfers from '../monitor-utils/get-value-of-transfers'
+import getTransfersByTokenName from '../monitor-utils/get-transfers-by-token-name'
+import getFeeAmount from '../monitor-utils/get-fee-amount'
+import isConsideredSentTokenTx from '../monitor-utils/is-considered-sent-token-tx'
+import isConfirmedServerTx from '../monitor-utils/is-confirmed-server-tx'
+import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx'
+import filterEffects from './filter-effects'
+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 === '0' ? 'Failed' : null)
+  const feeAmount = getFeeAmount(asset, serverTx)
+  const internalTransfers = filterEffects(serverTx.effects, 'internal') || []
+  const ethereumTransfers = [serverTx, ...internalTransfers]
+  const erc20Transfers = filterEffects(serverTx.effects, 'erc20') || []
+  const tokenTransfersByTokenName = getTransfersByTokenName(erc20Transfers, tokensByAddress)
+  const toAddress = tryFindExternalRecipient(ethereumTransfers, ourWalletAddress)
+  const ourWalletWasSender = serverTx.from === ourWalletAddress
+
+  const logItemCommonProperties = {
+    confirmations,
+    date,
+    error,
+    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,
+          feeAmount: ourWalletWasSender ? feeAmount : undefined,
+          selfSend,
+          tokens: getNamesOfTokensTransferredByServerTx({
+            asset,
+            tokensByAddress,
+            ourWalletAddress,
+            serverTx,
+            internalTransfers,
+            erc20Transfers,
+          }),
+        },
+      ])
+    }
+  }
+  // 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, tokenTransfers)
+    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,
+        feeAmount: isConsideredSent ? feeAmount : 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)))
+
+function isSelfSendTx({
+  coinAmount,
+  ourWalletWasSender,
+  sendingTransferPresent,
+  receivingTransferPresent,
+}) {
+  return (
+    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
+  )
+}

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

@@ -0,0 +1,41 @@
+import lodash from 'lodash'
+import getValueOfTransfers from '../monitor-utils/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,
+  internalTransfers,
+  erc20Transfers,
+}) {
+  // Treat smart contract ETH transfer transactions as ETH transfers, not token transfers
+  if (!getValueOfTransfers(ourWalletAddress, asset, internalTransfers).isZero) {
+    return []
+  }
+
+  const tokenAddresses = erc20Transfers.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/clarity-utils/index.js

@@ -0,0 +1,3 @@
+export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick'
+export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx'
+export { default as filterEffects } from './filter-effects'

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

@@ -7,6 +7,7 @@ import {
   type PendingTransactionsDictionary,
   checkPendingTransactions,
   getAllLogItemsByAsset,
+  getLogItemsFromServerTx,
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
@@ -165,6 +166,7 @@ export class EthereumMonitor extends BaseMonitor {
     const hasNewIndex = !derivedIndex || index > derivedIndex
 
     const logItemsByAsset = getAllLogItemsByAsset({
+      getLogItemsFromServerTx,
       ourWalletAddress: derivedData.ourWalletAddress,
       allTransactionsFromServer,
       asset: this.asset,

package/src/tx-log/index.js

@@ -1 +1,2 @@
 export * from './ethereum-monitor'
+export { ClarityMonitor } from './clarity-monitor'

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

@@ -1,10 +1,9 @@
-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({
+  getLogItemsFromServerTx,
   allTransactionsFromServer,
   ourWalletAddress,
   asset,

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

@@ -1,5 +1,6 @@
 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 getLogItemsFromServerTx } from './get-log-items-from-server-tx'
 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'