@exodus/ethereum-api 8.64.7 → 8.66.0

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.66.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.5...@exodus/ethereum-api@8.66.0) (2026-03-04)
+
+
+### Features
+
+
+* feat: add USDT blacklist status APIs for ETH and TRX and expose TRX raw account (#7444)
+
+
+### Bug Fixes
+
+
+* fix: avoid race conditions resulting in a `tipGasPrice` of `0` where possible (#7458)
+
+* fix: harden EthlikeError and improve error handling in tx-send (#7308)
+
+
+
+## [8.65.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.5...@exodus/ethereum-api@8.65.0) (2026-03-03)
+
+
+### Features
+
+
+* feat: encode per-network support flag, fix stale delegation state, eip7702 whitelist (#7477)
+
+* feat: gas price bump for evm (#7500)
+
+
+
 ## [8.64.7](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.5...@exodus/ethereum-api@8.64.7) (2026-02-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.64.7",
+  "version": "8.66.0",
   "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",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@exodus/asset": "^2.0.4",
-    "@exodus/asset-lib": "^5.3.0",
+    "@exodus/asset-lib": "^5.8.0",
     "@exodus/assets": "^11.4.0",
     "@exodus/basic-utils": "^3.0.1",
     "@exodus/bip44-constants": "^195.0.0",
@@ -33,6 +33,7 @@
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.8.0",
+    "@exodus/ethersproject-abi": "^5.4.2-exodus.2",
     "@exodus/fetch": "^1.3.0",
     "@exodus/models": "^12.13.0",
     "@exodus/safe-string": "^1.4.0",
@@ -68,5 +69,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "7d25477c075c7cef416ffe2c7e6e4c99e2928bdc"
+  "gitHead": "c715aabef7146610ab562c184a971c675f6d088f"
 }

package/src/create-asset-utils.js

@@ -1,13 +1,17 @@
+import { BlacklistCheckTypes } from '@exodus/asset-lib'
+import { defaultAbiCoder } from '@exodus/ethersproject-abi'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
 
+import { EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
 import { createEvmServer, createWsGateway, ValidMonitorTypes } from './exodus-eth-server/index.js'
 import { createEthereumHooks } from './hooks/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.js'
 import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
-import { BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
+import { BLOCK_TAG_LATEST, BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -141,6 +145,7 @@ export const createHistoryMonitorFactory = ({
   stakingAssetNames,
   rpcBalanceAssetNames,
   wsGatewayUri,
+  eip7702Supported,
 }) => {
   assert(assetName, 'expected assetName')
   assert(assetClientInterface, 'expected assetClientInterface')
@@ -158,6 +163,7 @@ export const createHistoryMonitorFactory = ({
           interval: ms(monitorInterval || '5m'),
           server,
           rpcBalanceAssetNames,
+          eip7702Supported,
           ...args,
         })
         break
@@ -168,6 +174,7 @@ export const createHistoryMonitorFactory = ({
           server,
           rpcBalanceAssetNames,
           wsGatewayClient: createWsGateway({ uri: wsGatewayUri }),
+          eip7702Supported,
           ...args,
         })
         break
@@ -176,6 +183,7 @@ export const createHistoryMonitorFactory = ({
           assetClientInterface,
           interval: ms(monitorInterval || '15s'),
           server,
+          eip7702Supported,
           ...args,
         })
         break
@@ -241,3 +249,64 @@ export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNon
 
   return { getNonce }
 }
+
+// Creates a contract-based blacklist check function.
+// async ({ address }) => boolean
+export const createContractBlackListCheck = ({ contractAddress, selector, server }) => {
+  assert(contractAddress, 'expected contractAddress')
+  assert(selector, 'expected selector')
+  assert(server, 'expected server')
+
+  return async ({ address }) => {
+    const tag = BLOCK_TAG_LATEST
+    const encodedAddress = address.slice(2).toLowerCase().padStart(64, '0')
+    const data = selector + encodedAddress
+    const result = await withErrorReason({
+      promise: server.ethCall({ to: contractAddress, data }, tag),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallErc20Failed,
+      hint: safeString`getBlackListStatus:ethCall`,
+      baseAssetName: server.baseAssetName,
+    })
+
+    if (typeof result !== 'string' || result.length === 0) {
+      throw new Error('getBlackListStatus got invalid ethCall response')
+    }
+
+    let isBlacklisted
+    try {
+      ;[isBlacklisted] = defaultAbiCoder.decode(['bool'], result)
+    } catch (err) {
+      throw new Error(`getBlackListStatus got invalid ABI bool result: ${err.message}`)
+    }
+
+    return isBlacklisted
+  }
+}
+
+// Composes blacklist check factories into a single getBlackListStatus.
+// Returns undefined if no checks are provided.
+// Returns { isBlacklisted: true } if ANY check returns true.
+// NOTE: blacklistChecks defaults to [] as a convenience, but it is the asset's responsibility
+// to be properly configured with the appropriate checks. An empty array means no blacklist
+// checks are run, which implies EIP-7702 is effectively enabled on that network with no whitelist.
+export const createGetBlackListStatus = ({ address: addressApi, blacklistChecks = [], server }) => {
+  if (blacklistChecks.length === 0) return
+
+  assert(addressApi, 'expected address')
+
+  // Extend here to support additional blacklist sources (e.g. an internal database query).
+  const checks = blacklistChecks.map((factory) => {
+    if (factory.type === BlacklistCheckTypes.CONTRACT_CALL) {
+      assert(server, 'expected server for CONTRACT_CALL blacklist check')
+      return factory({ server })
+    }
+
+    throw new Error(`Unknown blacklist check type: ${factory.type}`)
+  })
+
+  return async ({ address }) => {
+    assert(addressApi.validate(address), 'getBlackListStatus requires a valid Ethereum address')
+    const results = await Promise.all(checks.map((check) => check({ address })))
+    return { isBlacklisted: results.some(Boolean) }
+  }
+}

package/src/create-asset.js

@@ -22,6 +22,7 @@ import assert from 'minimalistic-assert'
 
 import { addressHasHistoryFactory } from './address-has-history.js'
 import {
+  createGetBlackListStatus,
   createHistoryMonitorFactory,
   createTransactionPrivacyFactory,
   getNonceFactory,
@@ -68,11 +69,13 @@ export const createAssetFactory = ({
   useEip1191ChainIdChecksum = false,
   forceGasLimitEstimation = false,
   rpcBalanceAssetNames = [],
+  blacklistChecks = [],
   supportsCustomFees: defaultSupportsCustomFees = false,
   useAbsoluteBalanceAndNonce = false,
   delisted = false,
   privacyRpcUrl: defaultPrivacyRpcUrl,
   wsGatewayUri: defaultWsGatewayUri,
+  eip7702Supported,
 }) => {
   assert(assetsList, 'assetsList is required')
   assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
@@ -233,6 +236,7 @@ export const createAssetFactory = ({
       stakingAssetNames,
       rpcBalanceAssetNames,
       wsGatewayUri,
+      eip7702Supported,
     })
 
     const defaultAddressPath = 'm/0/0'
@@ -262,6 +266,8 @@ export const createAssetFactory = ({
 
     const { getNonce } = getNonceFactory({ assetClientInterface, useAbsoluteBalanceAndNonce })
 
+    const getBlackListStatus = createGetBlackListStatus({ server, address, blacklistChecks })
+
     const api = {
       addressHasHistory,
       broadcastTx: (...args) => server.sendRawTransaction(...args),
@@ -277,6 +283,7 @@ export const createAssetFactory = ({
       getActivityTxs,
       getBalances,
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
+      ...(getBlackListStatus && { getBlackListStatus }),
       getConfirmationsNumber: () => confirmationsNumber,
       getDefaultAddressPath: () => defaultAddressPath,
       getFeeAsync: createTx, // createTx alias, remove me when possible
@@ -326,6 +333,7 @@ export const createAssetFactory = ({
       broadcastPrivateBundle,
       broadcastPrivateTx,
       forceGasLimitEstimation,
+      eip7702Supported,
       getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
       getNonce,
       privacyServer,

package/src/fee-utils.js

@@ -1,34 +1,40 @@
 import assert from 'minimalistic-assert'
 
-export const applyMultiplierToPrice = ({ feeAsset, gasPriceMultiplier, price }) => {
-  assert(typeof price === 'string', 'price should be a string')
-  return feeAsset.currency
-    .parse(price)
-    .mul(gasPriceMultiplier || 1)
-    .toBaseString({ unit: true })
-}
-
 /**
  * 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.
- *
- * TODO: We shouldn't actually do this, lol. The closer we are to
- *       the node, the better!
  */
-export const rewriteFeeConfig = ({ feeAsset, feeConfig, gasPriceMultiplier }) => {
+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, ...extras } = feeConfig
+    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,
-      gasPrice: applyMultiplierToPrice({
-        feeAsset,
-        gasPriceMultiplier,
-        price: gasPrice,
-      }) /* required */,
-      baseFeePerGas: baseFeePerGas
-        ? applyMultiplierToPrice({ feeAsset, gasPriceMultiplier, price: baseFeePerGas })
-        : undefined,
+      baseFeePerGas: nextBaseFeePerGas.toBaseString({ unit: true }),
+      tipGasPrice: nextTipGasPrice.toBaseString({ unit: true }),
+      gasPrice: nextBaseFeePerGas.add(nextTipGasPrice).toBaseString({ unit: true }),
     }
   } catch (e) {
     console.error(
@@ -148,9 +154,10 @@ export const calculateEthLikeFeeMonitorUpdate = async ({
 
   // Depending on whether `eip1559Enabled` on the client, we
   // can choose to return different properties.
-  const { eip1559Enabled, gasPriceMultiplier } = await assetClientInterface.getFeeConfig({
-    assetName: feeAsset.name,
-  })
+  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)
@@ -159,12 +166,7 @@ export const calculateEthLikeFeeMonitorUpdate = async ({
     ? calculateEthLikeFeeMonitorUpdateEip1559({ gasPrice, feeAsset, fetchedGasPrices })
     : calculateEthLikeFeeMonitorUpdateNonEip1559({ gasPrice }))
 
-  // HACK: We use `rewriteFeeConfig` to apply some additional padding
-  //       to our `gasPrice` and `baseFeePerGas` values. Once we're
-  //       feeling confident, we should be safe to skip doing this for
-  //       `eip1559Enabled` chains, since we should be able to guarantee
-  //       next block inclusion with accuracy.
-  return rewriteFeeConfig({ feeAsset, feeConfig, gasPriceMultiplier })
+  return refineFeeConfig({ feeAsset, feeConfig, gasPriceBump, gasPriceMultiplier })
 }
 
 /**

package/src/index.js

@@ -100,6 +100,8 @@ export { txSendFactory } from './tx-send/index.js'
 
 export { createAssetFactory } from './create-asset.js'
 
+export { createContractBlackListCheck } from './create-asset-utils.js'
+
 export {
   createAssetPluginFactory,
   fromAddEthereumChainParameterToFactoryParams,

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

@@ -28,7 +28,14 @@ export class ClarityMonitorV2 extends BaseMonitor {
   #walletAccountByAddress = new Map()
   #walletAccountInfo = new Map()
   #rpcBalanceAssetNames = []
-  constructor({ server, wsGatewayClient, rpcBalanceAssetNames, config, ...args } = {}) {
+  constructor({
+    server,
+    wsGatewayClient,
+    rpcBalanceAssetNames,
+    eip7702Supported,
+    config,
+    ...args
+  } = {}) {
     super(args)
     assert(wsGatewayClient instanceof WsGateway, 'expected WsGateway wsGatewayClient')
 
@@ -36,6 +43,7 @@ export class ClarityMonitorV2 extends BaseMonitor {
     this.server = server
     this.#wsClient = wsGatewayClient
     this.#rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.eip7702Supported = eip7702Supported
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -227,6 +235,7 @@ export class ClarityMonitorV2 extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -23,11 +23,12 @@ import {
 const { isEmpty } = lodash
 
 export class ClarityMonitor extends BaseMonitor {
-  constructor({ server, config, rpcBalanceAssetNames, ...args }) {
+  constructor({ server, config, rpcBalanceAssetNames, eip7702Supported, ...args }) {
     super(args)
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.server = server
     this.rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.eip7702Supported = eip7702Supported
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -191,6 +192,7 @@ export class ClarityMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -17,10 +17,11 @@ const { isEmpty, unionBy, zipObject } = lodash
 // The base ethereum monitor no history class handles listening for assets with no history
 
 export class EthereumNoHistoryMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
+  constructor({ server, config, eip7702Supported, ...args }) {
     super(args)
     this.server = server
     this.config = { ...config }
+    this.eip7702Supported = eip7702Supported
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
       getTxLog: (...args) => this.aci.getTxLog(...args),
@@ -190,6 +191,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

package/src/tx-log/monitor-utils/get-current-eip7702-delegation.js

@@ -1,38 +1,68 @@
 import { getEIP7702Delegation } from '../../eth-like-util.js'
 
+const NOT_DELEGATED = { isDelegated: false, delegatedAddress: null, isWhitelisted: null }
+
 /**
  * Checks if the address has an EIP-7702 delegation and returns the delegation state.
  * Returns the new state if changed, or the current state if unchanged.
- * On error, returns the current state to preserve existing data.
+ * On error, conservatively returns { isDelegated: false } to avoid showing stale delegation
+ * state that may no longer be accurate.
  *
  * @param {Object} params
  * @param {Object} params.server - The server instance to use for getCode
  * @param {string} params.address - The wallet address to check
+ * @param {Array<{address: string, name: string}>} [params.eip7702Supported] - Whitelist of trusted delegation targets.
+ *   If not an array, the check is skipped entirely (chain does not support EIP-7702).
+ *   An empty array means the check runs but every delegation will be isWhitelisted: false.
  * @param {Object} [params.currentDelegation] - The current delegation state from accountState
  * @param {Object} [params.logger] - Optional logger for warnings
  * @returns {Promise<Object|undefined>} The delegation state to use
  */
-export async function getCurrentEIP7702Delegation({ server, address, currentDelegation, logger }) {
+export async function getCurrentEIP7702Delegation({
+  server,
+  address,
+  eip7702Supported,
+  currentDelegation,
+  logger,
+}) {
+  // Non-array (undefined, false, etc.) → chain doesn't support EIP-7702, skip entirely
+  if (!Array.isArray(eip7702Supported)) return NOT_DELEGATED
+
   try {
     const result = await getEIP7702Delegation({ address, server })
 
-    // Return new state if changed
+    if (!result.isDelegated) return NOT_DELEGATED
+
+    // [] → check runs but nothing is trusted; populated array → whitelist check
+    const isWhitelisted = eip7702Supported.some(
+      ({ address }) => address.toLowerCase() === result.delegatedAddress.toLowerCase()
+    )
+
+    const newDelegation = {
+      isDelegated: true,
+      delegatedAddress: result.delegatedAddress,
+      isWhitelisted,
+    }
+
+    // Return new state only if something changed
     if (
-      currentDelegation?.isDelegated !== result.isDelegated ||
-      currentDelegation?.delegatedAddress !== result.delegatedAddress
+      currentDelegation?.isDelegated !== newDelegation.isDelegated ||
+      currentDelegation?.delegatedAddress !== newDelegation.delegatedAddress ||
+      currentDelegation?.isWhitelisted !== newDelegation.isWhitelisted
     ) {
-      return {
-        isDelegated: result.isDelegated,
-        delegatedAddress: result.delegatedAddress,
-      }
+      return newDelegation
     }
   } catch (error) {
     if (logger) {
       logger.warn('Failed to check EIP-7702 delegation:', error)
     }
+
+    // On error, conservatively clear delegation state — only hard RPC confirmation
+    // should result in isDelegated: true being shown to the user.
+    return NOT_DELEGATED
   }
 
-  // Return current state if unchanged or on error
+  // Return current state if unchanged
   return currentDelegation
 }