@exodus/ethereum-api 2.15.1 → 2.17.0

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

@@ -0,0 +1,36 @@
+import { create } from './api'
+
+const EXODUS_ETH_SERVER_URL = 'https://geth.a.exodus.io/wallet/v1/'
+const EXODUS_ETC_SERVER_URL = 'https://getc.a.exodus.io/wallet/v1/'
+const EXODUS_BSC_SERVER_URL = 'https://bsc.a.exodus.io/wallet/v1/'
+const EXODUS_POLYGON_SERVER_URL = 'https://polygon.a.exodus.io/wallet/v1/'
+const EXODUS_AVAXC_SERVER_URL = 'https://avax-c.a.exodus.io/wallet/v1/'
+const EXODUS_FTM_SERVER_URL = 'https://fantom.a.exodus.io/wallet/v1/'
+const EXODUS_HARMONY_SERVER_URL = 'https://harmony.a.exodus.io/wallet/v1/'
+// allow self-signed certs
+// process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+export const eth = create(EXODUS_ETH_SERVER_URL)
+export const etc = create(EXODUS_ETC_SERVER_URL)
+export const bsc = create(EXODUS_BSC_SERVER_URL)
+export const polygon = create(EXODUS_POLYGON_SERVER_URL)
+export const avaxc = create(EXODUS_AVAXC_SERVER_URL)
+export const ftm = create(EXODUS_FTM_SERVER_URL)
+export const harmony = create(EXODUS_HARMONY_SERVER_URL)
+
+// exported for in-library use only.
+export const serverMap = {
+  ethereum: eth,
+  ethereumclassic: etc,
+  bsc,
+  matic: polygon,
+  avalanchec: avaxc,
+  fantommainnet: ftm,
+  harmonymainnet: harmony,
+}
+
+export function getServer(asset) {
+  const baseAssetName = asset.baseAsset.name
+  const server = serverMap[baseAssetName]
+  if (!server) throw new Error(`unsupported base asset ${baseAssetName}`)
+  return server
+}

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

@@ -0,0 +1,108 @@
+import ms from 'ms'
+import { EventEmitter } from 'events'
+import WebSocket from '../websocket'
+
+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', data.gasprice)
+        break
+    }
+  }
+
+  function open() {
+    opened = true
+    clearTimeout(openTimeoutId)
+    if (ws) return
+
+    ws = new WebSocket(getURL())
+    ws.onerror = (e) => {}
+    ws.onmessage = (e) => {
+      try {
+        onMessage(e.data)
+      } catch (err) {}
+    }
+    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')
+    }
+    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
+    ws.onerror = null
+    ws.onmessage = null
+    ws.onopen = null
+    ws.onclose = null
+    ws.close()
+    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 }
+}

package/package/src/fee-monitor/avalanchec.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { avaxc as avalancheServer } from '../exodus-eth-server'
+
+export class AvalancheFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'avalanchec',
+      getGasPrice: avalancheServer.gasPrice,
+    })
+  }
+}

package/package/src/fee-monitor/bsc.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { bsc } from '../exodus-eth-server'
+
+export class BscFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'bsc',
+      getGasPrice: bsc.gasPrice,
+    })
+  }
+}

package/package/src/fee-monitor/ethereum.js

@@ -0,0 +1,13 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { eth as ethServer } from '../exodus-eth-server'
+
+export class EthereumFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee, interval }) {
+    super({
+      updateFee,
+      assetName: 'ethereum',
+      getGasPrice: ethServer.gasPrice,
+      interval,
+    })
+  }
+}

package/package/src/fee-monitor/ethereumclassic.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { etc as etcServer } from '../exodus-eth-server'
+
+export class EthereumClassicFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'ethereumclassic',
+      getGasPrice: etcServer.gasPrice,
+    })
+  }
+}

package/package/src/fee-monitor/fantom.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { ftm as fantomServer } from '../exodus-eth-server'
+
+export class FantomFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'fantommainnet',
+      getGasPrice: fantomServer.gasPrice,
+    })
+  }
+}

package/package/src/fee-monitor/harmony.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { harmony as harmonyServer } from '../exodus-eth-server'
+
+export class HarmonyFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'harmonymainnet',
+      getGasPrice: harmonyServer.gasPrice,
+    })
+  }
+}

package/package/src/fee-monitor/index.js

@@ -0,0 +1,7 @@
+export * from './ethereum'
+export * from './ethereumclassic'
+export * from './bsc'
+export * from './polygon'
+export * from './avalanchec'
+export * from './fantom'
+export * from './harmony'

package/package/src/fee-monitor/polygon.js

@@ -0,0 +1,12 @@
+import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
+import { polygon as polygonServer } from '../exodus-eth-server'
+
+export class PolygonFeeMonitor extends EthereumLikeFeeMonitor {
+  constructor({ updateFee }) {
+    super({
+      updateFee,
+      assetName: 'matic',
+      getGasPrice: polygonServer.gasPrice,
+    })
+  }
+}

package/package/src/gas-estimation.js

@@ -0,0 +1,103 @@
+import BN from 'bn.js'
+import * as ethUtil from '@exodus/ethereumjs-util'
+import { currency2buffer, isToken } from '@exodus/ethereum-lib'
+import { estimateGas, isContractAddress } from './eth-like-util'
+
+const EXTRA_PERCENTAGE = 20
+
+// Starting with geth v1.9.14, if gasPrice is set for eth_estimateGas call, the call allowance will
+// be calculated with account's balance divided by gasPrice. If user's balance is too low,
+// the gasEstimation will fail. If gasPrice is set to '0x0', the account's balance is not
+// used to estimate gas.
+export async function estimateGasLimit(
+  asset: Object,
+  fromAddress: string,
+  toAddress: string,
+  amount: Buffer | Object,
+  data: Buffer | string,
+  gasPrice?: string = '0x',
+  extraPercentage?: number = EXTRA_PERCENTAGE
+): number {
+  const opts = {
+    from: fromAddress,
+    to: toAddress,
+    value: normalizeAmount(amount),
+    data: Buffer.isBuffer(data) ? ethUtil.bufferToHex(data) : data,
+    gasPrice: normalizeGasPrice(gasPrice),
+  }
+
+  const estimatedGas = await estimateGas({ asset, ...opts })
+  return new BN(estimatedGas.slice(2), 16)
+    .imuln(100 + extraPercentage)
+    .idivn(100)
+    .toNumber()
+}
+
+export async function fetchGasLimit({
+  asset,
+  fromAddress,
+  toAddress,
+  txInput = '0x',
+  amount,
+  feeData = {},
+  bip70,
+  isContract,
+  throwOnError = true,
+  extraPercentage,
+}) {
+  if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice)
+    return asset.name === 'ethereum' ? 65000 : 130000 // from on chain stats https://dune.xyz/queries/189123
+
+  if (!amount) amount = asset.currency.ZERO
+  if (!feeData.gasPrice) feeData.gasPrice = asset.baseAsset.currency.ZERO
+
+  const _isToken = isToken(asset)
+  if (_isToken) {
+    txInput = ethUtil.bufferToHex(
+      asset.contract.transfer.build(toAddress, amount.toBase().toString({ unit: false }))
+    )
+    amount = asset.baseAsset.currency.ZERO
+    toAddress = asset.contract.address
+  } else if (!isContract) {
+    if (isContract === undefined)
+      isContract = await isContractAddress({ asset, address: toAddress })
+    if (!isContract) return asset.gasLimit
+  }
+
+  const gasPrice = ethUtil.bufferToHex(currency2buffer(feeData.gasPrice))
+
+  try {
+    return await estimateGasLimit(
+      asset,
+      fromAddress,
+      toAddress,
+      amount,
+      txInput,
+      gasPrice,
+      extraPercentage
+    )
+  } catch (err) {
+    if (throwOnError) throw err
+    console.log('fetchGasLimit error', err)
+  }
+
+  return _isToken ? asset.gasLimit : asset.contractGasLimit
+}
+
+function normalizeAmount(amount) {
+  if (!Buffer.isBuffer(amount)) {
+    amount = currency2buffer(amount)
+  }
+
+  amount = ethUtil.bufferToHex(amount)
+  while (amount[2] === '0') amount = '0x' + amount.slice(3)
+  if (amount === '0x') amount = '0x0'
+
+  return amount
+}
+
+function normalizeGasPrice(gasPrice) {
+  while (gasPrice[2] === '0') gasPrice = '0x' + gasPrice.slice(3)
+  if (gasPrice === '0x') gasPrice = '0x0'
+  return gasPrice
+}

package/package/src/get-balances.js

@@ -0,0 +1,38 @@
+import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
+
+const fixBalance = ({ txLog, balance }) => {
+  for (const tx of txLog) {
+    // TODO: pending can only be less than a few minutes old, we can only search the latest txs to improve performance
+    if (tx.sent && tx.pending && !tx.error) {
+      // coinAmount is negative for sent tx
+      balance = balance.sub(tx.coinAmount.abs())
+      if (tx.coinAmount.unitType.equals(tx.feeAmount.unitType)) {
+        balance = balance.sub(tx.feeAmount)
+      }
+    }
+  }
+  return balance
+}
+
+/**
+ * Api method to return the balance based on either account state balances or tx history.
+ *
+ * @param asset the asset to get the balances
+ * @param txLog the txLog when the balance is transaction based
+ * @param accountState the account state when the balance is loaded from RPC
+ * @returns {{balance}|null} an object with the balance or null if the balance is unknown/zero
+ */
+export const getBalances = ({ asset, txLog, accountState }) => {
+  if (isRpcBalanceAsset(asset)) {
+    const balance =
+      asset.baseAsset.name === asset.name
+        ? accountState?.balance
+        : accountState?.tokenBalances?.[asset.name]
+    return balance && !balance.isZero ? { balance: fixBalance({ txLog, balance }) } : null
+  }
+  return txLog.size
+    ? {
+        balance: txLog.getMutations().slice(-1)[0].balance,
+      }
+    : null
+}

package/package/src/index.js

@@ -0,0 +1,11 @@
+// Ideally, we should reduce the exports to just api.
+// If the client is importing one module specifically,
+// it's breaking the encapsulation
+export * from './eth-like-util'
+export * from './fee-monitor'
+export * from './gas-estimation'
+export * from './exodus-eth-server'
+export * from './tx-log'
+export * from './get-balances'
+export * from './staking'
+export * from './simulate-tx'

package/package/src/simulate-tx/fetch-tx-preview.js

@@ -0,0 +1,21 @@
+const ETHEREUM_TX_PREVIEW_API = 'https://simulation.a.exodus.io/simulate'
+
+export async function fetchTxPreview(transaction) {
+  const response = await fetch(ETHEREUM_TX_PREVIEW_API, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      network: 'ethereum',
+      chain: 'main',
+      transactions: [transaction],
+    }),
+  })
+
+  if (!response.ok) {
+    throw new Error(await response.text())
+  }
+
+  return response.json()
+}

package/package/src/simulate-tx/index.js

@@ -0,0 +1,2 @@
+export * from './fetch-tx-preview'
+export * from './simulate-eth-tx'

package/package/src/simulate-tx/simulate-eth-tx.js

@@ -0,0 +1,86 @@
+import assets from '@exodus/assets'
+
+import { fetchTxPreview } from './fetch-tx-preview'
+import { getERC20Params } from '../eth-like-util'
+
+const ethDecimals = assets.ethereum.units.ETH
+
+const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
+
+async function getDecimals(type, assetContractAddress = null) {
+  if (type === 'erc20' && assetContractAddress) {
+    const { decimals } = await getERC20Params({
+      address: assetContractAddress,
+      assetName: 'ethereum',
+      paramNames: ['decimals'],
+    })
+
+    return decimals
+  }
+
+  return ethDecimals
+}
+
+export async function simulateAndRetrieveSideEffects(transaction) {
+  const willSend = []
+  const willReceive = []
+
+  if (!transaction.to) throw new Error(`'to' field is missing in the TX object`)
+
+  const blocknativeTxObject = {
+    to: transaction.to,
+    input: transaction.data,
+    from: transaction.from,
+    value: ethHexToInt(transaction.value),
+    gas: ethHexToInt(transaction.gas),
+    maxFeePerGas: ethHexToInt(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: ethHexToInt(transaction.maxPriorityFeePerGas),
+  }
+
+  try {
+    const simulatedTx = await fetchTxPreview(blocknativeTxObject)
+
+    const [simulatedBalanceChanges] = simulatedTx.netBalanceChanges
+
+    const [sender] =
+      simulatedBalanceChanges &&
+      simulatedBalanceChanges.filter(({ address }) => address === transaction.from)
+
+    if (sender) {
+      for (const balanceChange of sender.balanceChanges) {
+        const { delta, asset } = balanceChange
+
+        const decimal = await getDecimals(asset.type, asset.contractAddress)
+
+        if (delta.startsWith('-')) {
+          willSend.push({
+            symbol: asset.symbol,
+            balance: delta.slice(1),
+            assetType: asset.type,
+            decimal,
+          })
+        } else {
+          willReceive.push({
+            symbol: asset.symbol,
+            balance: delta,
+            assetType: asset.type,
+            decimal,
+          })
+        }
+      }
+    }
+
+    if (!willSend.length) {
+      willSend.push({
+        symbol: 'ETH',
+        balance: ethHexToInt(transaction.value).toString(),
+        assetType: 'ether',
+        decimal: ethDecimals,
+      })
+    }
+  } catch (_) {
+    throw new Error('Simulation of Ethereum transaction failed.')
+  }
+
+  return { willSend, willReceive }
+}

package/package/src/staking/fantom-staking.js

@@ -0,0 +1,115 @@
+import { createContract } from '@exodus/ethereum-lib'
+
+export const SFC_ADDRESS = '0xfc00face00000000000000000000000000000000'
+
+export class FantomStaking {
+  constructor() {
+    this.sfcContract = createContract(SFC_ADDRESS, 'fantomSfc')
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    return contract[method].build(...args)
+  }
+
+  /**
+   * Get tx data of method to delegate (stake) amount to validator
+   */
+  delegate = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'delegate', validatorId)
+  }
+
+  /**
+   * undelegate creates a transaction preparing part of the delegations
+   * to be withdrawn.
+   *
+   * Note: The amount must be lower than the total delegation amount for that account. Also,
+   * the requestId value has to be unique and previously unused numeric identifier of the new
+   * withdrawal. The actual withdraw execution, available after a lock period, will use the same
+   * request id to process the prepared withdrawal.
+   */
+  undelegate = ({ requestId, validatorId, amount }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'undelegate', validatorId, requestId, amount)
+  }
+
+  /**
+   * withdraw creates a transaction executing partial withdraw for the given
+   * prepared withdraw request.
+   *
+   * Note: The request id has to exist and has to be prepared for the withdraw to execute
+   * correctly.
+   */
+  withdraw = ({ requestId, validatorId }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'withdraw', validatorId, requestId)
+  }
+
+  /**
+   * claimRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  claimRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'claimRewards', validatorId)
+  }
+
+  /**
+   * restakeRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  restakeRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'restakeRewards', validatorId)
+  }
+
+  /**
+   * lockStake creates a transaction for locking delegation.
+   */
+  lockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'lockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * relockStake creates a transaction for re-locking delegation.
+   */
+  relockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'relockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * unlockStake creates a transaction for unlocking delegation.
+   */
+  unlockStake = ({ validatorId, amount }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'unlockStake', validatorId, amount)
+  }
+
+  #validateValidatorId = (validatorId) => {
+    if (!Number.isInteger(validatorId) || validatorId <= 0) {
+      throw new Error('Validator id must be positive unsigned integer value.')
+    }
+  }
+
+  #validateRequestId = (requestId) => {
+    if (!Number.isInteger(requestId) || requestId <= 0) {
+      throw new Error('Request id must be a valid numeric identifier.')
+    }
+  }
+
+  #validateDuration = (duration) => {
+    if (!Number.isInteger(duration)) {
+      throw new Error('The lock duration must be an integer.')
+    }
+
+    if (duration > 365 * 86400) {
+      throw new Error('The lock duration must be at most 365 days.')
+    }
+  }
+}

package/package/src/staking/index.js

@@ -0,0 +1,2 @@
+export { MaticStaking } from './matic-staking'
+export { FantomStaking } from './fantom-staking'