@exodus/ethereum-api 8.7.1 → 8.9.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.9.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.8.0...@exodus/ethereum-api@8.9.0) (2024-07-03)
+
+
+### Features
+
+* dynamic evm factory ([#2659](https://github.com/ExodusMovement/assets/issues/2659)) ([0baae82](https://github.com/ExodusMovement/assets/commit/0baae82a7f53c8808c9cd2621cf04e9960568cc6))
+
+
+### Bug Fixes
+
+* **ethereum:** false dropped tx check ([#2707](https://github.com/ExodusMovement/assets/issues/2707)) ([d05a8c8](https://github.com/ExodusMovement/assets/commit/d05a8c895563fb13120956c0081db7ebe86195d6))
+
+
+
+## [8.8.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.7.1...@exodus/ethereum-api@8.8.0) (2024-07-02)
+
+
+### Features
+
+* Attach some error reasons to create tx ([#2649](https://github.com/ExodusMovement/assets/issues/2649)) ([0f783e2](https://github.com/ExodusMovement/assets/commit/0f783e2a40079ce407b366e0f6411d279c1fb0ce)), closes [#2646](https://github.com/ExodusMovement/assets/issues/2646)
+
+
+### Bug Fixes
+
+* ethereum-api default url in servers ([#2689](https://github.com/ExodusMovement/assets/issues/2689)) ([2fc70a4](https://github.com/ExodusMovement/assets/commit/2fc70a49c05f18f6153009b1cebdd9ea522509ac))
+
+
+
 ## [8.7.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.7.0...@exodus/ethereum-api@8.7.1) (2024-06-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.7.1",
+  "version": "8.9.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -20,6 +20,7 @@
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
+    "@exodus/asset": "^1.2.0",
     "@exodus/asset-lib": "^4.2.0",
     "@exodus/assets": "^9.1.1",
     "@exodus/basic-utils": "^2.1.0",
@@ -48,7 +49,6 @@
     "ws": "^6.1.0"
   },
   "devDependencies": {
-    "@exodus/assets": "^9.1.1",
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/bsc-meta": "^1.2.2",
     "@exodus/ethereumarbone-meta": "^1.2.0",
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "0ff8ab06fea52301cc926c2b78ab812992cc5692"
+  "gitHead": "237c799e9bc8df6574be95056a999896e2503290"
 }

package/src/create-asset-plugin-factory.js

@@ -0,0 +1,162 @@
+import { createMetaDef } from '@exodus/asset'
+import { FeeData } from '@exodus/asset-lib'
+import { createAssetFactory } from './create-asset'
+import assert from 'minimalistic-assert'
+import { UnitType } from '@exodus/currency'
+
+// Move to ethereum-api for config base evm
+export const createAssetPluginFactory = (config) => {
+  assert(config, 'config is required')
+  assert(config.chainId, 'chainId is required')
+  assert(config.meta, 'config.meta is required')
+  assert(config.meta.explorerUrl, 'meta.explorerUrl is required')
+
+  const chainId = config.chainId
+  const { explorerUrl, ...meta } = config.meta
+  const name = `evm_${chainId}`
+  const ticker = `EVM${chainId}`
+  const tokenType = `EVM_${chainId}_TOKEN`
+
+  const units = {
+    wei: 0,
+    Kwei: 3,
+    Mwei: 6,
+    Gwei: 9,
+    [ticker]: config.decimals || 18,
+  }
+
+  const currency = UnitType.create(units)
+
+  // adds lots of validation in config
+  const tokenOverrides = (token) => ({
+    ...token,
+    assetType: tokenType,
+    contract: token.addresses,
+    gasLimit: meta.gasLimit || 120e3,
+  })
+
+  const blockExplorer = {
+    addressUrl: (address) => `${explorerUrl}/address/${encodeURIComponent(address)}`,
+    txUrl: (txId) => `${explorerUrl}/tx/${encodeURIComponent(txId)}`,
+  }
+
+  const assetType = 'ETHEREUM_LIKE'
+  const { asset, assetsList } = createMetaDef({
+    assetParams: {
+      ...meta,
+      name,
+      ticker,
+      units,
+      chainId,
+      assetType,
+      blockExplorer,
+    },
+    tokensParams: meta.tokens || [],
+    tokenOverrides,
+  })
+
+  const resolveFeeDataConfigDefaults = () => {
+    const shared = {
+      tipGasPrice: '0 Gwei',
+      fuelThreshold: '0 Gwei',
+      gasPriceEconomicalRate: 0.8,
+      gasPriceMinimumRate: 0.6,
+    }
+
+    if (config.eip1559Enabled === true) {
+      assert(config.baseFeePerGas, 'baseFeePerGas is required')
+      const baseFeePerGas = currency.parse(config.baseFeePerGas)
+      const gasPrice = config.gasPrice ? currency.parse(config.gasPrice) : baseFeePerGas.mul(1.5)
+      return {
+        gasPrice: gasPrice.toBaseString({ unit: true }),
+        baseFeePerGas: baseFeePerGas.toBaseString({ unit: true }),
+        max: gasPrice.mul(5).toBaseString({ unit: true }),
+        min: gasPrice.div(5).toBaseString({ unit: true }),
+        eip1559Enabled: config.eip1559Enabled,
+        ...shared,
+        ...config.feeData,
+      }
+    }
+
+    if (config.eip1559Enabled === false) {
+      assert(config.gasPrice, 'gasPrice is required')
+      const gasPrice = currency.parse(config.gasPrice)
+      return {
+        gasPrice: gasPrice.toBaseString({ unit: true }),
+        max: gasPrice.mul(5).toBaseString({ unit: true }),
+        min: gasPrice.div(5).toBaseString({ unit: true }),
+        eip1559Enabled: config.eip1559Enabled,
+        ...shared,
+        ...config.feeData,
+      }
+    }
+
+    return {
+      gasPrice: '0.02 Gwei',
+      baseFeePerGas: '0.02 Gwei',
+      eip1559Enabled: true,
+      ...shared,
+      ...config.feeData,
+    }
+  }
+
+  const feeData = new FeeData({
+    config: resolveFeeDataConfigDefaults(),
+    mainKey: 'gasPrice',
+    currency: asset.currency,
+  })
+
+  const createAsset = createAssetFactory({
+    assetsList,
+    feeData,
+    ...config.plugin,
+  })
+
+  return { name, chainId, createAsset }
+}
+
+// https://docs.metamask.io/wallet/reference/wallet_addethereumchain/
+export const fromAddEthereumChainParameterToFactoryParams = (params) => {
+  assert(params.chainId, 'chainId is required')
+  assert(params.chainName, 'chainName is required')
+  assert(params.rpcUrls?.[0], 'rpcUrls is required')
+  assert(params.blockExplorerUrls?.[0], 'blockExplorerUrls is required')
+  assert(params.nativeCurrency, 'nativeCurrency is required')
+  assert(params.nativeCurrency.symbol, 'nativeCurrency.symbol is required')
+  assert(params.nativeCurrency.decimals, 'nativeCurrency.decimals is required')
+
+  const chainId = parseInt(params.chainId.replace('0x', ''), 16)
+
+  // obvious coloring:)
+  const color =
+    params.color ||
+    '#' +
+      (chainId % 256).toString(16) +
+      ((chainId + 50) % 256).toString(16) +
+      ((chainId + 100) % 256).toString(16)
+  return {
+    chainId,
+    meta: {
+      explorerUrl: params.blockExplorerUrls[0],
+      displayName: params.chainName,
+      displayTicker: params.nativeCurrency.name || params.nativeCurrency.symbol,
+      primaryColor: color,
+      gradientColors: [color, color],
+      gradientCoords: {
+        x1: '0%',
+        y1: '0%',
+        x2: '100%',
+        y2: '100%',
+      },
+    },
+    plugin: {
+      serverUrl: params.rpcUrls?.[0],
+      confirmationsNumber: 5,
+      monitorType: 'no-history',
+      isTestnet: params.isTestnet,
+    },
+    baseFeePerGas: params.baseFeePerGas,
+    gasPrice: params.gasPrice,
+    eip1559Enabled: params.eip1559Enabled,
+  }
+}

package/src/create-asset.js

@@ -1,7 +1,7 @@
 import { connectAssetsList } from '@exodus/assets'
 import { pick } from '@exodus/basic-utils'
 import bip44Constants from '@exodus/bip44-constants/by-ticker'
-import { getBalances } from './get-balances'
+import { getBalancesFactory } from './get-balances'
 import { ClarityMonitor } from './tx-log/clarity-monitor'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor'
 import { EthereumMonitor } from './tx-log/ethereum-monitor'
@@ -108,7 +108,12 @@ export const createAssetFactory = ({
       encodePublic: encodePublicFactory({ chainId, useEip1191ChainIdChecksum }),
     }
 
-    const { createToken, getTokens } = createTokenFactory({ address, bip44, keys }, assets)
+    const getBalances = getBalancesFactory({ monitorType })
+
+    const { createToken, getTokens } = createTokenFactory(
+      { address, bip44, keys, getBalances },
+      assets
+    )
 
     const addressHasHistory = addressHasHistoryFactory({ server })
 

package/src/create-token-factory.js

@@ -1,9 +1,8 @@
 import { isPolygonClaimUndelegate, isPolygonDelegate, isPolygonUndelegate } from './staking/matic'
 import { createContract } from '@exodus/ethereum-lib'
 
-import { getBalances } from './get-balances'
-
 import { createStakingApi } from './staking-api'
+import assert from 'minimalistic-assert'
 
 const defaultTokenFeatures = {
   isMaxFeeAsset: true,
@@ -30,8 +29,9 @@ const getPolygonActivityTxs = ({ txs }) =>
 const getActivityTxs = ({ txs }) => txs.filter((tx) => !smallbalanceTx(tx))
 
 const getCreateBaseToken =
-  (props) =>
+  ({ getBalances, ...props }) =>
   ({ name, contract, features, ...tokenDef }) => {
+    assert(getBalances, 'getBalances is required')
     const tokenSpecificFeatures = name === 'polygon' ? { staking: {} } : {}
     const tokenSpecificApiFunctions =
       name === 'polygon' ? { staking: createStakingApi({ network: name }) } : {}

package/src/error-wrapper.js

@@ -0,0 +1,89 @@
+export const reasons = {
+  fetchGasLimitFailed: 'Fetch gas limit failed',
+  nonceFetchFailed: 'Nonce fetch failed',
+  balanceFetchFailed: 'Balance fetch failed',
+  broadcastTxFailed: 'Broadcast tx failed',
+  getTransactionByHashFailed: 'Get transaction by hash failed',
+  ethCallErc20Failed: 'Eth call erc20 failed',
+  insufficientFunds: 'Insufficient funds',
+  bumpTxFailed: 'Bump tx failed',
+}
+
+const MAX_HINT_LENGTH = 100
+// TODO: move this to be an generic error for all assets
+export class EthLikeError extends Error {
+  #hintStack
+
+  /**
+   * Creates an instance of EthLikeError.
+   *
+   * @param {string} message - Standard error message.
+   * @param {string} tag - Tag associated with the error.
+   * @param {string} reason - A constant indicating the generic failure. Must not contain any sensitive information such as private keys, transaction IDs, or wallet addresses.
+   * @param {string} hint - A hint to help the user understand the error. Must not contain any sensitive information such as private keys, transaction IDs, or wallet addresses.
+   */
+  constructor({ message, reason, hint }) {
+    super(message)
+    this.name = 'EthLikeError'
+    this.#hintStack = [hint] // NOTE: we can add more hints to the stack
+    this.reason = reason
+    this.hint = this.#extractHint(hint)
+  }
+
+  addHint = (hint) => {
+    const filteredHint = this.#extractHint(hint)
+    if (!filteredHint) {
+      return this
+    }
+
+    this.#hintStack.push(hint)
+    this.hint = `${this.#hintStack.join(':')}`
+    return this
+  }
+
+  // NOTE: a class method for now, if we move this to be a generic error for all assets, each asset will have its own implementation
+  #extractHint = (hint) => {
+    if (!hint) return ''
+
+    // Define regex patterns for sensitive information
+    const sensitivePatterns = [
+      /(?:0x)?[\dA-Fa-f]{64}/g, // Pattern for transaction hashes (hex string of 64 characters, optional 0x prefix)
+      /(?:0x)?[\dA-Fa-f]{40}/g, // Pattern for wallet addresses (hex string of 40 characters, optional 0x prefix)
+    ]
+
+    let filteredHint = hint
+
+    // Check for sensitive information
+    const containsSensitiveInfo = sensitivePatterns.some((pattern) => pattern.test(filteredHint))
+
+    if (containsSensitiveInfo) {
+      console.warn('Hint contains sensitive information and will be ignored.')
+      return ''
+    }
+
+    // Limit length to 100 characters
+    if (filteredHint.length > MAX_HINT_LENGTH) {
+      filteredHint = filteredHint.slice(0, MAX_HINT_LENGTH - 3) + '...'
+    }
+
+    return filteredHint
+  }
+}
+
+export const withErrorReason = async (promise, errorReason, hint) => {
+  try {
+    return await promise
+  } catch (err) {
+    if (err instanceof EthLikeError) {
+      // ignore errorReason and add hint to stack
+      err.addHint(hint)
+      throw err
+    }
+
+    throw new EthLikeError({
+      message: err.message,
+      reason: errorReason,
+      hint,
+    })
+  }
+}

package/src/eth-like-util.js

@@ -4,6 +4,7 @@ import { memoizeLruCache } from '@exodus/asset-lib'
 import SolidityContract from '@exodus/solidity-contract'
 import { getServerByName, getServer } from './exodus-eth-server'
 import { fromHexToString } from './number-utils'
+import * as ErrorWrapper from './error-wrapper'
 
 export async function isContract(baseAssetName, address) {
   return getServerByName(baseAssetName).isContract(address)
@@ -35,17 +36,27 @@ export const isForwarderContractCached = memoizeLruCache(
 
 export async function getNonce({ asset, address, tag = 'latest' }) {
   const server = getServer(asset)
-  const nonce = await server.getTransactionCount(address, tag)
+  const nonce = await ErrorWrapper.withErrorReason(
+    server.getTransactionCount(address, tag),
+    ErrorWrapper.reasons.nonceFetchFailed,
+    'getNonce'
+  )
+
   return parseInt(nonce, 16)
 }
 
 export async function estimateGas({ asset, ...args }) {
-  return getServer(asset).estimateGas(args)
+  return ErrorWrapper.withErrorReason(
+    getServer(asset).estimateGas(args),
+    ErrorWrapper.reasons.fetchGasLimitFailed,
+    'estimateGas'
+  )
 }
 
 // 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'
@@ -54,6 +65,7 @@ export async function getBalance({ asset, address }) {
 // Only base assets, not tokens
 export async function getBalanceProxied({ asset, address, tag = 'latest' }) {
   if (!isEthereumLikeAsset(asset)) throw new Error(`unsupported asset ${asset.name}`)
+
   const result = await getServer(asset).getBalanceProxied(address)
   return fromHexToString(result)
 }
@@ -61,6 +73,7 @@ export async function getBalanceProxied({ asset, address, tag = 'latest' }) {
 // 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()
@@ -69,6 +82,7 @@ export async function getTokenBalance({ asset, address }) {
 
 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)
@@ -83,7 +97,7 @@ export function sendRawTransaction(asset) {
 export async function transactionExists({ asset, txId }) {
   const server = getServer(asset)
   txId = normalizeTxId(txId)
-  const txResult = await server.getTransactionByHash(txId)
+  const txResult = server.getTransactionByHash(txId)
   return txResult && txResult.hash === txId
 }
 
@@ -122,12 +136,18 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
         callResponse = await server.ethCall({ to: address, data: ERC20[method].methodId })
       } catch (err) {
         if (err.message === 'execution reverted') {
-          throw new Error(
-            `Can't find parameters for contract with address ${address}. Are you sure it is a valid ERC20 contract?`
-          )
+          throw new ErrorWrapper.EthLikeError({
+            message: `Can't find parameters for contract with address ${address}. Are you sure it is a valid ERC20 contract?`,
+            reason: ErrorWrapper.reasons.ethCallErc20Failed,
+            hint: 'ethCall:executionReverted',
+          })
         }
 
-        throw new Error(err.message)
+        throw new ErrorWrapper.EthLikeError({
+          message: err.message,
+          reason: ErrorWrapper.reasons.ethCallErc20Failed,
+          hint: 'ethCall',
+        })
       }
 
       if (method === 'decimals') return parseInt(callResponse)

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

@@ -9,6 +9,7 @@ export default class ApiCoinNodesServer extends EventEmitter {
   constructor({ uri }) {
     super()
     this.uri = uri
+    this.defaultUri = uri
     this.id = 0
   }
 

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

@@ -9,6 +9,7 @@ export default class ClarityServer extends EventEmitter {
     super()
     this.baseAssetName = baseAssetName
     this.uri = uri
+    this.defaultUri = uri
     this.baseNamespace = `/v1/${this.baseAssetName}`
     this.sockets = Object.create(null)
     this.id = 0

package/src/gas-estimation.js

@@ -102,6 +102,7 @@ export async function fetchGasLimit({
     )
   } catch (err) {
     if (throwOnError) throw err
+
     console.error('fetchGasLimit error', err)
 
     // fallback value for contract case

package/src/get-balances.js

@@ -1,6 +1,8 @@
 import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
 
 import { get } from 'lodash'
+import assert from 'minimalistic-assert'
+
 import {
   getBalanceFromAccountState,
   getBalanceFromTxLog,
@@ -30,36 +32,40 @@ const getUnstaked = ({ accountState, asset }) => {
  * @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
  */
-export const getBalances = ({ asset, txLog, accountState }) => {
-  const unconfirmedReceived = getUnconfirmedReceivedBalance({ asset, txLog })
-  const unconfirmedSent = getUnconfirmedSentBalance({ asset, txLog })
+export const getBalancesFactory = ({ monitorType }) => {
+  assert(monitorType, 'monitorType is required')
+  return ({ asset, txLog, accountState }) => {
+    const unconfirmedReceived = getUnconfirmedReceivedBalance({ asset, txLog })
+    const unconfirmedSent = getUnconfirmedSentBalance({ asset, txLog })
 
-  // balance from txLog / rpc is considered to be total
-  const balanceWithoutUnconfirmedSent = isRpcBalanceAsset(asset)
-    ? getBalanceFromAccountState({ asset, accountState }).sub(unconfirmedSent)
-    : getBalanceFromTxLog({ txLog, asset })
+    // balance from txLog / rpc is considered to be total
+    const balanceWithoutUnconfirmedSent =
+      monitorType === 'no-history' || isRpcBalanceAsset(asset)
+        ? getBalanceFromAccountState({ asset, accountState }).sub(unconfirmedSent)
+        : getBalanceFromTxLog({ txLog, asset })
 
-  const staked = getStaked({ asset, accountState })
-  const unstaking = getUnstaking({ asset, accountState })
-  const unstaked = getUnstaked({ asset, accountState })
-  const total = balanceWithoutUnconfirmedSent
-  const spendable = balanceWithoutUnconfirmedSent
-    .sub(unconfirmedReceived)
-    .sub(staked)
-    .sub(unstaking)
-    .sub(unstaked)
+    const staked = getStaked({ asset, accountState })
+    const unstaking = getUnstaking({ asset, accountState })
+    const unstaked = getUnstaked({ asset, accountState })
+    const total = balanceWithoutUnconfirmedSent
+    const spendable = balanceWithoutUnconfirmedSent
+      .sub(unconfirmedReceived)
+      .sub(staked)
+      .sub(unstaking)
+      .sub(unstaked)
 
-  return {
-    // new
-    spendable,
-    total,
-    staked,
-    unstaking,
-    unstaked,
-    unconfirmedReceived,
-    unconfirmedSent,
-    // legacy
-    balance: total,
-    spendableBalance: spendable,
+    return {
+      // new
+      spendable,
+      total,
+      staked,
+      unstaking,
+      unstaked,
+      unconfirmedReceived,
+      unconfirmedSent,
+      // legacy
+      balance: total,
+      spendableBalance: spendable,
+    }
   }
 }

package/src/index.js

@@ -11,5 +11,10 @@ export * from './simulate-tx'
 export * from './allowance'
 export * from './optimism-gas'
 export * from './number-utils'
+export { reasons as errorReasons, withErrorReason, EthLikeError } from './error-wrapper'
 export { txSendFactory, getFeeInfo } from './tx-send'
 export { createAssetFactory } from './create-asset'
+export {
+  createAssetPluginFactory,
+  fromAddEthereumChainParameterToFactoryParams,
+} from './create-asset-plugin-factory'

package/src/nft-utils.js

@@ -1,6 +1,7 @@
 import SolidityContract from '@exodus/solidity-contract'
 import { fetchGasLimit } from './gas-estimation'
 import assert from 'minimalistic-assert'
+import * as ErrorWrapper from './error-wrapper'
 
 export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) => {
   assert(asset, 'asset is required')
@@ -43,7 +44,11 @@ export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) =>
       }
     })
   ).catch((e) => {
-    throw new Error(errors.join('\n'))
+    throw new ErrorWrapper.EthLikeError({
+      message: errors.join('\n'),
+      reason: ErrorWrapper.reasons.fetchGasLimitFailed,
+      hint: 'getNftArguments',
+    })
   })
   return {
     contractAddress,

package/src/tx-log/clarity-monitor.js

@@ -26,11 +26,13 @@ export class ClarityMonitor extends BaseMonitor {
   }
 
   setServer(config) {
-    if (!config?.server || config.server === this.server.uri) {
+    const uri = config?.server || this.server.defaultUri
+
+    if (uri === this.server.uri) {
       return
     }
 
-    this.server.setURI(config.server)
+    this.server.setURI(uri)
     this.subscribeWalletAddresses()
     if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
       this.server.connectFee()

package/src/tx-log/ethereum-monitor.js

@@ -1,4 +1,3 @@
-import { getServer } from '../exodus-eth-server'
 import { isRpcBalanceAsset, getAssetAddresses } from '@exodus/ethereum-lib'
 
 import {
@@ -28,7 +27,7 @@ import { fromHexToString } from '../number-utils'
 export class EthereumMonitor extends BaseMonitor {
   constructor({ server, config, ...args }) {
     super(args)
-    this.server = server || getServer(this.asset)
+    this.server = server
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -41,9 +40,13 @@ export class EthereumMonitor extends BaseMonitor {
   }
 
   setServer(config = {}) {
-    if (config.serverv1 && this.server.getURL() !== config.serverv1) {
-      this.server.setURL(config.serverv1)
+    const uri = config?.serverv1 || this.server.defaultUri
+
+    if (uri === this.server.getURL()) {
+      return
     }
+
+    this.server.setURL(uri)
   }
 
   async deriveData({ assetSource, tokens }) {
@@ -120,8 +123,8 @@ export class EthereumMonitor extends BaseMonitor {
         // FIXME: Fetching unconfirmed txs from node helps to avoid
         // flagging on-chain confirmed txs as dropped in the wallet.
         // Once the real bug is found, remove this logic
-        const response = await this.server.getTransactionByHash(tx.txId)
-        const isTxConfirmed = response?.result?.blockNumber !== null
+        const rpcTx = await this.server.getTransactionByHash(tx.txId)
+        const isTxConfirmed = !!rpcTx?.blockNumber
         this.logger.warn(`tx ${tx.txId} confirmed: ${isTxConfirmed}`)
         await updateTx(tx, assetName, { isTxConfirmed })
       }

package/src/tx-log/ethereum-no-history-monitor.js

@@ -1,6 +1,3 @@
-import { getServer } from '../exodus-eth-server'
-// eslint-disable-next-line import/no-deprecated
-import { DEFAULT_SERVER_URLS } from '@exodus/ethereum-lib'
 import { Tx } from '@exodus/models'
 
 import {
@@ -22,7 +19,7 @@ import { SynchronizedTime } from '@exodus/basic-utils'
 export class EthereumNoHistoryMonitor extends BaseMonitor {
   constructor({ server, config, ...args }) {
     super(args)
-    this.server = server || getServer(this.asset)
+    this.server = server
     this.config = { ...config }
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -31,14 +28,13 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   setServer(config) {
-    if (!config?.server) {
-      // eslint-disable-next-line import/no-deprecated
-      this.server.setURI(DEFAULT_SERVER_URLS[this.asset.name])
+    const uri = config?.server || this.server.defaultUri
+
+    if (uri === this.server.uri) {
       return
     }
 
-    if (config.server === this.server.uri) return
-    this.server.setURI(config.server)
+    this.server.setURI(uri)
   }
 
   async getBalances({ tokens, ourWalletAddress }) {

package/src/tx-send/tx-send.js

@@ -5,6 +5,7 @@ import { calculateBumpedGasPrice, isEthereumLikeToken, normalizeTxId } from '@ex
 import assert from 'minimalistic-assert'
 import getFeeInfo from './get-fee-info'
 import { getNftArguments } from '../nft-utils'
+import * as ErrorWrapper from '../error-wrapper'
 
 const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
@@ -127,20 +128,56 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
       await baseAsset.api.broadcastTx(rawTx.toString('hex'))
     } catch (err) {
       const nonceTooLowErr = err.message.match(/nonce (is |)too low/i)
+      const insufficientFundsErr = err.message.match(/insufficient funds/i)
       const txAlreadyExists = nonceTooLowErr
         ? await transactionExists({ asset, txId })
         : err.message.match(/already known/i)
 
       if (txAlreadyExists) {
         console.info('tx already broadcast') // inject logger factory from platform
-      } else if (bumpTxId || !nonceTooLowErr) {
-        throw err
+      } else if (insufficientFundsErr) {
+        throw new ErrorWrapper.EthLikeError({
+          message: err.message,
+          reason: ErrorWrapper.reasons.insufficientFunds,
+          hint: 'broadcastTx',
+        })
+      } else if (bumpTxId) {
+        throw new ErrorWrapper.EthLikeError({
+          message: err.message,
+          reason: ErrorWrapper.reasons.bumpTxFailed,
+          hint: 'broadcastTx',
+        })
+      } else if (!nonceTooLowErr) {
+        throw new ErrorWrapper.EthLikeError({
+          message: err.message,
+          reason: ErrorWrapper.reasons.broadcastTxFailed,
+          hint: 'otherErr:broadcastTx',
+        })
       } else if (nonceTooLowErr) {
         console.info('trying to send again...') // inject logger factory from platform
         // let's try to fix the nonce issue
+
         nonce = await getNonce({ asset: baseAsset, address: fromAddress })
         ;({ txId, rawTx } = await createTx({ ...createTxParams, nonce }))
-        await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+
+        try {
+          await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+        } catch (err) {
+          const insufficientFundsErr = err.message.match(/insufficient funds/i)
+          if (insufficientFundsErr) {
+            throw new ErrorWrapper.EthLikeError({
+              message: err.message,
+              reason: ErrorWrapper.reasons.insufficientFunds,
+              hint: 'retry:broadcastTx',
+            })
+          }
+
+          throw new ErrorWrapper.EthLikeError({
+            message: err.message,
+            reason: ErrorWrapper.reasons.broadcastTxFailed,
+            hint: 'retry:broadcastTx',
+          })
+        }
       }
     }