@exodus/ethereum-api 8.76.3 → 8.76.5

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.76.5](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.4...@exodus/ethereum-api@8.76.5) (2026-06-03)
+
+**Note:** Version bump only for package @exodus/ethereum-api
+
+
+
+
+
+## [8.76.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.3...@exodus/ethereum-api@8.76.4) (2026-06-02)
+
+
+### Bug Fixes
+
+
+* fix(ethereum-api): eliminate send-all dust on HYPE and other forceGasLimitEstimation networks (#7747)
+
+
+
 ## [8.76.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.2...@exodus/ethereum-api@8.76.3) (2026-06-01)
 
 **Note:** Version bump only for package @exodus/ethereum-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.3",
+  "version": "8.76.5",
   "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",
@@ -70,5 +70,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "aac7087b928f14da94a1a071b5abaf0983136c2a"
+  "gitHead": "651f8346570d40e724109e3df1cd2a3e10323a6f"
 }

package/src/check-tx/create-assess-transaction.js

@@ -0,0 +1,23 @@
+import { fetchival } from '@exodus/fetch'
+import assert from 'minimalistic-assert'
+
+export const DEFAULT_ASSESS_TRANSACTION_API_URL =
+  'https://simulation.a.exodus.io/simulation/transaction/assessment'
+
+export const createAssessTransaction = (
+  { apiUrl = DEFAULT_ASSESS_TRANSACTION_API_URL, headers, request = fetchival } = Object.create(
+    null
+  )
+) => {
+  assert(typeof apiUrl === 'string' && apiUrl.length > 0, 'apiUrl must be a non-empty string')
+
+  return async function assessTransaction({ payload }) {
+    return request(apiUrl, {
+      method: 'POST',
+      headers: {
+        ...headers,
+        'Content-Type': 'application/json',
+      },
+    }).post(payload)
+  }
+}

package/src/check-tx/create-check-tx.js

@@ -1,5 +1,4 @@
 import { memoizeLruCache } from '@exodus/asset-lib'
-import { makeSimulationAPICall } from '@exodus/web3-utils'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
 
@@ -37,25 +36,25 @@ const isRecipientFinding = ({ finding, recipientAddress }) => {
   })
 }
 
-const pickFindingForRecipient = ({ findings, recipientAddress }) => {
-  if (!Array.isArray(findings) || !recipientAddress) return GENERIC_RISK_REASON
-  const finding = findings.find((candidate) =>
-    isRecipientFinding({ finding: candidate, recipientAddress })
-  )
-  return finding?.title || GENERIC_RISK_REASON
+const findRecipientFinding = ({ findings, recipientAddress }) => {
+  if (!Array.isArray(findings) || !recipientAddress) return
+  return findings.find((candidate) => isRecipientFinding({ finding: candidate, recipientAddress }))
 }
 
 const parseAssessment = ({ body, recipientAddress }) => {
   if (!body?.success) return { action: 'NONE' }
   if (body.data?.recommendation !== 'deny') return { action: 'NONE' }
+  const finding = findRecipientFinding({ findings: body.data?.findings, recipientAddress })
+  if (!finding) return { action: 'NONE' }
+
   return {
     action: 'WARN',
-    reason: pickFindingForRecipient({ findings: body.data?.findings, recipientAddress }),
+    reason: finding.title || GENERIC_RISK_REASON,
   }
 }
 
-// Rejects after `timeoutMs`. The underlying request keeps running because
-// `makeSimulationAPICall` doesn't accept an AbortSignal.
+// Rejects after `timeoutMs`. The underlying request keeps running because the
+// API helper doesn't accept an AbortSignal.
 const withTimeout = async (promise, timeoutMs) => {
   let timeoutId
   const timeoutPromise = new Promise((_resolve, reject) => {
@@ -71,14 +70,9 @@ const withTimeout = async (promise, timeoutMs) => {
 const noopLogger = { warn: () => {} }
 
 export const createCheckTx = (
-  {
-    apiUrl,
-    timeout = DEFAULT_TIMEOUT_MS,
-    makeApiCall = makeSimulationAPICall,
-    logger = noopLogger,
-  } = Object.create(null)
+  { timeout = DEFAULT_TIMEOUT_MS, makeApiCall, logger = noopLogger } = Object.create(null)
 ) => {
-  assert(apiUrl, 'apiUrl is required')
+  assert(typeof makeApiCall === 'function', 'makeApiCall is required')
 
   const warn = typeof logger?.warn === 'function' ? logger.warn.bind(logger) : noopLogger.warn
 
@@ -90,13 +84,7 @@ export const createCheckTx = (
       if (input !== undefined) transaction.input = input
       if (hash !== undefined) transaction.hash = hash
 
-      const body = await withTimeout(
-        makeApiCall({
-          url: apiUrl,
-          payload: { serviceProvider: 'hypernative', transaction },
-        }),
-        timeout
-      )
+      const body = await withTimeout(makeApiCall({ payload: { transaction } }), timeout)
 
       if (!body) throw new Error('checkTx: empty response')
       return parseAssessment({ body, recipientAddress: toAddress })

package/src/create-asset.js

@@ -1,3 +1,4 @@
+import { createConsoleLogger } from '@exodus/asset-lib'
 import { ASSET_FAMILY, connectAssetsList } from '@exodus/assets'
 import bip44Constants from '@exodus/bip44-constants/by-ticker.js'
 import {
@@ -21,6 +22,7 @@ import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 
 import { addressHasHistoryFactory } from './address-has-history.js'
+import { createAssessTransaction } from './check-tx/create-assess-transaction.js'
 import { createCheckTx } from './check-tx/index.js'
 import {
   createGetBlackListStatus,
@@ -78,9 +80,9 @@ export const createAssetFactory = ({
   useAbsoluteBalanceAndNonce = false,
   delisted = false,
   privacyRpcUrl: defaultPrivacyRpcUrl,
-  riskAssessment: defaultRiskAssessment,
   wsGatewayUri: defaultWsGatewayUri,
   eip7702Supported,
+  transactionAssessment: defaultTransactionAssessment,
 }) => {
   assert(assetsList, 'assetsList is required')
   assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
@@ -104,7 +106,7 @@ export const createAssetFactory = ({
     nfts: defaultNfts,
     customTokens: defaultCustomTokens,
     privacyRpcUrl: defaultPrivacyRpcUrl,
-    riskAssessment: defaultRiskAssessment,
+    transactionAssessment: defaultTransactionAssessment,
   }
   return (
     {
@@ -125,7 +127,7 @@ export const createAssetFactory = ({
       supportsCustomFees,
       useAbsoluteBalanceAndNonce: overrideUseAbsoluteBalanceAndNonce,
       privacyRpcUrl,
-      riskAssessment,
+      transactionAssessment,
     } = configWithOverrides
 
     const asset = assets[base.name]
@@ -276,7 +278,7 @@ export const createAssetFactory = ({
     })
 
     const getFeeAsync = async (...args) => {
-      const { unsignedTx, ...rest } = await createTx(...args)
+      const { unsignedTx, amount, ...rest } = await createTx(...args)
       return rest
     }
 
@@ -294,16 +296,18 @@ export const createAssetFactory = ({
 
     const securityChecks = createSecurityChecks({ eip7702Supported })
 
+    const web3 = createWeb3API({ asset })
+
     let checkTx
-    if (riskAssessment?.apiUrl) {
+    let sendValidations = []
+    if (transactionAssessment?.enabled) {
       checkTx = createCheckTx({
-        apiUrl: riskAssessment.apiUrl,
-        logger: riskAssessment.logger,
+        makeApiCall: createAssessTransaction({ apiUrl: transactionAssessment.apiUrl }),
+        logger: createConsoleLogger('@exodus/ethereum-api:check-tx'),
       })
+      sendValidations = createSendValidations({ assetClientInterface, checkTx })
     }
 
-    const sendValidations = checkTx ? createSendValidations({ assetClientInterface, checkTx }) : []
-
     const moveFunds = moveFundsFactory({
       baseAssetName: asset.name,
       assetClientInterface,
@@ -365,7 +369,7 @@ export const createAssetFactory = ({
           }),
         }),
       validateAssetId: address.validate,
-      web3: createWeb3API({ asset }),
+      web3,
     }
 
     const fullAsset = {

package/src/gas-estimation.js

@@ -119,6 +119,7 @@ export async function fetchGasLimit({
   bip70,
   txType = TX_TYPE_TRANSFER,
   throwOnError = true,
+  isSendAll = false,
 }) {
   if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice) {
     // from on chain stats https://dune.xyz/queries/189123
@@ -178,7 +179,15 @@ export async function fetchGasLimit({
     })
 
     const scaledGasLimitEstimate = scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
-    if (!isToken) return scaledGasLimitEstimate
+    if (!isToken) {
+      // For native send-all on EOA targets, return the raw `eth_estimateGas`
+      // result (no 2x safety pad). Combined with the EIP-1559 tip override
+      // applied in tx-create.js (also gated on `isSendAll && !isContract`),
+      // this is the no-dust path: gasLimit ≈ gasUsed, so nothing comes back
+      // as refund. For contracts we keep the safety pad because contract
+      // gas can be nondeterministic against estimates.
+      return isSendAll && !isContractTxToAddress ? estimatedGasLimit : scaledGasLimitEstimate
+    }
 
     // NOTE: If we've enabled `fixGasLimit`s for a token,
     //       we need to make sure that transaction we're

package/src/move-funds.js

@@ -4,6 +4,7 @@ import assert from 'minimalistic-assert'
 
 import { getNonce, getTokenBalanceFromNode } from './eth-like-util.js'
 import { fetchGasLimit } from './gas-estimation.js'
+import { AmountIncludesFeeUnderflowError } from './tx-create.js'
 
 export const moveFundsFactory = ({ baseAssetName, assetClientInterface, createTx, server }) => {
   assert(baseAssetName, 'baseAssetName is required')
@@ -73,37 +74,69 @@ export const moveFundsFactory = ({ baseAssetName, assetClientInterface, createTx
       fromAddress,
       toAddress,
       amount,
+      // `isSendAll` and `amountIncludesFee` are no-ops on the token branch
+      // (both gated on `!isToken` / `!isEthereumLikeToken(asset)` downstream),
+      // so don't pass them. Keeps the API surface honest about which flags
+      // actually take effect for each branch.
+      ...(isToken ? null : { isSendAll: true }),
     })
 
-    const fee = feeData.gasPrice.mul(gasLimit)
-
-    const afterFee = ethBalance.sub(fee)
-    if (isToken) {
-      if (afterFee.isNegative) {
-        throw new MoveFundsError('token-fee-insufficient', { fromAddress })
-      }
-    } else {
-      if (!afterFee.isPositive) {
+    let createTxResult
+    try {
+      createTxResult = await createTx({
+        asset,
+        walletAccount,
+        fromAddress,
+        // Native sweep: pass the full balance and let createTx subtract the
+        // accurate fee. Token sweep: pass the full token balance unchanged
+        // (the native gas fee is paid separately from native balance).
+        address: toAddress,
+        amount,
+        nonce,
+        gasLimit,
+        gasPrice: feeData.gasPrice,
+        // TODO: drop this. Move funds has no fee picker, so it's always
+        // `feeData.gasPrice` (same as `gasPrice` above) and a no-op anyway.
+        // If we ever need a custom fee, thread it through prepareSendFundsTx.
+        customFee: feeData.gasPrice,
+        // Both flags are no-ops for tokens (see fetchGasLimit call above).
+        ...(isToken ? null : { isSendAll: true, amountIncludesFee: true }),
+      })
+    } catch (err) {
+      // createTx throws `AmountIncludesFeeUnderflowError` for the native
+      // sweep when the accurate fee (including OP-stack L1 data fee) exceeds
+      // the balance we passed in. Translate to the typed MoveFundsError so
+      // consumers (mobile/desktop MoveFunds screens) render the right copy.
+      if (!isToken && err instanceof AmountIncludesFeeUnderflowError) {
         throw new MoveFundsError('balance-negative', { fromAddress })
       }
 
-      amount = amount.sub(fee)
+      throw err
     }
 
-    const { unsignedTx } = await createTx({
-      asset,
-      walletAccount,
-      fromAddress,
-      address: toAddress,
-      amount,
-      nonce,
-      gasLimit,
-      gasPrice: feeData.gasPrice,
-      customFee: feeData.gasPrice,
-      isSendAll: true,
-    })
+    // Token sweep equivalent of the native underflow gate: createTx doesn't
+    // validate ETH balance vs gas for token transfers, so check it here using
+    // the authoritative fee returned from `calculateFee`. This catches the
+    // OP-stack edge case where balance covers `gasPrice * gasLimit` but not
+    // the additional L1 data fee.
+    if (isToken && ethBalance.sub(createTxResult.fee).isNegative) {
+      throw new MoveFundsError('token-fee-insufficient', { fromAddress })
+    }
 
-    return { fromAddress, toAddress, amount, fee, privateKey, unsignedTx }
+    // Trust createTx for both amount and fee. For native sweep `amount` is
+    // the post-subtraction value (input balance minus accurate fee). For
+    // token sweep `amount` is the input token balance unchanged, since we
+    // don't pass `amountIncludesFee`. In both cases `fee` includes the
+    // OP-stack L1 data fee from `calculateFee`, which matters more for
+    // tokens than for native because ERC-20 calldata is larger.
+    return {
+      fromAddress,
+      toAddress,
+      amount: createTxResult.amount,
+      fee: createTxResult.fee,
+      privateKey,
+      unsignedTx: createTxResult.unsignedTx,
+    }
   }
 
   const sendFunds = async ({ privateKey, unsignedTx }) => {

package/src/send-validations.js

@@ -39,14 +39,13 @@ export const createSendValidations = ({ assetClientInterface, checkTx }) => {
       })
       if (!fromAddress) return
 
-      // Match Hypernative's documented native-send payload shape.
+      // Native send: empty calldata, no signed tx hash to pass yet.
       const result = await checkTx({
         chain: asset.chainId,
         fromAddress,
         toAddress: destinationAddress,
         value: sendAmount.toBaseString({ unit: false }),
         input: '0x',
-        hash: '0x1',
       })
 
       if (result?.action !== 'WARN') return

package/src/tx-create.js

@@ -20,6 +20,62 @@ import {
   TX_TYPE_TRANSFER,
 } from './tx-type/index.js'
 
+// Thrown by `resolveAmountIncludesFeeTxAttributes` when the fee subtraction
+// implied by `amountIncludesFee` would drive the resulting tx value below
+// zero (i.e. the caller's balance can't cover the computed fee). Exported so
+// callers like MoveFunds can `instanceof`-check and translate it into their
+// own user-facing error type without string-matching the message.
+export class AmountIncludesFeeUnderflowError extends Error {
+  constructor() {
+    super('transaction gas cost exceeds fee-inclusive amount')
+    this.name = 'AmountIncludesFeeUnderflowError'
+  }
+}
+
+async function calculateFee({
+  asset,
+  chainId,
+  eip1559Enabled,
+  gasLimit,
+  gasPrice,
+  tipGasPrice,
+  nonce,
+  txInput,
+  txToAddress,
+  txValue,
+}) {
+  const ethjsTx = createEthereumJsTx({
+    txData: {
+      nonce,
+      gasPrice: currency2buffer(gasPrice),
+      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
+      gasLimit,
+      to: txToAddress,
+      value: currency2buffer(txValue),
+      data: txInput,
+      chainId,
+    },
+    txMeta: {
+      eip1559Enabled,
+    },
+  })
+  const transactionBuffer = ethjsTx.serialize()
+
+  const baseFee = gasPrice.mul(gasLimit)
+  const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
+    ? await asset.baseAsset.estimateL1DataFee({
+        unsignedTx: { txData: { transactionBuffer, chainId } },
+      })
+    : undefined
+
+  const l1DataFee = optimismL1DataFee
+    ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
+    : asset.baseAsset.currency.ZERO
+
+  const fee = baseFee.add(l1DataFee)
+  return { fee, transactionBuffer }
+}
+
 async function createUnsignedTxWithFees({
   asset,
   chainId,
@@ -57,35 +113,19 @@ async function createUnsignedTxWithFees({
     isContractTxToAddress,
   })
 
-  const ethjsTx = createEthereumJsTx({
-    txData: {
-      nonce,
-      gasPrice: currency2buffer(gasPrice),
-      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
-      gasLimit,
-      to: txToAddress,
-      value: currency2buffer(txValue),
-      data: txInput,
-      chainId,
-    },
-    txMeta: {
-      eip1559Enabled,
-    },
+  const { fee, transactionBuffer } = await calculateFee({
+    asset,
+    chainId,
+    eip1559Enabled,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    txInput,
+    txToAddress,
+    txValue,
   })
-  const transactionBuffer = ethjsTx.serialize()
 
-  const baseFee = gasPrice.mul(gasLimit)
-  const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-    ? await asset.baseAsset.estimateL1DataFee({
-        unsignedTx: { txData: { transactionBuffer, chainId } },
-      })
-    : undefined
-
-  const l1DataFee = optimismL1DataFee
-    ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-    : asset.baseAsset.currency.ZERO
-
-  const fee = baseFee.add(l1DataFee)
   const extraFeeData = getExtraFeeData({ asset, amount, txValue })
   const unsignedTx = {
     txData: { transactionBuffer, chainId },
@@ -102,6 +142,7 @@ async function createUnsignedTxWithFees({
   return {
     unsignedTx,
     fee,
+    amount,
     extraFeeData,
     // exhcange compatibility until the use usignedTx, remove me!
     gasPrice,
@@ -110,6 +151,60 @@ async function createUnsignedTxWithFees({
   }
 }
 
+// TODO: Move this into tx attribute resolution once gasLimit is resolved there.
+// `amountIncludesFee` changes the tx value, so the fee subtraction should happen
+// in the same flow that finalizes amount, txValue, txInput, txToAddress, and
+// gasLimit.
+async function resolveAmountIncludesFeeTxAttributes({
+  amountIncludesFee,
+  asset,
+  chainId,
+  eip1559Enabled,
+  gasLimit,
+  gasPrice,
+  tipGasPrice,
+  txAttributes,
+}) {
+  const { amount, nonce, txInput, txToAddress, txValue } = txAttributes
+
+  // `amountIncludesFee` is a hint: subtract any fee that is paid in the same
+  // currency as `amount`. On EVM today, gas is paid in the native asset, so
+  // for ERC-20 sends and zero-value calldata (i.e approve()) flows there is nothing in the
+  // amount's currency to subtract. Pass through silently in those cases, so
+  // consumers can set this flag based on intent without needing to know
+  // whether the asset is a token or whether the call carries zero native
+  // value.
+  if (!amountIncludesFee || isEthereumLikeToken(asset) || amount.isZero) {
+    return { txAttributes }
+  }
+
+  const { fee } = await calculateFee({
+    asset,
+    chainId,
+    eip1559Enabled,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    txInput,
+    txToAddress,
+    txValue,
+  })
+  const reducedAmount = amount.sub(fee)
+
+  if (!reducedAmount.gte(asset.currency.ZERO)) {
+    throw new AmountIncludesFeeUnderflowError()
+  }
+
+  return {
+    txAttributes: {
+      ...txAttributes,
+      amount: reducedAmount,
+      txValue: reducedAmount,
+    },
+  }
+}
+
 const resolveTxFactoryGasPrices = async ({
   assetClientInterface,
   baseAsset,
@@ -384,7 +479,12 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     gasPrice: providedGasPrice,
     bip70,
     customFee: providedCustomFee,
+    // Intent flag: the user is trying to empty the wallet. Used for send-all-only
+    // dust behavior such as the EIP-1559 tip override.
     isSendAll,
+    // Amount semantics flag: the provided amount includes the fee budget, so the
+    // final tx value should be reduced by the computed fee.
+    amountIncludesFee = false,
     bumpTxId,
   }) => {
     assert(asset, 'asset is required')
@@ -520,6 +620,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
         bip70,
         amount: resolvedTxAttributes.amount,
         txType,
+        isSendAll,
       }))
 
     // HACK: We cannot ensure the no dust invariant for `isSendAll`
@@ -532,8 +633,21 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     const isSendAllBaseAsset =
       isSendAll && !isEthereumLikeToken(asset) && !resolvedTxAttributes.isContractTxToAddress
 
+    const finalTipGasPrice = isSendAllBaseAsset && eip1559Enabled ? gasPrice : tipGasPrice
+
+    const { txAttributes: finalTxAttributes } = await resolveAmountIncludesFeeTxAttributes({
+      amountIncludesFee,
+      asset,
+      chainId,
+      eip1559Enabled,
+      gasLimit,
+      gasPrice,
+      tipGasPrice: finalTipGasPrice,
+      txAttributes: resolvedTxAttributes,
+    })
+
     return createUnsignedTxWithFees({
-      ...resolvedTxAttributes,
+      ...finalTxAttributes,
       asset,
       chainId,
       gasLimit,
@@ -545,7 +659,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       // fixed gas cost transaction, no dust balance should remain,
       // since any deviation in the underlying `baseFeePerGas` will
       // result only affect the tip for the miner - no dust remains.
-      tipGasPrice: isSendAllBaseAsset && eip1559Enabled ? gasPrice : tipGasPrice,
+      tipGasPrice: finalTipGasPrice,
       eip1559Enabled,
     })
   }