@exodus/ethereum-api 8.64.5 → 8.64.7

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.64.7](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.5...@exodus/ethereum-api@8.64.7) (2026-02-24)
+
+
+### Bug Fixes
+
+
+* fix: harden EthlikeError and improve error handling in tx-send (#7308)
+
+
+
+## [8.64.6](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.5...@exodus/ethereum-api@8.64.6) (2026-02-23)
+
+
+### Bug Fixes
+
+
+* fix: avoid race conditions resulting in a `tipGasPrice` of `0` where possible (#7458)
+
+
+
 ## [8.64.5](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.4...@exodus/ethereum-api@8.64.5) (2026-02-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.64.5",
+  "version": "8.64.7",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -35,9 +35,10 @@
     "@exodus/ethereumjs": "^1.8.0",
     "@exodus/fetch": "^1.3.0",
     "@exodus/models": "^12.13.0",
-    "@exodus/safe-string": "^1.2.1",
+    "@exodus/safe-string": "^1.4.0",
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.3.0",
+    "@exodus/traceparent": "^3.0.1",
     "@exodus/web3-ethereum-utils": "^4.6.0",
     "bn.js": "^5.2.1",
     "delay": "^4.0.1",
@@ -54,7 +55,7 @@
   "devDependencies": {
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/bsc-meta": "^2.5.1",
-    "@exodus/errors": "^3.3.0",
+    "@exodus/errors": "^3.8.0",
     "@exodus/ethereumarbone-meta": "^2.1.2",
     "@exodus/fantommainnet-meta": "^2.0.5",
     "@exodus/matic-meta": "^2.2.7",
@@ -67,5 +68,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "12e4eb3740319bb74eaedcc04b53c0dc056ad1a1"
+  "gitHead": "7d25477c075c7cef416ffe2c7e6e4c99e2928bdc"
 }

package/src/ens/index.js

@@ -64,4 +64,5 @@ const resolveEnsAddress = async (address, server) => {
   return resolver.decodeOutput({ data, method: 'name' })[0]
 }
 
+// This doesn't seem to be used anywhere.
 export { resolveEnsAddress, resolveEnsName }

package/src/error-wrapper.js

@@ -1,13 +1,277 @@
-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',
-  transactionUnderpriced: 'Transaction underpriced',
+import { safeString } from '@exodus/safe-string'
+
+// Error types for categorizing EVM errors
+export const EVM_ERROR_TYPES = {
+  NODE_STATE_READ: safeString`NODE_STATE_READ`, // RPC-level read operations
+  CONTRACT_CALL: safeString`CONTRACT_CALL`, // Smart contract calls (eth_call, estimateGas)
+  BROADCAST: safeString`BROADCAST`, // Transaction broadcast errors (includes reverts)
+}
+
+// Operation-specific reasons
+export const EVM_ERROR_REASONS = {
+  // RPC-level read operations
+  balanceFetchFailed: {
+    reason: safeString`balance fetch failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  nonceFetchFailed: {
+    reason: safeString`nonce fetch failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getTransactionByHashFailed: {
+    reason: safeString`get transaction by hash failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getCodeFailed: {
+    reason: safeString`get code failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getGasPriceFailed: {
+    reason: safeString`get gas price failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getBaseFeePerGasFailed: {
+    reason: safeString`get base fee per gas failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+
+  // Generic smart contract call failure.
+  ethCallFailed: {
+    reason: safeString`eth call failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+  ethCallErc20Failed: {
+    reason: safeString`eth call erc20 failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+
+  // Gas Usage Simulation (checks contract reverts)
+  fetchGasLimitFailed: {
+    reason: safeString`fetch gas limit failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+
+  // Write operations (checks sender account state/ability to transact)
+  // Generic failure, no info about a particular smart contract revert.
+  broadcastTxFailed: {
+    reason: safeString`broadcast tx failed`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+
+  // Reversion reasons
+  executionReverted: {
+    reason: safeString`execution reverted`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidOpcode: {
+    reason: safeString`invalid opcode`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientFundsForGas: {
+    reason: safeString`insufficient funds for gas * price + value`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  alreadyKnown: {
+    reason: safeString`already known`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  nonceTooLow: {
+    reason: safeString`nonce too low`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientBalance: {
+    reason: safeString`execution reverted: insufficient balance / transfer exceeds balance`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  replacementTransactionUnderpriced: {
+    reason: safeString`replacement transaction underpriced`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  zeroTransfer: {
+    reason: safeString`execution reverted: transfer amount must be greater than zero`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  mathError: {
+    reason: safeString`execution reverted: arithmetic overflow/underflow`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+
+  transactionUnderpriced: {
+    reason: safeString`transaction underpriced`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  nonceTooHigh: {
+    reason: safeString`nonce too high`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  gasPriceBelowMin: {
+    reason: safeString`transaction gas price below minimum`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientGas: {
+    reason: safeString`insufficient gas`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  futureTransactionReplace: {
+    reason: safeString`future transaction tries to replace pending`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  eip155Required: {
+    reason: safeString`eip-155 replay protection required`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidRlpSerialization: {
+    reason: safeString`invalid rlp serialization`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  transactionTypeNotSupported: {
+    reason: safeString`transaction type not supported`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  delegatedAccountError: {
+    reason: safeString`delegated account error`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidJumpDestination: {
+    reason: safeString`invalid jump destination`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+}
+
+// Patterns to normalize (group similar errors together)
+const EVM_NORMALIZATION_PATTERNS = [
+  // Insufficient funds for gas (native currency, not tokens)
+  {
+    pattern: /(insufficient funds for gas \* price \+ value|insufficient funds(?!.*balance))/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientFundsForGas,
+  },
+  // "nonce too low" or "nonce is too low" - tx nonce already used
+  {
+    pattern: /\bnonce\b.*\btoo low\b/i,
+    errorInfo: EVM_ERROR_REASONS.nonceTooLow,
+  },
+  // Comprehensive insufficient balance / transfer exceeds balance pattern (TOKEN balance issues)
+  // Catches: ERC20/BEP20, 0xe450d38c custom error, insufficient balance, balanceNotEnough,
+  // and token-specific "transfer amount exceeds balance" (BaseToken, SaveYourAssets, XVS, Ondo, FLOKI, etc.)
+  {
+    pattern:
+      /(0xe450d38c|insufficient.?balance|balance.?not.?enough|not enough fund|(erc20|bep20):.*transfer amount exceeds balance|\w+:.*transfer amount exceeds balance)/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientBalance,
+  },
+  // Arithmetic overflow/underflow errors (SafeMath, Solidity 0.8+, etc.)
+  {
+    pattern: /(safemath:.*overflow|arithmetic underflow or overflow)/i,
+    errorInfo: EVM_ERROR_REASONS.mathError,
+  },
+  // Transfer amount must be greater than zero (various phrasings)
+  {
+    pattern:
+      /(transfer amount must be greater than zero|amount must be greater than 0|amt must be over than 0|zero_amount|transfer amount must be positive|transfer amount zero)/i,
+    errorInfo: EVM_ERROR_REASONS.zeroTransfer,
+  },
+  // Gas price below network minimum (not mempool competition, but protocol minimum)
+  // "gas price below minimum", "gas tip cap...minimum", "max fee per gas less than block base fee"
+  {
+    pattern:
+      /gas price below minimum|gas tip cap.*minimum|max fee per gas less than block base fee/i,
+    errorInfo: EVM_ERROR_REASONS.gasPriceBelowMin,
+  },
+  // Gas limit errors
+  // "intrinsic gas too low", "insufficient gas", "floor data gas cost" - gas limit below minimum required
+  {
+    pattern: /intrinsic gas too low|insufficient gas|floor data gas cost/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientGas,
+  },
+  // "nonce too high" or "nonce is too high" - tx nonce too far ahead
+  {
+    pattern: /\bnonce\b.*\btoo high\b/i,
+    errorInfo: EVM_ERROR_REASONS.nonceTooHigh,
+  },
+  // Transaction type not supported
+  // "transaction type not supported", "tx type not supported" - chain doesn't support this tx type (e.g., EIP-1559)
+  {
+    pattern: /transaction type not supported|tx type not supported/i,
+    errorInfo: EVM_ERROR_REASONS.transactionTypeNotSupported,
+  },
+  // Invalid jump destination
+  {
+    pattern: /invalid jump destination/i,
+    errorInfo: EVM_ERROR_REASONS.invalidJumpDestination,
+  },
+  // Transaction already in mempool/chain
+  // "already known", "known transaction", "already imported", "already in mempool"
+  {
+    pattern: /already known|known transaction|already imported|already in mempool/i,
+    errorInfo: EVM_ERROR_REASONS.alreadyKnown,
+  },
+  // Replacement transaction underpriced (must come BEFORE "transaction underpriced")
+  {
+    pattern: /replacement transaction underpriced/i,
+    errorInfo: EVM_ERROR_REASONS.replacementTransactionUnderpriced,
+  },
+  // Transaction underpriced (checked after replacement to avoid double match)
+  {
+    pattern: /transaction underpriced/i,
+    errorInfo: EVM_ERROR_REASONS.transactionUnderpriced,
+  },
+  // Replay-protected transactions required (EIP-155 chain ID signing)
+  // "only replay-protected", "replay-protected transaction/tx required", "not replay protected", "invalid chain id"
+  {
+    pattern:
+      /only replay-protected|replay-protected (transaction|tx) required|not replay protected|invalid chain id/i,
+    errorInfo: EVM_ERROR_REASONS.eip155Required,
+  },
+  // Future transaction tries to replace pending (nonce conflict)
+  {
+    pattern: /future transaction.*replace.*pending/i,
+    errorInfo: EVM_ERROR_REASONS.futureTransactionReplace,
+  },
+  // Serialization/signature errors
+  // "rlp:", "invalid rlp", "decode rlp", "invalid sender", "invalid signature", "bad signature"
+  {
+    pattern: /rlp:|invalid rlp|decode rlp|invalid sender|invalid signature|bad signature/i,
+    errorInfo: EVM_ERROR_REASONS.invalidRlpSerialization,
+  },
+  // EIP-7702 delegation errors
+  // "delegated" (but not "delegatecall"), "eip-7702", "eip7702" - account delegation related errors
+  {
+    pattern: /\bdelegated\b(?!\s*call)|eip-?7702/i,
+    errorInfo: EVM_ERROR_REASONS.delegatedAccountError,
+  },
+  // GENERIC CATCH-ALL PATTERNS (must be last)
+  {
+    pattern: /^execution reverted$/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+  {
+    pattern: /\binvalid opcode\b/i,
+    errorInfo: EVM_ERROR_REASONS.invalidOpcode,
+  },
+  {
+    pattern: /^execution reverted: 0x$/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+  // Final catch-all for any remaining "execution reverted:" messages
+  {
+    pattern: /execution reverted:/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+]
+
+// This should be renamed something better
+export function getEvmErrorReason(errorMessage) {
+  for (const { pattern, errorInfo } of EVM_NORMALIZATION_PATTERNS) {
+    if (pattern.test(errorMessage)) {
+      return {
+        reason: errorInfo.reason,
+        type: errorInfo.type,
+        wasNormalized: true,
+        patternUsed: pattern.toString(),
+      }
+    }
+  }
+
+  return null
 }
 
 const MAX_HINT_LENGTH = 100
@@ -19,15 +283,22 @@ export class EthLikeError extends Error {
    * Creates an instance of EthLikeError.
    *
    * @param {string} message - Standard error message.
-   * @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 {Object} errorReasonInfo - Object containing reason and type for the error.
+   * @param {string} errorReasonInfo.reason - A constant indicating the generic failure. Must not contain any sensitive information such as private keys, transaction IDs, or wallet addresses.
+   * @param {string} errorReasonInfo.type - A category for the error (e.g., 'NODE_STATE_READ', 'CONTRACT_CALL', 'BROADCAST').
    * @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.
+   * @param {TraceId} [traceId] - Optional TraceId object from HTTP response 'traceparent' header for debugging.
+   * @param {string} [baseAssetName] - Optional base asset name (e.g. 'ethereum', 'bnbsmartchain') for identifying the network.
    */
-  constructor({ message, reason, hint }) {
+  constructor({ message, errorReasonInfo, hint, traceId, baseAssetName }) {
     super(message)
-    this.name = 'EthLikeError'
+    this.name = safeString`EthLikeError`
     this.#hintStack = [hint] // NOTE: we can add more hints to the stack
-    this.reason = reason
+    this.reason = errorReasonInfo.reason
     this.hint = this.#extractHint(hint)
+    this.type = errorReasonInfo.type
+    this.traceId = traceId
+    this.baseAssetName = baseAssetName
   }
 
   addHint = (hint) => {
@@ -41,6 +312,15 @@ export class EthLikeError extends Error {
     return this
   }
 
+  getContext = () => {
+    return {
+      reason: this.reason,
+      type: this.type,
+      traceId: this.traceId,
+      baseAssetName: this.baseAssetName,
+    }
+  }
+
   // 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 ''
@@ -72,7 +352,7 @@ export class EthLikeError extends Error {
   }
 }
 
-export const withErrorReason = async (promise, errorReason, hint) => {
+export const withErrorReason = async ({ promise, errorReasonInfo, hint, baseAssetName }) => {
   try {
     return await promise
   } catch (err) {
@@ -84,8 +364,10 @@ export const withErrorReason = async (promise, errorReason, hint) => {
 
     throw new EthLikeError({
       message: err.message,
-      reason: errorReason,
+      errorReasonInfo,
       hint,
+      traceId: err.traceId,
+      baseAssetName,
     })
   }
 }

package/src/eth-like-util.js

@@ -1,9 +1,10 @@
 import { memoizeLruCache } from '@exodus/asset-lib'
 import { ABI, isEthereumLikeAsset, isEthereumLikeToken, normalizeTxId } from '@exodus/ethereum-lib'
+import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import * as ErrorWrapper from './error-wrapper.js'
+import { EthLikeError, EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
 import { getServer, getServerByName } from './exodus-eth-server/index.js'
 import { fromHexToString } from './number-utils.js'
 
@@ -18,7 +19,12 @@ export async function isContract(baseAssetName, address) {
 }
 
 export async function isContractAddress({ asset, address }) {
-  return getServer(asset).isContract(address)
+  return withErrorReason({
+    promise: getServer(asset).isContract(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`isContractAddress`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 export const isContractAddressCached = memoizeLruCache(
@@ -29,7 +35,12 @@ export const isContractAddressCached = memoizeLruCache(
 
 export async function isForwarderContract({ asset, address }) {
   const server = getServer(asset)
-  const contractCode = await server.getCode(address)
+  const contractCode = await withErrorReason({
+    promise: server.getCode(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`isForwarderContract`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return contractCode === FORWARDER_CONTRACT_CODE
 }
 
@@ -41,21 +52,23 @@ export const isForwarderContractCached = memoizeLruCache(
 
 export async function getNonce({ asset, address, tag = 'latest' }) {
   const server = getServer(asset)
-  const nonce = await ErrorWrapper.withErrorReason(
-    server.getTransactionCount(address, tag),
-    ErrorWrapper.reasons.nonceFetchFailed,
-    'getNonce'
-  )
+  const nonce = await withErrorReason({
+    promise: server.getTransactionCount(address, tag),
+    errorReasonInfo: EVM_ERROR_REASONS.nonceFetchFailed,
+    hint: safeString`getNonce`,
+    baseAssetName: asset.baseAsset.name,
+  })
 
   return parseInt(nonce, 16)
 }
 
 export async function estimateGas({ asset, ...args }) {
-  return ErrorWrapper.withErrorReason(
-    getServer(asset).estimateGas(args),
-    ErrorWrapper.reasons.fetchGasLimitFailed,
-    'estimateGas'
-  )
+  return withErrorReason({
+    promise: getServer(asset).estimateGas(args),
+    errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+    hint: safeString`estimateGas`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 // Only base assets, not tokens
@@ -63,7 +76,12 @@ 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)
+  const balances = await withErrorReason({
+    promise: server.getBalance(address),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getBalance`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return balances?.confirmed?.value || '0'
 }
 
@@ -71,16 +89,27 @@ export async function getBalance({ asset, address }) {
 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)
+  const result = await withErrorReason({
+    promise: getServer(asset).getBalanceProxied(address),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getBalanceProxied`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return fromHexToString(result)
 }
 
 // Only ETH-like assets with token support
+// How would this return token balances? It does the same as getBalanceProxied... getting ETH balance
 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 balances = await withErrorReason({
+    promise: server.getBalance(address),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getTokenBalance`,
+    baseAssetName: asset.baseAsset.name,
+  })
   const contractAddress = asset.contract.address.toLowerCase()
   return balances?.confirmed?.[contractAddress] || '0'
 }
@@ -90,7 +119,12 @@ export async function getTokenBalanceFromNode({ asset, address }) {
 
   const server = getServer(asset)
   const contractAddress = asset.contract.address.toLowerCase()
-  const balances = await server.balanceOf(address, contractAddress)
+  const balances = await withErrorReason({
+    promise: server.balanceOf(address, contractAddress),
+    errorReasonInfo: EVM_ERROR_REASONS.ethCallErc20Failed,
+    hint: safeString`getTokenBalanceFromNode`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return balances?.confirmed?.[contractAddress] || '0'
 }
 
@@ -102,14 +136,24 @@ 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 = await withErrorReason({
+    promise: server.getTransactionByHash(txId),
+    errorReasonInfo: EVM_ERROR_REASONS.getTransactionByHashFailed,
+    hint: safeString`transactionExists`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return Boolean(txResult && txResult.hash === txId)
 }
 
 export async function getTransaction({ asset, txId }) {
   const server = getServer(asset)
   txId = normalizeTxId(txId)
-  return server.getTransactionByHash(txId)
+  return withErrorReason({
+    promise: server.getTransactionByHash(txId),
+    errorReasonInfo: EVM_ERROR_REASONS.getTransactionByHashFailed,
+    hint: safeString`getTransaction`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 export const getIsForwarderContract = memoizeLruCache(
@@ -140,18 +184,12 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
       try {
         callResponse = await server.ethCall({ to: address, data: ERC20[method].methodId })
       } catch (err) {
-        if (err.message === 'execution reverted') {
-          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 ErrorWrapper.EthLikeError({
+        throw new EthLikeError({
           message: err.message,
-          reason: ErrorWrapper.reasons.ethCallErc20Failed,
-          hint: 'ethCall',
+          errorReasonInfo: EVM_ERROR_REASONS.ethCallErc20Failed,
+          hint: safeString`getERC20Params`,
+          traceId: err.traceId,
+          baseAssetName: asset.baseAsset.name,
         })
       }
 
@@ -181,7 +219,12 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
 }
 
 export async function getEIP7702Delegation({ address, server }) {
-  const code = await server.getCode(address)
+  const code = await withErrorReason({
+    promise: server.getCode(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`getEIP7702Delegation`,
+    baseAssetName: server.baseAssetName,
+  })
 
   // No code at all
   if (!code || code === '0x' || code === '0x0') {

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

@@ -6,12 +6,14 @@ import lodash from 'lodash'
 
 import { fromHexToString } from '../number-utils.js'
 import { errorMessageToSafeHint } from './errors.js'
+import { getFallbackGasPriceEstimation } from './utils.js'
 
 const { isEmpty } = lodash
 
 export default class ApiCoinNodesServer extends EventEmitter {
-  constructor({ uri }) {
+  constructor({ baseAssetName, uri }) {
     super()
+    this.baseAssetName = baseAssetName
     this.uri = uri
     this.defaultUri = uri
     this.id = 0
@@ -166,6 +168,10 @@ export default class ApiCoinNodesServer extends EventEmitter {
     return this.sendRequest(request)
   }
 
+  async getGasPriceEstimation() {
+    return getFallbackGasPriceEstimation({ server: this })
+  }
+
   // for fee monitor
   getGasPrice = this.gasPrice
 

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

@@ -6,6 +6,7 @@ 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']
@@ -120,6 +121,10 @@ export function create(defaultURL, ensAssetName) {
       return requestWithRetry('proxy', { method: 'eth_gasPrice' })
     },
 
+    async getGasPriceEstimation() {
+      return getFallbackGasPriceEstimation({ server: this })
+    },
+
     // for fee monitor
     async getGasPrice() {
       return requestWithRetry('proxy', { method: 'eth_gasPrice' })