@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.0

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

@@ -0,0 +1,306 @@
+import { createConsoleLogger } from '@exodus/asset-lib'
+import EventEmitter from 'eventemitter3'
+import assert from 'minimalistic-assert'
+
+const createSubscriptionName = (network) => {
+  return `v1/transactions/${network}`
+}
+
+const createSubscriptionKey = ({ subscriptionName, address }) => {
+  return `${subscriptionName}|${address}`
+}
+
+const parseSubscriptionKey = (subscriptionKey) => {
+  const [subscriptionName, address] = subscriptionKey.split('|')
+
+  return {
+    subscriptionName,
+    subscriptionAddress: address,
+  }
+}
+
+/**
+ * @typedef subscribeWalletAddresses
+ * @property {string} network - The network identifier
+ * @property {string} address - The wallet address to subscribe
+ */
+
+export default class WsGateway extends EventEmitter {
+  #socket = null
+  #pendingOutboundMessages = []
+  // Dedup subscriptions to reduce workload on server and resubscribe after closing
+  #subscriptions = new Set()
+  #reconnectionTimeoutId = null
+  #uri = null
+  #logger = createConsoleLogger(`@exodus/ws-gateway`)
+
+  constructor({ uri }) {
+    super()
+    assert(typeof uri === 'string', 'expected string uri')
+
+    this.#uri = uri
+  }
+
+  _handlers = {
+    message: ({ target, data }) => {
+      if (target !== this.#socket) return
+      try {
+        const msg = JSON.parse(data)
+
+        if (Array.isArray(msg)) {
+          for (const item of msg) {
+            this.#handleMessage(item)
+          }
+
+          return
+        }
+
+        this.#handleMessage(msg)
+      } catch (error) {
+        this.#logger.error('WS gateway on message error', { error })
+      }
+    },
+    close: ({ target, code, reason }) => {
+      if (target !== this.#socket) return
+      this.#reconnect({ code, reason })
+    },
+    open: ({ target }) => {
+      if (target !== this.#socket) return
+      this.#flushPendingOutbound()
+      this.emit('opened')
+    },
+    error: ({ target }) => {
+      if (target !== this.#socket) return
+      this.#reconnect({ code: 0, reason: 'Error' })
+    },
+  }
+
+  getSocket() {
+    return this.#socket
+  }
+
+  getSubscriptions() {
+    return this.#subscriptions
+  }
+
+  setServer(uri) {
+    this.#uri = uri || this.#uri
+  }
+
+  start() {
+    if (this.#socket) {
+      return
+    }
+
+    this.#socket = new WebSocket(this.#uri)
+
+    this.#socket.addEventListener('message', this._handlers.message)
+    this.#socket.addEventListener('close', this._handlers.close)
+    this.#socket.addEventListener('open', this._handlers.open)
+    this.#socket.addEventListener('error', this._handlers.error)
+  }
+
+  #reconnect({ code, reason } = {}) {
+    this.#logger.warn(`Reconnect. Code ${code}, ${reason || 'Empty reason'}`)
+
+    this.#clearSocketListeners()
+
+    if (this.#socket) {
+      if ([WebSocket.OPEN, WebSocket.CONNECTING].includes(this.#socket.readyState)) {
+        this.#socket.close()
+      }
+
+      this.#socket = null
+    }
+
+    clearTimeout(this.#reconnectionTimeoutId)
+    this.#subscriptions.clear()
+    this.#pendingOutboundMessages = []
+
+    this.#reconnectionTimeoutId = setTimeout(() => {
+      this.start()
+      clearTimeout(this.#reconnectionTimeoutId)
+    }, 2500)
+  }
+
+  unsubscribeWalletAddresses({ network, addresses = [] } = {}) {
+    assert(network, '"network" is required')
+
+    const unsubscribeName = createSubscriptionName(network)
+
+    const payload = []
+
+    const addressesSet = new Set(addresses)
+
+    for (const subscriptionKey of this.#subscriptions) {
+      const { subscriptionName, subscriptionAddress } = parseSubscriptionKey(subscriptionKey)
+      if (subscriptionName !== unsubscribeName) continue
+
+      // Unsubscribe whole network
+      if (addressesSet.size === 0) {
+        if (!payload.some((item) => item.subscription === subscriptionName)) {
+          payload.push({
+            subscription: subscriptionName,
+          })
+        }
+
+        this.#subscriptions.delete(subscriptionKey)
+        continue
+      }
+
+      if (addressesSet.has(subscriptionAddress)) {
+        payload.push({
+          subscription: subscriptionName,
+          entityId: subscriptionAddress,
+        })
+        this.#subscriptions.delete(subscriptionKey)
+      }
+    }
+
+    if (payload.length === 0) {
+      return
+    }
+
+    this.#sendMessage({
+      eventName: 'unsubscribe',
+      payload,
+    })
+  }
+
+  /**
+   * @param {Array<subscribeWalletAddresses>} subscriptions
+   */
+  subscribeWalletAddresses({ network, addresses }) {
+    assert(network, '"network" is required')
+    const payload = []
+
+    for (const address of addresses) {
+      const subscriptionName = createSubscriptionName(network)
+      const subscriptionKey = createSubscriptionKey({ subscriptionName, address })
+
+      if (this.#subscriptions.has(subscriptionKey)) {
+        continue
+      }
+
+      payload.push({
+        subscription: subscriptionName,
+        entityId: address,
+      })
+    }
+
+    if (payload.length === 0) {
+      return
+    }
+
+    this.#sendMessage({
+      eventName: 'subscribe',
+      payload,
+    })
+  }
+
+  #sendMessage(message) {
+    if (!this.#socket) {
+      this.start()
+    }
+
+    if (!this.#socket) {
+      return
+    }
+
+    if (this.#socket.readyState === WebSocket.OPEN) {
+      this.#socket.send(JSON.stringify(message))
+      return
+    }
+
+    this.#pendingOutboundMessages.push(message)
+  }
+
+  #flushPendingOutbound() {
+    if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
+      return
+    }
+
+    const pending = this.#pendingOutboundMessages
+    this.#pendingOutboundMessages = []
+
+    for (const message of pending) {
+      this.#socket.send(JSON.stringify(message))
+    }
+  }
+
+  #handleMessage(message) {
+    switch (message.type) {
+      case 'new_transactions': {
+        const { subscription, entityId, payload } = message
+        const network = subscription.split('/')[2]
+
+        for (const transaction of payload.transactions) {
+          this.emit(`${network}:new_transaction`, {
+            address: entityId,
+            transaction,
+            cursor: payload.cursor,
+          })
+        }
+
+        break
+      }
+
+      case 'connection_ack': {
+        this.emit('connected', message)
+        break
+      }
+
+      case 'subscribe_ack': {
+        const { subscription, entityId } = message
+
+        const subscriptionKey = createSubscriptionKey({
+          subscriptionName: subscription,
+          address: entityId,
+        })
+        this.#subscriptions.add(subscriptionKey)
+
+        this.emit('subscribed', message)
+        break
+      }
+
+      case 'error': {
+        this.#logger.error('Error from server', message)
+        this.emit('error', message)
+        break
+      }
+
+      default: {
+        break
+      }
+    }
+  }
+
+  #clearSocketListeners() {
+    if (!this.#socket) return
+
+    this.#socket.removeEventListener('message', this._handlers.message)
+    this.#socket.removeEventListener('close', this._handlers.close)
+    this.#socket.removeEventListener('open', this._handlers.open)
+    this.#socket.removeEventListener('error', this._handlers.error)
+  }
+
+  dispose(network, addresses) {
+    this.unsubscribeWalletAddresses({ network, addresses })
+    this.removeAllListeners(`${network}:new_transaction`)
+
+    if (this.#subscriptions.size > 0) {
+      return
+    }
+
+    this.#flushPendingOutbound()
+    this.#clearSocketListeners()
+
+    clearTimeout(this.#reconnectionTimeoutId)
+
+    if (this.#socket && [WebSocket.OPEN, WebSocket.CONNECTING].includes(this.#socket.readyState)) {
+      this.#socket.close()
+    }
+
+    this.#socket = null
+  }
+}

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

@@ -1,6 +1,5 @@
+import EventEmitter from 'events/events.js' // forces it to use the module from node_modules
 import ms from 'ms'
-import EventEmitter from 'events/' // '/' forces it to use the module from node_modules
-import WebSocket from '../websocket'
 
 const RECONNECT_INTERVAL = ms('10s')
 const PING_INTERVAL = ms('10s')

package/src/fee-data/EthLikeFeeData.js

@@ -0,0 +1,81 @@
+import { FeeData } from '@exodus/asset-lib'
+import {
+  mapCurrency as defaultMapCurrency,
+  modelToJSON,
+} from '@exodus/asset-lib/src/utils/index.js'
+import { isNumberUnit } from '@exodus/currency'
+import lodash from 'lodash'
+
+const { isEmpty, isEqual } = lodash
+
+const PRE_EIP1559_UNIT_KEYS_GUARD = ['gasPrice']
+const EIP1559_UNIT_KEYS_GUARD = ['gasPrice', 'baseFeePerGas']
+
+export const bound = ({ val, multiplier, max, min }) => {
+  if (!isNumberUnit(val)) return val
+
+  if (multiplier) {
+    val = val.mul(multiplier)
+  }
+
+  if (max) {
+    val = val.lte(max) ? val : max
+  }
+
+  if (min) {
+    val = val.gte(min) ? val : min
+  }
+
+  return val
+}
+
+const mapCurrency = ({ currency, config }) => {
+  const { eip1559Enabled } = config
+  return defaultMapCurrency(
+    config,
+    [currency],
+    eip1559Enabled ? EIP1559_UNIT_KEYS_GUARD : PRE_EIP1559_UNIT_KEYS_GUARD
+  )
+}
+
+const boundFactory =
+  ({ config }) =>
+  (val) => {
+    const { multiplier, max, min } = config
+    return bound({ val, multiplier, max, min })
+  }
+
+export class EthLikeFeeData extends FeeData {
+  constructor({ currency, config }) {
+    super({ currency, config, mainKey: 'gasPrice' })
+    Object.assign(this, mapCurrency({ currency, config }))
+  }
+
+  update(config = {}) {
+    if (isEmpty(config)) return this
+
+    config = super.update(config)
+
+    if (config.eip1559Enabled) {
+      const bound = boundFactory({ config })
+
+      const { baseFeePerGas, tipGasPrice = this.currency.ZERO } = config
+
+      const enforcedEffectiveGasPrice = bound(baseFeePerGas.add(tipGasPrice))
+
+      // When the `effectiveGasPrice` is lower, we'll increase the
+      // `tipGasPrice` to ensure we meet the `enforcedEffectiveGasPrice`.
+      //
+      // Conversely, when the `effectiveGasPrice` is too high, we'll
+      // try to reduce the `tipGasPrice` where possible, but whilst
+      // maintaining the `baseFeePerGas`, since this is the minimum
+      // for the current network.
+      Object.assign(config, {
+        tipGasPrice: enforcedEffectiveGasPrice.sub(baseFeePerGas).clampLowerZero(),
+      })
+    }
+
+    if (isEqual(this.toJSON(), modelToJSON({ ...config }))) return this
+    return new this.constructor({ config, currency: this.currency })
+  }
+}

package/src/fee-data/index.js

@@ -0,0 +1,54 @@
+import assert from 'minimalistic-assert'
+
+import { EthLikeFeeData } from './EthLikeFeeData.js'
+
+export const createFeeDataConfigDefaults = ({ currency, feeDataConfig }) => {
+  const shared = {
+    tipGasPrice: '0 Gwei',
+    fuelThreshold: '0 Gwei',
+    gasPriceMinimumRate: 0.6,
+    gasPriceMaximumRate: 1.3,
+    gasPriceMultiplier: 1,
+  }
+
+  if (feeDataConfig.eip1559Enabled === true) {
+    assert(feeDataConfig.baseFeePerGas, 'baseFeePerGas is required')
+    const baseFeePerGas = currency.parse(feeDataConfig.baseFeePerGas)
+    const gasPrice = feeDataConfig.gasPrice
+      ? currency.parse(feeDataConfig.gasPrice)
+      : baseFeePerGas.mul(1.5)
+    return {
+      gasPrice: gasPrice.toBaseString({ unit: true }),
+      baseFeePerGas: baseFeePerGas.toBaseString({ unit: true }),
+      eip1559Enabled: feeDataConfig.eip1559Enabled,
+      ...shared,
+      ...feeDataConfig,
+    }
+  }
+
+  if (feeDataConfig.eip1559Enabled === false) {
+    assert(feeDataConfig.gasPrice, 'gasPrice is required')
+    const gasPrice = currency.parse(feeDataConfig.gasPrice)
+    return {
+      gasPrice: gasPrice.toBaseString({ unit: true }),
+      max: gasPrice.mul(5).toBaseString({ unit: true }),
+      min: gasPrice.div(5).toBaseString({ unit: true }),
+      eip1559Enabled: feeDataConfig.eip1559Enabled,
+      ...shared,
+      ...feeDataConfig,
+    }
+  }
+
+  return {
+    gasPrice: '0.02 Gwei',
+    baseFeePerGas: '0.02 Gwei',
+    eip1559Enabled: true,
+    ...shared,
+    ...feeDataConfig,
+  }
+}
+
+export const createFeeData = ({ currency, feeDataConfig }) => {
+  const config = createFeeDataConfigDefaults({ currency, feeDataConfig })
+  return new EthLikeFeeData({ config, currency })
+}

package/src/fee-utils.js

@@ -0,0 +1,229 @@
+import assert from 'minimalistic-assert'
+
+/**
+ * Returns augmented `feeConfig` values manipulated using the `feeData`,
+ * for example, like multiplying the `gasPrice`. This helps us to apply
+ * modifications to values before presenting them to the consumer.
+ */
+export const refineFeeConfig = ({ feeAsset, feeConfig, gasPriceBump, gasPriceMultiplier }) => {
+  const fromString = (str) => {
+    assert(typeof str === 'string', 'expected string')
+    return feeAsset.currency.parse(str)
+  }
+
+  try {
+    const { gasPrice, baseFeePerGas, tipGasPrice, ...extras } = feeConfig
+
+    gasPriceMultiplier ||= 1
+    gasPriceBump ||= feeAsset.currency.ZERO
+
+    if (!baseFeePerGas) {
+      const nextGasPrice = fromString(gasPrice).mul(gasPriceMultiplier).add(gasPriceBump)
+      return {
+        ...extras,
+        gasPrice: nextGasPrice.toBaseString({ unit: true }),
+      }
+    }
+
+    const nextBaseFeePerGas = fromString(baseFeePerGas).mul(gasPriceMultiplier)
+    const nextTipGasPrice = tipGasPrice
+      ? fromString(tipGasPrice).mul(gasPriceMultiplier).add(gasPriceBump)
+      : gasPriceBump
+
+    return {
+      ...extras,
+      baseFeePerGas: nextBaseFeePerGas.toBaseString({ unit: true }),
+      tipGasPrice: nextTipGasPrice.toBaseString({ unit: true }),
+      gasPrice: nextBaseFeePerGas.add(nextTipGasPrice).toBaseString({ unit: true }),
+    }
+  } catch (e) {
+    console.error(
+      'Unable to rewrite feeConfig - gas prices will not be amplified using the `gasPriceMultiplier`.',
+      e
+    )
+    return feeConfig
+  }
+}
+
+const canNormalizeToBigInt = (val) =>
+  typeof val === 'string' || typeof val === 'number' || typeof val === 'bigint'
+
+// Returns a `bigint`ified version of the supplied value.
+export const ensureBigInt = (val) => {
+  assert(canNormalizeToBigInt(val), `unable to normalize ${String(val)}`)
+  return BigInt(val)
+}
+
+export const getOptionalBigInt = (fetchedGasPrices, prop) => {
+  const val = fetchedGasPrices?.[prop]
+  return canNormalizeToBigInt(val) ? BigInt(val) : null
+}
+
+const calculateEthLikeFeeMonitorUpdateNonEip1559 = async ({ gasPrice }) => ({
+  gasPrice: `${gasPrice.toString()} wei`,
+})
+
+export const getBaseFeePerGasFromServerOrNull = async ({ feeAsset }) => {
+  try {
+    const { server } = feeAsset
+    return ensureBigInt(await server.getBaseFeePerGas())
+  } catch {
+    return null
+  }
+}
+
+// HACK: If the `baseFeePerGas` has not been defined for a network,
+//       or due to issues with the `baseFeePerGas` being returned
+//       as `0` from WebSockets, we'll make a fresh attempt to query
+// .     the RPC here. If that still doesn't work we'll return `null`.
+const getBaseFeePerGasOrNull = async ({ feeAsset, fetchedGasPrices }) => {
+  const baseFeePerGas = getOptionalBigInt(fetchedGasPrices, 'baseFeePerGas')
+
+  if (typeof baseFeePerGas === 'bigint' && baseFeePerGas > BigInt('0')) return baseFeePerGas
+
+  return getBaseFeePerGasFromServerOrNull({ feeAsset })
+}
+
+export const calculateEthLikeFeeMonitorUpdateEip1559 = async ({
+  feeAsset,
+  fetchedGasPrices,
+  gasPrice: defaultGasPrice,
+}) => {
+  // Determine the `baseFeePerGas`, if possible.
+  let baseFeePerGas = await getBaseFeePerGasOrNull({ feeAsset, fetchedGasPrices })
+
+  // Some backends will return a `nextBaseFeePerGas`, which
+  // provides us more information about pricing in an upcoming
+  // block.
+  //
+  // As a precaution, rather than choose this value unconditionally,
+  // we'll aim to use the larger between the two (where defined).
+  const nextBaseFeePerGas = getOptionalBigInt(fetchedGasPrices, 'nextBaseFeePerGas')
+  if (typeof nextBaseFeePerGas === 'bigint' && nextBaseFeePerGas > BigInt(baseFeePerGas || 0)) {
+    baseFeePerGas = nextBaseFeePerGas
+  }
+
+  // Knowing the `baseFeePerGas` is required for EIP-1559 networks,
+  // so we if we haven't found one, we cannot continue.
+  if (typeof baseFeePerGas !== 'bigint') throw new Error('expected baseFeePerGas')
+
+  // HACK: Enforce our expectations that the `gasPrice` must be
+  //       at least the `baseFeePerGas`.
+  const gasPrice = baseFeePerGas > defaultGasPrice ? baseFeePerGas : defaultGasPrice
+
+  // `eth_gasPrice` embeds the node's prevailing tip on top of the
+  // `baseFeePerGas`. Without an explicit `tipGasPrice`, `refineFeeConfig`
+  // collapses the effective gas price to the bare base fee, producing
+  // zero-tip transactions that private bundle relays drop silently.
+  const inferredTipGasPrice = gasPrice - baseFeePerGas
+
+  const defaultFeeConfig = {
+    gasPrice: `${gasPrice.toString()} wei`,
+    baseFeePerGas: `${baseFeePerGas.toString()} wei`,
+    ...(inferredTipGasPrice > BigInt(0) && {
+      tipGasPrice: `${inferredTipGasPrice.toString()} wei`,
+    }),
+  }
+
+  // Determine if there are any `rewardPercentiles` specified in the
+  // `fetchedGasPrices`. If there's nothing, we can continue as normal.
+  if (!fetchedGasPrices.hasOwnProperty('rewardPercentiles')) return defaultFeeConfig
+
+  // If `rewardPercentiles` have been defined, we aim to consume the
+  // `50`th reward percentile, and use this as the `maxPriorityFeePerGas`.
+  const maxPriorityFeePerGas50Percentile = getOptionalBigInt(
+    fetchedGasPrices.rewardPercentiles,
+    '50'
+  )
+
+  // NOTE: We do not use a `maxPriorityFeePerGas50Percentile === 0n` as
+  //       a condition for early termination, since this is a valid
+  //       (although unlikely) condition.
+  if (typeof maxPriorityFeePerGas50Percentile !== 'bigint') return defaultFeeConfig
+
+  return {
+    ...defaultFeeConfig,
+    gasPrice: `${(baseFeePerGas + maxPriorityFeePerGas50Percentile).toString()} wei`,
+    tipGasPrice: `${maxPriorityFeePerGas50Percentile.toString()} wei`,
+  }
+}
+
+/**
+ * The core logic for normalizing and interpreting cross-server
+ * fee information.
+ */
+export const calculateEthLikeFeeMonitorUpdate = async ({
+  assetClientInterface,
+  feeAsset,
+  fetchedGasPrices,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(feeAsset, 'expected feeAsset')
+  assert(fetchedGasPrices, 'expected fetchedGasPrices')
+
+  // Depending on whether `eip1559Enabled` on the client, we
+  // can choose to return different properties.
+  const { eip1559Enabled, gasPriceBump, gasPriceMultiplier } =
+    await assetClientInterface.getFeeConfig({
+      assetName: feeAsset.name,
+    })
+
+  // NOTE: The `gasPrice` is a required value for all EVM networks.
+  const gasPrice = ensureBigInt(fetchedGasPrices.gasPrice)
+
+  const feeConfig = await (eip1559Enabled
+    ? calculateEthLikeFeeMonitorUpdateEip1559({ gasPrice, feeAsset, fetchedGasPrices })
+    : calculateEthLikeFeeMonitorUpdateNonEip1559({ gasPrice }))
+
+  return refineFeeConfig({ feeAsset, feeConfig, gasPriceBump, gasPriceMultiplier })
+}
+
+/**
+ * A common handler for normalizing the handling of `FeeMonitor` updates.
+ */
+export const executeEthLikeFeeMonitorUpdate = async ({
+  assetClientInterface,
+  feeAsset,
+  fetchedGasPrices,
+}) => {
+  const nextFeeConfig = await calculateEthLikeFeeMonitorUpdate({
+    assetClientInterface,
+    feeAsset,
+    fetchedGasPrices,
+  })
+
+  // Update the `assetClientInterface` so our updated fee
+  // settings propagate through the client.
+  await assetClientInterface.updateFeeConfig({ assetName: feeAsset.name, feeConfig: nextFeeConfig })
+
+  return nextFeeConfig
+}
+
+// TODO: rename to getEffectiveGasPriceForFeeData
+export const resolveGasPrice = ({ feeData }) => {
+  assert(feeData, 'feeData is required')
+
+  if (feeData.eip1559Enabled) {
+    return feeData.tipGasPrice
+      ? feeData.baseFeePerGas.add(feeData.tipGasPrice)
+      : feeData.baseFeePerGas
+  }
+
+  return feeData.gasPrice
+}
+
+export const ensureSaneEip1559GasPriceForTipGasPrice = ({ gasPrice, tipGasPrice }) => {
+  if (!tipGasPrice || tipGasPrice.lt(gasPrice)) return gasPrice
+  return tipGasPrice
+}
+
+export const getNormalizedFeeDataForCustomFee = ({ customFee, feeData }) => {
+  const { eip1559Enabled } = feeData
+  // We must ensure maxPriorityFeePerGas <= maxFeePerGas or our transaction library throws an error
+  // It's a bit counterintuitive  since maxPriorityFeePerGas should only contain the tip,
+  // so we should be subtracting the base gas price from the custom gas price to keep just the tip
+  // but the fee is also limited by our maxFeePerGas above, so that implicitly captures the max tip.
+  // Setting this tipGasPrice to undefined will result in a legacy transaction (not an EIP1559 anymore)
+  if (eip1559Enabled && customFee) return { ...feeData, tipGasPrice: customFee }
+  return feeData
+}