@exodus/ethereum-api 2.17.0 → 2.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -12,7 +12,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.5.4",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.16.0",
+    "@exodus/ethereum-lib": "^2.17.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.0.1",
@@ -29,5 +29,5 @@
     "@exodus/assets-base": "^8.0.136",
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "e29e3ae24e62456979a65ffcc383e60da4f206c4"
+  "gitHead": "b788a070aee322e4e4d1ac3e6cdd146b7a9ea691"
 }

package/package/package.json

@@ -1,33 +0,0 @@
-{
-  "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

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

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

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

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

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

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

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