@exodus/ethereum-api 9.0.2 → 10.0.0

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

@@ -1,276 +0,0 @@
-import { randomUUID } from '@exodus/crypto/randomUUID'
-import { bufferToHex } from '@exodus/ethereumjs/util'
-import fetchival from '@exodus/fetch/experimental/fetchival'
-import { retry } from '@exodus/simple-retry'
-import SolidityContract from '@exodus/solidity-contract'
-import ms from 'ms'
-
-import { fromHexToString } from '../number-utils.js'
-import { getFallbackGasPriceEstimation } from './utils.js'
-import createWebSocket from './ws.js'
-
-const RETRY_DELAYS = ['10s']
-
-export function create(defaultURL, ensAssetName) {
-  let API_URL = defaultURL
-  const ws = createWebSocket(() => {
-    const obj = new URL(API_URL)
-    obj.protocol = 'wss:'
-    return `${obj}`
-  })
-
-  function baseUrl(version = 'v1') {
-    return new URL(version === 'v1' ? API_URL : API_URL.replace('v1', version))
-  }
-
-  async function request(module, params = {}, { version = 'v1', method = 'get' } = {}) {
-    try {
-      return await fetchival(baseUrl(version), { timeout: ms('15s') })(module).method(
-        method,
-        params
-      )
-    } catch (err) {
-      let nerr = err
-      if (err.response && (err.response.status === 500 || err.response.status === 400)) {
-        try {
-          const data = await err.response.json()
-          const msg = data.error.replace(/^RPC error \(code: -\d+\): /, '')
-          nerr = new Error(msg)
-        } catch {}
-
-        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() {
-      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)
-      const balance = fromHexToString(result)
-      return {
-        confirmed: {
-          [tokenAddress]: balance,
-        },
-      }
-    },
-
-    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 getGasPriceEstimation() {
-      return getFallbackGasPriceEstimation({ server: this })
-    },
-
-    // for fee monitor
-    async getGasPrice() {
-      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
-    },
-
-    async getLatestBlock() {
-      return this.getBlockByNumber('latest')
-    },
-
-    async getBaseFeePerGas() {
-      const response = await this.getLatestBlock()
-      if (response.baseFeePerGas) {
-        return fromHexToString(response.baseFeePerGas)
-      }
-    },
-
-    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 _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
-      const hex = _data.startsWith('0x') ? _data : '0x' + _data
-      return requestWithRetry(
-        'proxy',
-        { method: 'eth_sendRawTransaction', params: [hex] },
-        { version: 'v2', method: 'post' }
-      )
-    },
-
-    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) {
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.params) requestData.params = []
-
-      return request('proxy', requestData, { version: 'v2', method: 'post' })
-    },
-  }
-}

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

@@ -1,126 +0,0 @@
-import EventEmitter from 'events/events.js' // forces it to use the module from node_modules
-import ms from 'ms'
-
-const RECONNECT_INTERVAL = ms('10s')
-const PING_INTERVAL = ms('10s')
-const MAX_RECONNECT_DELAY = ms('15s')
-
-export default function createWebSocket(getURL) {
-  const addresses = new Set()
-  const events = new EventEmitter()
-  let ws
-  let pingIntervalId = null
-  let opened = false
-  let isWSOpened = false
-  let openTimeoutId
-
-  function subscribeAddress(address) {
-    const data = JSON.stringify({ type: 'subscribe-address', address })
-    ws.send(data)
-  }
-
-  function subscribeGasPrice() {
-    const data = JSON.stringify({ type: 'subscribe-gasprice' })
-    ws.send(data)
-  }
-
-  function clearPing() {
-    clearInterval(pingIntervalId)
-    pingIntervalId = null
-  }
-
-  function onMessage(data) {
-    data = JSON.parse(data)
-    switch (data.type) {
-      case 'address':
-        events.emit(`address-${data.address}`)
-        break
-      case 'gasprice':
-        events.emit('gasprice', { gasPrice: data.gasprice, baseFeePerGas: data.baseGasPrice })
-        break
-    }
-  }
-
-  function open() {
-    opened = true
-    clearTimeout(openTimeoutId)
-    if (ws) return
-
-    ws = new WebSocket(getURL())
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = (e) => {}
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = (e) => {
-      try {
-        onMessage(e.data)
-      } catch {}
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = () => {
-      for (const address of addresses.values()) subscribeAddress(address)
-      subscribeGasPrice()
-      if (typeof ws.ping === 'function') {
-        pingIntervalId = setInterval(() => ws.ping(), PING_INTERVAL)
-      } else {
-        console.warn('Client side ping not available')
-      }
-
-      isWSOpened = true
-      events.emit('open')
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = () => {
-      ws = null
-      isWSOpened = false
-      clearPing()
-      if (opened) {
-        openTimeoutId = setTimeout(open, reconnectDelay())
-      }
-
-      events.emit('close')
-    }
-  }
-
-  function close() {
-    opened = false
-    isWSOpened = false
-    clearTimeout(openTimeoutId)
-    if (!ws) return
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = null
-    try {
-      ws.close()
-    } catch (e) {
-      if (!/WebSocket was closed before the connection was established/.test(e.message)) {
-        throw e
-      }
-    }
-
-    ws = null
-    clearPing()
-    events.emit('close')
-  }
-
-  function reconnectDelay() {
-    const min = RECONNECT_INTERVAL
-    const max = MAX_RECONNECT_DELAY
-    return Math.floor(Math.random() * (max - min + 1) + min)
-  }
-
-  function watch(address) {
-    if (addresses.has(address)) return
-    addresses.add(address)
-
-    if (ws) subscribeAddress(address)
-  }
-
-  return { events, open, close, watch, isCreated: () => !!ws, isOpened: () => isWSOpened }
-}