@exodus/ethereum-api 2.16.0 → 2.17.0

package/package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@exodus/ethereum-api",
+  "version": "2.21.0",
+  "description": "Ethereum Api",
+  "main": "src/index.js",
+  "author": "Exodus Movement, Inc.",
+  "license": "UNLICENSED",
+  "homepage": "https://github.com/ExodusMovement/ethereum#readme",
+  "files": ["src", "!src/__tests__"],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "dependencies": {
+    "@exodus/asset-lib": "^3.5.4",
+    "@exodus/crypto": "^1.0.0-rc.0",
+    "@exodus/ethereum-lib": "^2.15.0",
+    "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
+    "@exodus/simple-retry": "^0.0.6",
+    "@exodus/solidity-contract": "^1.0.1",
+    "fetchival": "0.3.3",
+    "make-concurrent": "4.0.0",
+    "minimalistic-assert": "^1.0.1",
+    "ms": "^2.1.1",
+    "url": "0.10.3",
+    "url-join": "4.0.0",
+    "ws": "6.1.0"
+  },
+  "devDependencies": {
+    "@exodus/assets": "^8.0.67",
+    "@exodus/assets-base": "^8.0.136",
+    "@exodus/models": "^8.7.2"
+  }
+}

package/package/src/eth-like-util.js

@@ -0,0 +1,147 @@
+import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken, ABI } from '@exodus/ethereum-lib'
+import { eth, serverMap, getServer } from './exodus-eth-server'
+import { memoizeLruCache } from '@exodus/asset-lib'
+import assets from '@exodus/assets'
+import SolidityContract from '@exodus/solidity-contract'
+
+// Mobile only.
+// Behavior is buggy, because the default server used is ethereum.
+// We should refactor mobile to pass 'asset' instead of 'assetName' so that we can use 'isContractAddress'. But that would touch many assets.
+export async function isContract(baseAssetName, address) {
+  const server = serverMap[baseAssetName] || eth
+  return server.isContract(address)
+}
+
+export async function isContractAddress({ asset, address }) {
+  return getServer(asset).isContract(address)
+}
+
+export async function isForwarderContract({ asset, address }) {
+  const contractCode = await getServer(asset).getCode(address)
+  return (
+    contractCode ===
+    '0x5836818037808036817364b29dc43e817817cf77468c8dda63d98ce08fb25af43d91908282803e602b57fd5bf3'
+  )
+}
+
+export async function getNonce({ asset, address, tag = 'latest' }) {
+  const server = getServer(asset)
+  const nonce = await server.getTransactionCount(address, tag)
+  return parseInt(nonce, 16)
+}
+
+export async function estimateGas({ asset, ...args }) {
+  return getServer(asset).estimateGas(args)
+}
+
+// Only base assets, not tokens
+export async function getBalance({ asset, address }) {
+  if (!isEthereumLikeAsset(asset)) throw new Error(`unsupported asset ${asset.name}`)
+  const server = getServer(asset)
+  const balances = await server.getBalance(address)
+  return balances?.confirmed?.value || '0'
+}
+
+// Only ETH-like assets with token support
+export async function getTokenBalance({ asset, address }) {
+  if (!isEthereumLikeToken(asset)) throw new Error(`unsupported ETH-like token ${asset.name}`)
+  const server = getServer(asset)
+  const balances = await server.getBalance(address)
+  const contractAddress = asset.contract.address.toLowerCase()
+  return balances?.confirmed?.[contractAddress] || '0'
+}
+
+export async function getTokenBalanceFromNode({ asset, address }) {
+  if (!isEthereumLikeToken(asset)) throw new Error(`unsupported ETH-like token ${asset.name}`)
+  const server = getServer(asset)
+  const contractAddress = asset.contract.address.toLowerCase()
+  const balances = await server.balanceOf(address, contractAddress)
+  return balances?.confirmed?.[contractAddress] || '0'
+}
+
+// Returns function for supplied asset
+export function sendRawTransaction(asset) {
+  return getServer(asset).sendRawTransaction
+}
+
+export async function transactionExists({ asset, txId }) {
+  const server = getServer(asset)
+  txId = normalizeTxId(txId)
+  const txResult = await server.getTransactionByHash(txId)
+  return txResult && txResult.hash === txId
+}
+
+export const getIsForwarderContract = memoizeLruCache(
+  isForwarderContract,
+  ({ asset, address }) => `${asset.name}:${address}`,
+  { max: 100 }
+)
+
+const ERC20 = new SolidityContract(ABI.erc20)
+const ERC20BytesParams = new SolidityContract(ABI.erc20BytesParams)
+const DEFAULT_PARAM_NAMES = ['decimals', 'name', 'symbol']
+const erc20ParamsCache = {}
+
+export const getERC20Params = async ({
+  assetName,
+  address,
+  paramNames = DEFAULT_PARAM_NAMES,
+} = {}) => {
+  const asset = assets[assetName]
+  if (!asset) {
+    throw new Error(`${assetName} not found`)
+  }
+  if (!address) {
+    throw new Error(`Token address should be provided, got: ${address}`)
+  }
+
+  const cacheKey = `${address}:${paramNames}`
+  if (erc20ParamsCache[cacheKey]) {
+    return erc20ParamsCache[cacheKey]
+  }
+
+  const server = getServer(asset)
+
+  const paramValues = await Promise.all(
+    paramNames.map(async (method) => {
+      let callResponse
+      try {
+        callResponse = await server.ethCall({ to: address, data: ERC20[method].methodId })
+      } catch (err) {
+        if (err.message === 'execution reverted') {
+          throw Error(
+            `Can't find parameters for contract with address ${address}. Are you sure it is a valid ERC20 contract?`
+          )
+        }
+
+        throw Error(err.message)
+      }
+
+      if (method === 'decimals') return parseInt(callResponse)
+
+      try {
+        return ERC20.decodeOutput({ method, data: callResponse })[0]
+      } catch (err) {
+        // sometimes ERC20s violate the standard and use 'bytes32' type instead of 'string'
+        if (err.message.includes('overflow') && callResponse) {
+          const hex = ERC20BytesParams.decodeOutput({ method, data: callResponse })[0]
+          const rawName = Buffer.from(hex.split('0x')[1], 'hex').toString()
+
+          // trims 'Maker\x00\x00\x00...' to 'Maker'
+          return rawName.slice(0, rawName.indexOf('\x00'))
+        }
+      }
+    })
+  )
+
+  const response = paramNames.reduce(
+    (accumulatedObj, paramName, index) => ({
+      ...accumulatedObj,
+      [paramName]: paramValues[index],
+    }),
+    {}
+  )
+  erc20ParamsCache[cacheKey] = response
+
+  return response
+}

package/package/src/etherscan/account.js

@@ -0,0 +1,49 @@
+import assert from 'assert'
+import request from './request'
+
+const isValidResponseCheck = (x) =>
+  (x.status === '1' && x.message === 'OK') || x.message === 'No transactions found'
+const _request = async (...args) => request(isValidResponseCheck, 'account', ...args)
+
+export async function fetchBalance(address) {
+  const balance = await _request('balance', { address })
+
+  const isValid = /^[0-9]+$/.test(balance)
+  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
+
+  return balance
+}
+
+export async function fetchTxlist(address, options) {
+  const params = { startblock: 0, endblock: 'latest', ...options, address }
+  const txlist = await _request('txlist', params)
+
+  // simple check
+  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
+
+  return txlist
+}
+
+export async function fetchTxlistinternal(address, options) {
+  const params = { startblock: 0, endblock: 'latest', ...options, address }
+  const txlist = await _request('txlistinternal', params)
+
+  // simple check
+  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
+
+  return txlist
+}
+
+export async function tokenBalance(token, address) {
+  const params = {
+    [token.length === 42 ? 'contractaddress' : 'tokenname']: token,
+    address,
+    tag: 'latest',
+  }
+  const balance = await _request('tokenbalance', params)
+
+  const isValid = /^[0-9]+$/.test(balance)
+  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
+
+  return balance
+}

package/package/src/etherscan/index.js

@@ -0,0 +1,48 @@
+import {
+  fetchBalance as _fetchBalance,
+  fetchTxlist as _fetchTxlist,
+  fetchTxlistinternal as _fetchTxlistinternal,
+  tokenBalance as _tokenBalance,
+} from './account'
+import {
+  sendRawTransaction as _sendRawTransaction,
+  getTransactionCount as _getTransactionCount,
+  getTransactionReceipt as _getTransactionReceipt,
+  estimateGas as _estimateGas,
+  getCode as _getCode,
+  gasPrice as _gasPrice,
+  ethCall as _ethCall,
+} from './proxy'
+import { setEtherscanApiKey } from './request'
+import { getLogs as _getLogs } from './logs'
+import createWebSocket from './ws'
+
+export const ETHERSCAN_WS_URL = 'wss://socket.etherscan.io/wshandler'
+
+export const fetchBalance = _fetchBalance
+export const fetchTxlist = _fetchTxlist
+export const fetchTxlistinternal = _fetchTxlistinternal
+export const tokenBalance = _tokenBalance
+
+export const sendRawTransaction = _sendRawTransaction
+export const getTransactionCount = _getTransactionCount
+export const getTransactionReceipt = _getTransactionReceipt
+export const estimateGas = _estimateGas
+export const getCode = _getCode
+export const gasPrice = _gasPrice
+
+export const getLogs = _getLogs
+
+export const setApiKey = setEtherscanApiKey
+
+export const ws = createWebSocket(ETHERSCAN_WS_URL)
+
+export const ethCall = _ethCall
+
+export function filterTxsSent(addr, etherscanTxs) {
+  return etherscanTxs.filter((tx) => tx.from.toLowerCase() === addr.toLowerCase())
+}
+
+export function filterTxsReceived(addr, etherscanTxs) {
+  return etherscanTxs.filter((tx) => tx.to.toLowerCase() === addr.toLowerCase())
+}

package/package/src/etherscan/logs.js

@@ -0,0 +1,16 @@
+import assert from 'assert'
+import request from './request'
+
+const isValidResponseCheck = (x) =>
+  (x.status === '1' && x.message === 'OK') || x.message === 'No records found'
+const _request = async (...args) => request(isValidResponseCheck, 'logs', ...args)
+
+export async function getLogs(address, fromBlock, toBlock, options) {
+  const params = { ...options, address, fromBlock, toBlock }
+  const events = await _request('getLogs', params)
+
+  // simple check
+  assert(Array.isArray(events), `Invalid transactions: ${events}`)
+
+  return events
+}

package/package/src/etherscan/proxy.js

@@ -0,0 +1,47 @@
+import request from './request'
+
+const isValidResponseCheck = (x) => x.result !== undefined
+const _request = async (...args) => request(isValidResponseCheck, 'proxy', ...args)
+
+export async function sendRawTransaction(data) {
+  const txhash = await _request('eth_sendRawTransaction', { hex: '0x' + data })
+
+  const isValidTxHash = /^0x[0-9a-fA-F]{64}$/.test(txhash)
+  if (!isValidTxHash) throw new Error(`Invalid tx hash: ${txhash}`)
+
+  return txhash.slice(2)
+}
+
+export async function getTransactionCount(address, tag = 'latest') {
+  return _request('eth_getTransactionCount', { address, tag })
+}
+
+export async function getTransactionReceipt(txhash) {
+  return _request('eth_getTransactionReceipt', { txhash })
+}
+
+export async function estimateGas(data) {
+  return _request('eth_estimateGas', data)
+}
+
+export async function getCode(address) {
+  const code = await _request('eth_getCode', { address })
+
+  const isValidCode = /^0x[0-9a-fA-F]*$/.test(code) && code.length % 2 === 0
+  if (!isValidCode) throw new Error(`Invalid address code: ${code}`)
+
+  return code
+}
+
+export async function gasPrice() {
+  const price = await _request('eth_gasPrice')
+
+  const isValidPrice = /^0x[0-9a-fA-F]+$/.test(price)
+  if (!isValidPrice) throw new Error(`Invalid price: ${price}`)
+
+  return price
+}
+
+export async function ethCall(data) {
+  return _request('eth_call', data)
+}

package/package/src/etherscan/request.js

@@ -0,0 +1,25 @@
+import ms from 'ms'
+import makeConcurrent from 'make-concurrent'
+import fetchival from 'fetchival'
+// The module in desktop explicitly sets node-fetch. Do we need this?
+// import fetch from '../fetch'
+// fetchival.fetch = fetch
+
+const ETHERSCAN_API_URL = 'https://api.etherscan.io/api'
+const DEFAULT_ETHERSCAN_API_KEY = 'XM3VGRSNW1TMSIR14I9MVFP15X74GNHTRI'
+
+let etherscanApiKey = DEFAULT_ETHERSCAN_API_KEY
+
+export function setEtherscanApiKey(apiKey) {
+  etherscanApiKey = apiKey || DEFAULT_ETHERSCAN_API_KEY
+}
+
+export default makeConcurrent(
+  async function(isValidResponseCheck, module, action, params = {}) {
+    const queryParams = { ...params, module, action, apiKey: etherscanApiKey }
+    const data = await fetchival(ETHERSCAN_API_URL, { timeout: ms('15s') }).get(queryParams)
+    if (!isValidResponseCheck(data)) throw new Error(`Invalid response: ${JSON.stringify(data)}`)
+    return data.result
+  },
+  { concurrency: 3 }
+)

package/package/src/etherscan/ws.js

@@ -0,0 +1,88 @@
+import { EventEmitter } from 'events'
+import ms from 'ms'
+import WebSocket from '../websocket'
+
+const RECONNECT_INTERVAL = ms('10s')
+const PING_INTERVAL = ms('20s')
+
+export default function createWebSocket(url) {
+  const addresses = new Set()
+  const events = new EventEmitter().setMaxListeners(20)
+  const pingMessage = JSON.stringify({ event: 'ping' })
+  let ws
+  let wsOpened = false
+  let opened = false
+  let openTimeoutId
+  let pingIntervalId
+
+  function subscribeAddress(address) {
+    const data = JSON.stringify({ event: 'txlist', address })
+    ws.send(data)
+  }
+
+  function onMessage(data) {
+    data = JSON.parse(data)
+    switch (data.event) {
+      case 'txlist':
+        for (const tx of data.result) events.emit(`address-${data.address}`, tx)
+        break
+
+      case 'subscribe-txlist':
+        const match = data.message.toLowerCase().match(/0x[0-9a-f]{40}/)
+        if (match && data.status === '1') events.emit(`address-${match[0]}-subscribed`)
+        else ws.close()
+        break
+    }
+  }
+
+  function isOpened() {
+    return wsOpened
+  }
+
+  function open() {
+    opened = true
+    clearTimeout(openTimeoutId)
+    if (ws) return
+
+    ws = new WebSocket(url)
+
+    ws.on('message', (data) => {
+      try {
+        onMessage(data)
+      } catch (err) {}
+    })
+    ws.once('open', () => {
+      for (const address of addresses.values()) subscribeAddress(address)
+      pingIntervalId = setInterval(() => ws && ws.send(pingMessage), PING_INTERVAL)
+      wsOpened = true
+      events.emit('open')
+    })
+    ws.once('close', () => {
+      ws = null
+      clearInterval(pingIntervalId)
+      if (opened) openTimeoutId = setTimeout(open, RECONNECT_INTERVAL)
+      wsOpened = false
+      events.emit('close')
+    })
+  }
+
+  function close() {
+    opened = false
+    clearTimeout(openTimeoutId)
+    if (!ws) return
+
+    ws.close()
+    ws = null
+  }
+
+  function watch(address) {
+    address = address.toLowerCase()
+
+    if (addresses.has(address)) return
+    addresses.add(address)
+
+    if (wsOpened) subscribeAddress(address)
+  }
+
+  return { events, isOpened, open, close, watch }
+}

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

@@ -0,0 +1,242 @@
+import urlJoin from 'url-join'
+import url from 'url'
+import fetchival from 'fetchival'
+import ms from 'ms'
+import createWebSocket from './ws'
+import { retry } from '@exodus/simple-retry'
+import SolidityContract from '@exodus/solidity-contract'
+import { bufferToHex } from '@exodus/ethereumjs-util'
+import { randomUUID } from '@exodus/crypto/randomUUID'
+
+const RETRY_DELAYS = ['10s']
+
+export function create(defaultURL) {
+  let API_URL = defaultURL
+  const ws = createWebSocket(() => {
+    // eslint-disable-next-line
+    const obj = url.parse(API_URL)
+    obj.protocol = 'wss:'
+    return url.format(obj)
+  })
+
+  async function request(module, params = {}, { version = 'v1', method = 'get' } = {}) {
+    const url = urlJoin(version === 'v1' ? API_URL : API_URL.replace('v1', version), module)
+    try {
+      return await fetchival(url, { timeout: ms('15s') })[method](params)
+    } catch (err) {
+      let nerr = err
+      if (err.response && err.response.status === 500) {
+        try {
+          const data = await err.response.json()
+          const msg = data.error.replace(/^RPC error \(code: -\d+\): /, '')
+          nerr = new Error(msg)
+        } catch (err) {}
+        nerr.finalError = true
+      }
+
+      throw nerr
+    }
+  }
+
+  // Default retry function
+  const requestWithRetry = retry(request, { delayTimesMs: RETRY_DELAYS })
+
+  return {
+    getURL() {
+      return API_URL
+    },
+
+    setURL(newURL) {
+      if (newURL === API_URL) return // prevents useless WS reconnections
+
+      API_URL = newURL || defaultURL
+
+      if (ws.isCreated()) {
+        ws.close()
+        ws.open()
+      }
+    },
+
+    stop() {
+      if (ws.isCreated()) {
+        ws.close()
+      }
+    },
+
+    ws,
+
+    async getBalance(address, opts) {
+      opts = { startblock: 'earliest', endblock: 'pending', ...opts }
+      return requestWithRetry('balance', { address, from: opts.startblock, to: opts.endblock })
+    },
+
+    async getBalanceProxied(address, tag = 'latest') {
+      return requestWithRetry('proxy', { method: 'eth_getBalance', address, tag })
+    },
+
+    async balanceOf(address, tokenAddress, tag = 'latest') {
+      const contract = SolidityContract.simpleErc20(tokenAddress)
+      const callData = contract.balanceOf.build(address)
+      const data = {
+        data: bufferToHex(callData),
+        to: tokenAddress,
+        tag,
+      }
+      const result = await retry(this.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
+      return {
+        confirmed: {
+          [tokenAddress]: parseInt(result, 16),
+        },
+      }
+    },
+
+    async getHistory(address, opts) {
+      opts = { startblock: 'earliest', endblock: 'pending', limit: 1000, ...opts }
+      return requestWithRetry('history', {
+        address,
+        from: opts.startblock,
+        to: opts.endblock,
+        limit: opts.limit,
+      })
+    },
+
+    async getHistoryV2(address, opts = {}) {
+      return requestWithRetry(
+        'history',
+        {
+          address,
+          ...opts,
+        },
+        { version: 'v2' }
+      )
+    },
+
+    async gasPrice() {
+      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
+    },
+
+    async getTransactionCount(address, tag = 'latest') {
+      return requestWithRetry('proxy', { method: 'eth_getTransactionCount', address, tag })
+    },
+
+    async getTransactionByHash(hash) {
+      return requestWithRetry('proxy', { method: 'eth_getTransactionByHash', hash })
+    },
+
+    async getTransactionReceipt(txhash) {
+      return requestWithRetry('proxy', { method: 'eth_getTransactionReceipt', txhash })
+    },
+
+    async getCode(address, tag = 'latest') {
+      return requestWithRetry('proxy', { method: 'eth_getCode', address, tag })
+    },
+
+    async getStorageAt({ address, slot, tag = 'latest' }) {
+      return requestWithRetry('proxy', { method: 'eth_getStorageAt', address, slot, tag })
+    },
+
+    async isContract(address) {
+      const code = await requestWithRetry('proxy', { method: 'eth_getCode', address })
+      return code.length > 2
+    },
+
+    async sendRawTransaction(data) {
+      const hex = data.startsWith('0x') ? data : '0x' + data
+      return requestWithRetry('proxy', { method: 'eth_sendRawTransaction', hex })
+    },
+
+    async estimateGas(data, tag = 'latest') {
+      return requestWithRetry('proxy', { method: 'eth_estimateGas', ...data, tag })
+    },
+
+    /**
+     * Hits a magnifier endpoint returning maximum gas limit that a specified
+     * contract along with method consumed in the past.
+     * @param opts : Object with parameters
+     * @returns {Promise<*>}
+     */
+    async getGasEstimation({ address, data }) {
+      return requestWithRetry('gas-estimation', {
+        address,
+        data,
+      })
+    },
+
+    async ethCall(data, tag = 'latest') {
+      return request('proxy', { method: 'eth_call', ...data, tag })
+    },
+
+    async blockNumber() {
+      return requestWithRetry('proxy', { method: 'eth_blockNumber' })
+    },
+
+    async getBlockByNumber(number, isFullTransactions = false) {
+      return requestWithRetry('proxy', {
+        method: 'eth_getBlockByNumber',
+        number,
+        isFullTransactions,
+      })
+    },
+
+    async getLogs(params) {
+      return requestWithRetry('proxy', { method: 'eth_getLogs', ...params })
+    },
+
+    async simulateRawTransaction(rawTransaction, applyPending = true) {
+      rawTransaction = rawTransaction.replace('0x', '')
+      return request('proxy', {
+        method: 'debug_simulateRawTransaction',
+        rawTransaction,
+        applyPending,
+      })
+    },
+
+    async getCoinbase() {
+      return request('proxy', {
+        method: 'eth_coinbase',
+      })
+    },
+
+    async getBlockByHash(blockHash, fullTx = false) {
+      return request('proxy', {
+        method: 'eth_getBlockByHash',
+        blockHash,
+        fullTx,
+      })
+    },
+
+    async getBlockTransactionCountByHash(blockHash) {
+      return request('proxy', {
+        method: 'eth_getBlockTransactionCountByHash',
+        blockHash,
+      })
+    },
+
+    async getBlockTransactionCountByNumber(quantityOrTag) {
+      return request('proxy', {
+        method: 'eth_getBlockTransactionCountByNumber',
+        quantityOrTag,
+      })
+    },
+
+    async getCompilers() {
+      return request('proxy', {
+        method: 'eth_getCompilers',
+      })
+    },
+
+    async getNetVersion() {
+      return request('proxy', {
+        method: 'net_version',
+      })
+    },
+
+    async proxyToCoinNode(requestData) {
+      if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
+      if (!requestData.id) requestData.id = randomUUID()
+      if (!requestData.params) requestData.params = []
+
+      return request('proxy', requestData, { version: 'v2', method: 'post' })
+    },
+  }
+}