@exodus/ethereum-api 8.76.3 → 8.76.4

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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.4",
   "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": "f0c007138096bf627e21fc9e757637394fe2a5b0"
 }

package/src/create-asset.js

@@ -276,7 +276,7 @@ export const createAssetFactory = ({
     })
 
     const getFeeAsync = async (...args) => {
-      const { unsignedTx, ...rest } = await createTx(...args)
+      const { unsignedTx, amount, ...rest } = await createTx(...args)
       return rest
     }
 

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/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,
     })
   }