@exodus/ethereum-api 4.0.1 → 4.0.2-alpha1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "4.0.1",
+  "version": "4.0.2-alpha1",
   "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.0",
+    "@exodus/ethereum-lib": "^2.26.1-alpha1",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.2.1",
     "@exodus/simple-retry": "^0.0.6",
@@ -35,6 +35,5 @@
   },
   "devDependencies": {
     "@exodus/models": "^8.10.4"
-  },
-  "gitHead": "729674ae988309eccf03feefbf891d8b43947577"
+  }
 }

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

@@ -0,0 +1,191 @@
+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/exodus-eth-server/index.js

@@ -1,15 +1,28 @@
-import { DEFAULT_SERVER_URLS, ETHEREUM_LIKE_ASSETS } from '@exodus/ethereum-lib'
+import {
+  DEFAULT_SERVER_URLS,
+  ETHEREUM_LIKE_ASSETS,
+  ETHEREUM_LIKE_MONITOR_TYPES,
+} 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,
-    DEFAULT_SERVER_URLS[assetName].includes('clarity')
-      ? new ClarityServer({ baseAssetName: assetName, uri: DEFAULT_SERVER_URLS[assetName] })
-      : create(DEFAULT_SERVER_URLS[assetName], assetName),
-  ])
+  ETHEREUM_LIKE_ASSETS.map((assetName) => [assetName, getAssetServer(assetName)])
 )
 
 // allow self-signed certs

package/src/fee-monitor/index.js

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

package/src/fee-monitor/rootstock.js

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,197 @@
+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 } from 'lodash'
+
+import { BaseMonitor } from '@exodus/asset-lib'
+import { getAssetAddresses } from '@exodus/ethereum-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 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 batch = []
+    for (const { tx } of pendingTransactions) {
+      const request = this.server.getTransactionByHashRequest(tx.txId)
+      batch.push(request)
+    }
+    const responses = await this.server.sendBatchRequest(batch)
+    const txsFromNode = {}
+    responses.forEach(
+      (response, index) => (txsFromNode[pendingTransactions[index].tx.txId] = response)
+    )
+
+    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,
+          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 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 = { 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 allAssets = [this.asset, ...tokensByAddress.values()]
+    const logItemsByAsset = Object.fromEntries(allAssets.map((asset) => [asset.name, []]))
+
+    txsToUpdate.forEach((txToUpdate) => {
+      const { tx } = txToUpdate
+      logItemsByAsset[txToUpdate.assetSource.asset].push(Tx.fromJSON({ ...tx, confirmations: 1 }))
+    })
+
+    await this.updateAccountState({ newData: { ...accountState }, walletAccount })
+
+    await this.removeFromTxLog(txsToRemove)
+    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
+  }
+}

package/src/tx-log/index.js

@@ -1,2 +1,3 @@
 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'
 
-const UNCONFIRMED_TX_LIMIT = ms('5m')
+export const UNCONFIRMED_TX_LIMIT = ms('5m')
 
 const mapToObject = (map) => Object.fromEntries([...map.entries()]) // only for string keys