@exodus/ethereum-api 4.0.3-alpha1 → 4.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "4.0.3-alpha1",
+  "version": "4.0.3",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -16,7 +16,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.26.1-alpha2",
+    "@exodus/ethereum-lib": "^2.26.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.2.1",
     "@exodus/simple-retry": "^0.0.6",
@@ -35,5 +35,6 @@
   },
   "devDependencies": {
     "@exodus/models": "^8.10.4"
-  }
+  },
+  "gitHead": "1af733c9a00c108adaf9d302ae7a050ee2df8f78"
 }

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

@@ -1,28 +1,15 @@
-import {
-  DEFAULT_SERVER_URLS,
-  ETHEREUM_LIKE_ASSETS,
-  ETHEREUM_LIKE_MONITOR_TYPES,
-} from '@exodus/ethereum-lib'
+import { DEFAULT_SERVER_URLS, ETHEREUM_LIKE_ASSETS } from '@exodus/ethereum-lib'
 
 import { create } from './api'
 import ClarityServer from './clarity'
-import ApiCoinNodesServer from './api-coin-nodes'
-
-function getAssetServer(assetName) {
-  switch (ETHEREUM_LIKE_MONITOR_TYPES[assetName]) {
-    case 'no-history':
-      return new ApiCoinNodesServer({ uri: DEFAULT_SERVER_URLS[assetName] })
-    case 'clarity':
-      return new ClarityServer({ baseAssetName: assetName, uri: DEFAULT_SERVER_URLS[assetName] })
-    case 'magnifier':
-      return create(DEFAULT_SERVER_URLS[assetName], assetName)
-    default:
-      throw new Error(`No server API found for ${assetName}`)
-  }
-}
 
 const serverMap = Object.fromEntries(
-  ETHEREUM_LIKE_ASSETS.map((assetName) => [assetName, getAssetServer(assetName)])
+  ETHEREUM_LIKE_ASSETS.map((assetName) => [
+    assetName,
+    DEFAULT_SERVER_URLS[assetName].includes('clarity')
+      ? new ClarityServer({ baseAssetName: assetName, uri: DEFAULT_SERVER_URLS[assetName] })
+      : create(DEFAULT_SERVER_URLS[assetName], assetName),
+  ])
 )
 
 // allow self-signed certs

package/src/fee-monitor/index.js

@@ -8,4 +8,3 @@ export * from './fantom'
 export * from './harmony'
 export * from './ethereumarbnova'
 export * from './ethereumarbone'
-export * from './rootstock'

package/src/get-balances.js

@@ -1,4 +1,4 @@
-import { ETHEREUM_LIKE_MONITOR_TYPES, isRpcBalanceAsset } from '@exodus/ethereum-lib'
+import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
 
 const fixBalance = ({ txLog, balance }) => {
   for (const tx of txLog) {
@@ -23,10 +23,7 @@ const fixBalance = ({ txLog, balance }) => {
  * @returns {{balance}|null} an object with the balance or null if the balance is unknown/zero
  */
 export const getBalances = ({ asset, txLog, accountState }) => {
-  if (
-    isRpcBalanceAsset(asset) ||
-    ETHEREUM_LIKE_MONITOR_TYPES[asset.baseAsset.name] === 'no-history'
-  ) {
+  if (isRpcBalanceAsset(asset)) {
     const balance =
       asset.baseAsset.name === asset.name
         ? accountState?.balance

package/src/tx-log/index.js

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

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

@@ -1,7 +1,7 @@
 import ms from 'ms'
 import getSenderNonceKey from './get-sender-nonce-key'
 
-export const UNCONFIRMED_TX_LIMIT = ms('5m')
+const UNCONFIRMED_TX_LIMIT = ms('5m')
 
 const mapToObject = (map) => Object.fromEntries([...map.entries()]) // only for string keys
 

package/src/exodus-eth-server/api-coin-nodes.js

@@ -1,191 +0,0 @@
-import { bufferToHex } from '@exodus/ethereumjs-util'
-import SolidityContract from '@exodus/solidity-contract'
-import EventEmitter from 'events'
-
-export default class ApiCoinNodesServer extends EventEmitter {
-  constructor({ uri }) {
-    super()
-    this.uri = uri
-    this.id = 0
-  }
-
-  setURI(uri) {
-    this.uri = uri
-  }
-
-  async request(body) {
-    const options = {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    }
-
-    const response = await fetch(this.uri, options)
-    const data = await response.json()
-
-    return data
-  }
-
-  async sendBatchRequest(batch) {
-    const responses = await this.request(batch)
-    const isValid = responses.every((response) => {
-      return !isNaN(response?.id) && response?.result
-    })
-    if (responses.length !== batch.length || !isValid) {
-      throw new Error('Bad rpc batch 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.request(request)
-
-    const result = response?.result
-    const error = response?.error
-    if (error || !result) {
-      const message = error?.message || error?.code || 'no result'
-      throw new Error(`Bad rpc response: ${message}`)
-    }
-    return result
-  }
-
-  async isContract(address) {
-    const code = await this.getCode(address)
-    return code.length > 2
-  }
-
-  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)
-  }
-}

package/src/fee-monitor/rootstock.js

@@ -1,14 +0,0 @@
-import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
-import { getServerByName } from '../exodus-eth-server'
-
-const assetName = 'rootstock'
-
-export class RootstockFeeMonitor extends EthereumLikeFeeMonitor {
-  constructor({ updateFee }) {
-    super({
-      updateFee,
-      assetName,
-      getGasPrice: getServerByName(assetName).gasPrice,
-    })
-  }
-}

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

@@ -1,193 +0,0 @@
-import BN from 'bn.js'
-import { getServer } from '@exodus/ethereum-api'
-import { Tx } from '@exodus/models'
-
-import { getDeriveDataNeededForTick, getDeriveTransactionsToCheck } from './monitor-utils'
-
-import { isEmpty, unionBy, zipObject } from 'lodash'
-
-import { BaseMonitor } from '@exodus/asset-lib'
-
-import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check'
-
-// The base ethereum monitor no history class handles listening for assets with no history
-
-export class EthereumNoHistoryMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
-    super(args)
-    this.server = server || getServer(this.asset)
-    this.config = { ...config }
-    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
-    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
-      getTxLog: (...args) => this.aci.getTxLog(...args),
-    })
-  }
-
-  setServer(config) {
-    if (config.server === this.server?.uri) {
-      return
-    }
-    this.server.setURI(config.server)
-  }
-
-  async getBalances({ tokens, ourWalletAddress }) {
-    const batch = {}
-    const request = this.server.getBalanceRequest(ourWalletAddress)
-    batch[this.asset.name] = request
-    for (const token of tokens) {
-      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)
-  }
-
-  async getNewAccountState({ tokens, ourWalletAddress }) {
-    const asset = this.asset
-    const newAccountState = {}
-    const balances = await this.getBalances({ tokens, ourWalletAddress })
-    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 deriveData({ assetSource, tokens }) {
-    const { 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,
-    }
-  }
-
-  async getTransactionsFromNode(transactions) {
-    const batch = []
-    for (const { tx } of transactions) {
-      const request = this.server.getTransactionByHashRequest(tx.txId)
-      batch.push(request)
-    }
-    const responses = await this.server.sendBatchRequest(batch)
-    const txIds = transactions.map(({ tx }) => tx.txId)
-    return zipObject(txIds, responses)
-  }
-
-  async checkPendingTransactions({
-    pendingTransactionsGroupedByAddressAndNonce,
-    pendingTransactionsToCheck,
-    walletAccount,
-  }) {
-    const txsToUpdate = []
-    const txsToRemove = []
-    const now = Date.now()
-
-    const pendingTransactions = unionBy(
-      Object.values(pendingTransactionsGroupedByAddressAndNonce),
-      Object.values(pendingTransactionsToCheck),
-      'tx.txId'
-    )
-
-    if (isEmpty(pendingTransactions))
-      return {
-        txsToUpdate,
-        txsToRemove,
-      }
-
-    const txsFromNode = await this.getTransactionsFromNode(pendingTransactions)
-
-    for (const { tx, assetName } of pendingTransactions) {
-      const txFromNode = txsFromNode[tx.txId]
-      if (now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT) {
-        txsToRemove.push({
-          tx,
-          assetSource: { asset: assetName, walletAccount },
-        })
-      } else if (txFromNode.blockHash !== null) {
-        txsToUpdate.push({
-          tx: { ...tx, confirmations: 1 },
-          assetSource: { asset: assetName, walletAccount },
-        })
-      }
-    }
-
-    return {
-      txsToUpdate,
-      txsToRemove,
-    }
-  }
-
-  async tick({ refresh, walletAccount }) {
-    const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
-    const tokens = Object.values(assets).filter((asset) => asset.baseAsset.name !== asset.name)
-
-    const assetSource = { assetName: this.asset.name, walletAccount }
-
-    const {
-      ourWalletAddress,
-      pendingTransactionsGroupedByAddressAndNonce,
-      pendingTransactionsToCheck,
-    } = await this.deriveData({
-      assetSource,
-      tokens,
-    })
-
-    const accountState = await this.getNewAccountState({
-      tokens,
-      ourWalletAddress,
-    })
-
-    const { txsToUpdate, txsToRemove } = await this.checkPendingTransactions({
-      pendingTransactionsGroupedByAddressAndNonce,
-      pendingTransactionsToCheck,
-      walletAccount,
-    })
-
-    const logItemsByAsset = {}
-
-    txsToUpdate.forEach((txToUpdate) => {
-      logItemsByAsset[txToUpdate.assetSource.asset] =
-        logItemsByAsset[txToUpdate.assetSource.asset] || []
-      logItemsByAsset[txToUpdate.assetSource.asset].push(Tx.fromJSON(txToUpdate.tx))
-    })
-
-    await this.updateAccountState({ newData: { ...accountState }, walletAccount })
-
-    await this.removeFromTxLog(txsToRemove)
-    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
-  }
-}