@exodus/ethereum-api 8.53.5 → 8.53.6

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.53.6](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.53.5...@exodus/ethereum-api@8.53.6) (2025-10-23)
+
+
+### Bug Fixes
+
+
+* fix: improve transaction address resolution for gas estimation and encapsulate transaction property evaluation (#6636)
+
+* fix: increase evm resistance to txLog race conditions (#6676)
+
+
+
 ## [8.53.5](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.53.4...@exodus/ethereum-api@8.53.5) (2025-10-17)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.53.5",
+  "version": "8.53.6",
   "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",
@@ -29,7 +29,7 @@
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.18.1",
+    "@exodus/ethereum-lib": "^5.18.2",
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.8.0",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "48ee2473ddc98a5eb52a69bba220910263d21a45"
+  "gitHead": "124fa7a939418684d2ae50d8db93ff73c59c4cdc"
 }

package/src/gas-estimation.js

@@ -2,6 +2,11 @@ import { currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
 import { bufferToHex, toBuffer } from '@exodus/ethereumjs/util'
 
 import { estimateGas, isContractAddressCached, isForwarderContractCached } from './eth-like-util.js'
+import {
+  ARBITRARY_ADDRESS,
+  resolveCriticalTxAttributes,
+  TX_TYPE_TRANSFER,
+} from './tx-type/index.js'
 
 export const DEFAULT_GAS_LIMIT_MULTIPLIER = 1.29
 
@@ -12,23 +17,6 @@ export const DEFAULT_CONTRACT_GAS_LIMIT = 1e6
 export const DEFAULT_TOKEN_GAS_LIMIT = 120e3
 export const DEFAULT_GAS_LIMIT = 21_000
 
-// HACK: If a recipient address is not defined, we usually fall back to
-//       default address so gas estimation can still complete successfully
-//       without knowledge of which accounts are involved.
-//
-//       However, we must be careful to select addresses which are unlikely
-//       to have existing obligations, such as popular dead addresses or the
-//       reserved addresses of precompiles, since these can influence gas
-//       estimation.
-//
-//       Here, we use an address which is mostly all `1`s to make sure we can
-//       exaggerate the worst-case calldata cost (which is priced per high bit)
-//       whilst being unlikely to have any token balances.
-//
-//       Unfortunately, we can't use `0xffffffffffffffffffffffffffffffffffffffff`,
-//       since this address is a whale.
-export const ARBITRARY_ADDRESS = '0xfffFfFfFfFfFFFFFfeFfFFFffFffFFFFfFFFFFFF'.toLowerCase()
-
 // HACK: RPCs generally provide imprecise estimates
 //       for `gasUsed` (often these are insufficient).
 export const scaleGasLimitEstimate = ({
@@ -56,6 +44,7 @@ export async function estimateGasLimit({
   asset,
   fromAddress,
   toAddress,
+  // TODO: rename to value, as this is `msg.value`.
   amount = asset.currency.ZERO,
   data,
   gasPrice = '0x',
@@ -76,7 +65,13 @@ export async function resolveGasLimitMultiplier({ asset, feeData, toAddress, fro
   const gasLimitMultiplierWhenUnknownAddress =
     feeData?.gasLimits?.[asset.name]?.gasLimitMultiplierWhenUnknownAddress
 
-  if (gasLimitMultiplierWhenUnknownAddress && (!fromAddress || !toAddress)) {
+  // NOTE: If either the `fromAddress` or `toAddress` has fell
+  //       back to the `ARBITRARY_ADDRESS`, these qualify as
+  //       "unknown" addresses.
+  const fromAddressIsUnknown = fromAddress === ARBITRARY_ADDRESS
+  const toAddressIsUnknown = toAddress === ARBITRARY_ADDRESS
+
+  if (gasLimitMultiplierWhenUnknownAddress && (fromAddressIsUnknown || toAddressIsUnknown)) {
     return gasLimitMultiplierWhenUnknownAddress
   }
 
@@ -103,12 +98,6 @@ export async function resolveGasLimitMultiplier({ asset, feeData, toAddress, fro
   return DEFAULT_GAS_LIMIT_MULTIPLIER
 }
 
-export function resolveDefaultTxInput({ asset, toAddress, amount }) {
-  return isEthereumLikeToken(asset)
-    ? bufferToHex(asset.contract.transfer.build(toAddress.toLowerCase(), amount?.toBaseString()))
-    : '0x'
-}
-
 export const defaultGasLimit = ({ asset, txInput }) => {
   const isToken = isEthereumLikeToken(asset)
   return (
@@ -117,6 +106,7 @@ export const defaultGasLimit = ({ asset, txInput }) => {
   )
 }
 
+// TODO: `gasLimit` needs to be a responsibility of `resolveTxAttributesByTxType`.
 export async function fetchGasLimit({
   asset,
   feeData,
@@ -124,8 +114,9 @@ export async function fetchGasLimit({
   toAddress: providedToAddress,
   txInput: providedTxInput,
   amount: providedAmount,
-  contractAddress,
+  contractAddress: providedTxToAddress,
   bip70,
+  txType = TX_TYPE_TRANSFER,
   throwOnError = true,
 }) {
   if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice) {
@@ -133,16 +124,31 @@ export async function fetchGasLimit({
     return asset.name === 'ethereum' ? 65_000 : 130_000
   }
 
-  const amount = providedAmount ?? asset.currency.ZERO
+  // TODO: If we can provide the `walletAccount` via `fetchGasLimit` then
+  //       we can use `resolveTxAttributesByTxType` instead (and remove
+  //       the concept of critical attributes).
+  const { txToAddress, txInput, txValue } = resolveCriticalTxAttributes({
+    asset,
+    amount: providedAmount,
+    toAddress: providedToAddress,
+    txToAddress: providedTxToAddress,
+    txInput: providedTxInput,
+    txType,
+  })
+
+  const isContractTxToAddress =
+    Boolean(txToAddress) && (await isContractAddressCached({ asset, address: txToAddress }))
+
   const fromAddress = providedFromAddress ?? ARBITRARY_ADDRESS
-  const toAddress = providedToAddress ?? ARBITRARY_ADDRESS
-  const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
 
   const isToken = isEthereumLikeToken(asset)
 
-  const isContract = await isContractAddressCached({ asset, address: toAddress })
-
-  if (!isToken && !isContract && !asset.forceGasLimitEstimation) {
+  if (
+    txType === TX_TYPE_TRANSFER &&
+    !isToken &&
+    !isContractTxToAddress &&
+    !asset.forceGasLimitEstimation
+  ) {
     return defaultGasLimit({ asset, txInput })
   }
 
@@ -150,39 +156,47 @@ export async function fetchGasLimit({
     asset,
     feeData,
     fromAddress: providedFromAddress,
-    toAddress: providedToAddress,
+    toAddress: txToAddress,
   })
 
-  const txToAddress = contractAddress ?? (isToken ? asset.contract.address : toAddress)
-  const txAmount = isToken ? asset.baseAsset.currency.ZERO : amount
-
   try {
+    // NOTE: Although we'll return the `fixedGasLimit` for known
+    //       tokens, we'll still want to execute `estimateGasLimit`
+    //       to verify their transaction actually succeeds (i.e.
+    //       they aren't trying to transfer more than their balance).
+    //
+    //       This prevents users from submitting `fixedGasLimit`
+    //       token transactions which result in a `revert`.
     const estimatedGasLimit = await estimateGasLimit({
       asset,
       fromAddress,
       toAddress: txToAddress,
-      amount: txAmount,
+      amount: txValue,
       data: txInput,
     })
 
-    // NOTE: Although we'll return the `fixedGasLimit` for known
-    //       tokens, we'll still want to execute `estimateGasLimit`
-    //       to verify their transaction actually succeeds (i.e.
-    //       they aren't trying to transfer more than their balance).
+    const scaledGasLimitEstimate = scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
+    if (!isToken) return scaledGasLimitEstimate
+
+    // NOTE: If we've enabled `fixGasLimit`s for a token,
+    //       we need to make sure that transaction we're
+    //       making actually targets that token.
     //
-    //       This prevents users from submitting `fixedGasLimit`
-    //       token transactions which result in a `revert`.
-    return (
-      feeData?.gasLimits?.[asset.name]?.fixedGasLimit ??
-      scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
-    )
+    //       Otherwise, we risk applying the fixed gas limit
+    //       to transactions with _other_ smart contracts
+    //       simply because the caller specified the token
+    //       asset.
+    const isTokenTransaction = asset.contract.address.toLowerCase() === txToAddress.toLowerCase()
+    if (!isTokenTransaction) return scaledGasLimitEstimate
+
+    return feeData?.gasLimits?.[asset.name]?.fixedGasLimit ?? scaledGasLimitEstimate
   } catch (err) {
     if (throwOnError) throw err
 
     console.error('fetchGasLimit error', err)
 
     // fallback value for contract case
-    if (isContract) return DEFAULT_CONTRACT_GAS_LIMIT
+    if (isContractTxToAddress) return DEFAULT_CONTRACT_GAS_LIMIT
 
     return defaultGasLimit({ asset, txInput })
   }

package/src/index.js

@@ -24,7 +24,6 @@ export {
   DEFAULT_CONTRACT_GAS_LIMIT,
   DEFAULT_GAS_LIMIT_MULTIPLIER,
   estimateGasLimit,
-  resolveDefaultTxInput,
   fetchGasLimit,
 } from './gas-estimation.js'
 

package/src/nft-utils.js

@@ -34,9 +34,8 @@ export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) =>
         const gasLimit = await fetchGasLimit({
           asset,
           fromAddress,
-          toAddress: contractAddress,
+          contractAddress,
           txInput,
-          amount: asset.baseAsset.currency.ZERO,
         })
         return { txInput, gasLimit }
       } catch (e) {

package/src/tx-create.js

@@ -2,51 +2,65 @@ import { calculateBumpedGasPrice, currency2buffer, isEthereumLikeToken } from '@
 import createEthereumJsTx from '@exodus/ethereum-lib/src/unsigned-tx/create-ethereumjs-tx.js'
 import assert from 'minimalistic-assert'
 
-import * as ErrorWrapper from './error-wrapper.js'
-import { isContractAddressCached } from './eth-like-util.js'
 import { ensureSaneEip1559GasPriceForTipGasPrice } from './fee-utils.js'
-import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
+import { fetchGasLimit } from './gas-estimation.js'
 import { getExtraFeeData, getFeeFactoryGasPrices } from './get-fee.js'
 import { getNftArguments } from './nft-utils.js'
 import { getHighestIncentivePendingTxByNonce } from './tx-log/index.js'
+import {
+  assertTxAttributes,
+  isValidTxType,
+  resolveTxAttributesByTxType,
+  resolveTxFromAddress,
+  TX_TYPE_TRANSFER,
+} from './tx-type/index.js'
 
 async function createUnsignedTxWithFees({
   asset,
   chainId,
-  to, // the tx to address, it could be the reciver address for native sending, the token contract, the DEX contract, etc
-  value, // the value of the tx in NU, it can be the value in eth or 0 when calling contracts
-  data, // the data of the tx in hex string, it can be 0x for native sending or the params when sending to a contract
   gasLimit,
   eip1559Enabled,
   gasPrice, // eip 1559: `maxFeePerGas`
   tipGasPrice, // eip 1559: `maxPriorityPerGas`
-  nonce,
   bumpTxId,
-  coinAmount, // coinAmount
-  fromAddress, // user's sending address
-  toAddress, // user's receiver address
+  /* txAttributes */
+  amount,
+  toAddress,
+  txInput,
+  txToAddress,
+  txType,
+  txValue,
+  fromAddress,
+  nonce,
+  isContractTxToAddress,
 }) {
   assert(asset, 'asset is required')
   assert(typeof chainId === 'number', 'chainId is required')
-  assert(to, 'to is required')
-  assert(value, 'value is required')
-  assert(data, 'data is required')
   assert(gasLimit, 'gasLimit is required')
   assert(gasPrice, 'gasPrice is required')
-  assert(coinAmount, 'coinAmount is required')
-  assert(fromAddress, 'fromAddress is required')
-  assert(toAddress, 'toAddress is required')
   assert(typeof eip1559Enabled === 'boolean', 'eip1559Enabled is required')
 
+  assertTxAttributes({
+    amount,
+    toAddress,
+    txInput,
+    txToAddress,
+    txType,
+    txValue,
+    fromAddress,
+    nonce,
+    isContractTxToAddress,
+  })
+
   const ethjsTx = createEthereumJsTx({
     txData: {
       nonce,
       gasPrice: currency2buffer(gasPrice),
       tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
       gasLimit,
-      to,
-      value: currency2buffer(value),
-      data,
+      to: txToAddress,
+      value: currency2buffer(txValue),
+      data: txInput,
       chainId,
     },
     txMeta: {
@@ -67,7 +81,7 @@ async function createUnsignedTxWithFees({
     : asset.baseAsset.currency.ZERO
 
   const fee = baseFee.add(l1DataFee)
-  const extraFeeData = getExtraFeeData({ asset, amount: coinAmount })
+  const extraFeeData = getExtraFeeData({ asset, amount })
   const unsignedTx = {
     txData: { transactionBuffer, chainId },
     txMeta: {
@@ -76,7 +90,7 @@ async function createUnsignedTxWithFees({
       eip1559Enabled,
       fromAddress,
       toAddress,
-      amount: coinAmount.toDefaultString({ unit: true }),
+      amount: amount.toDefaultString({ unit: true }),
       fee: fee.toDefaultString({ unit: true }),
     },
   }
@@ -91,6 +105,35 @@ async function createUnsignedTxWithFees({
   }
 }
 
+const resolveTxFactoryGasPrices = ({
+  customFee: providedCustomFee,
+  feeData,
+  gasPrice: providedGasPrice,
+  tipGasPrice: providedTipGasPrice,
+}) => {
+  assert(feeData)
+
+  const {
+    gasPrice: maybeGasPrice,
+    feeData: { tipGasPrice: maybeTipGasPrice, eip1559Enabled },
+  } = getFeeFactoryGasPrices({ customFee: providedCustomFee, feeData })
+
+  const resolvedGasPrice = providedGasPrice ?? maybeGasPrice
+
+  if (!eip1559Enabled) return { eip1559Enabled, resolvedGasPrice }
+
+  const resolvedTipGasPrice = providedTipGasPrice ?? maybeTipGasPrice
+
+  return {
+    eip1559Enabled,
+    resolvedGasPrice: ensureSaneEip1559GasPriceForTipGasPrice({
+      gasPrice: resolvedGasPrice,
+      tipGasPrice: resolvedTipGasPrice,
+    }),
+    resolvedTipGasPrice,
+  }
+}
+
 const createBumpUnsignedTx = async ({
   fromAddress,
   chainId,
@@ -100,8 +143,11 @@ const createBumpUnsignedTx = async ({
   assetClientInterface,
   walletAccount,
   feeData,
-  nonce: providedNonce,
+  nonce: maybeProvidedNonce,
+  txType,
 }) => {
+  assert(isValidTxType(txType), 'invalid txType')
+
   const baseAsset = asset.baseAsset
   const replacedTx = baseAssetTxLog.get(bumpTxId)
   const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
@@ -131,13 +177,40 @@ const createBumpUnsignedTx = async ({
   }
 
   const toAddress = (replacedTokenTx || replacedTx).to
-  const isToken = isEthereumLikeToken(asset)
-  const txToAddress = isToken ? asset.contract.address : toAddress
-  const coinAmount = (replacedTokenTx || replacedTx).coinAmount.negate()
-  const gasLimit = replacedTx.data.gasLimit
-  const nonce = replacedTx.data.nonce
 
-  const value = isToken ? baseAsset.currency.ZERO : coinAmount
+  const amount = (replacedTokenTx || replacedTx).coinAmount.negate()
+
+  const txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
+
+  const replacedTxNonce = replacedTx.data.nonce
+
+  assert(
+    Number.isInteger(replacedTxNonce),
+    `Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`
+  )
+
+  // If we have evaluated a bump transaction and the `providedNonce` differs
+  // from the `bumpNonce`, we've encountered a conflict and cannot respect
+  // the caller's request.
+  if (maybeProvidedNonce && maybeProvidedNonce !== replacedTxNonce) {
+    throw new Error('incorrect nonce for replacement transaction')
+  }
+
+  const nonce = maybeProvidedNonce ?? replacedTxNonce
+
+  const resolvedTxAttributes = await resolveTxAttributesByTxType({
+    asset,
+    assetClientInterface,
+    fromAddress,
+    amount,
+    nonce,
+    txInput,
+    toAddress,
+    txType,
+    walletAccount,
+  })
+
+  const gasLimit = replacedTx.data.gasLimit
 
   const {
     gasPrice: currentGasPrice,
@@ -149,13 +222,13 @@ const createBumpUnsignedTx = async ({
   const maybeHighestIncentivePendingTxForNonce = await getHighestIncentivePendingTxByNonce({
     assetClientInterface,
     asset,
-    nonce,
+    nonce: resolvedTxAttributes.nonce,
     walletAccount,
   })
 
   assert(
     maybeHighestIncentivePendingTxForNonce,
-    `unable to resolve pending transaction for nonce ${nonce}`
+    `unable to resolve pending transaction for nonce ${resolvedTxAttributes.nonce}`
   )
 
   const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
@@ -171,41 +244,22 @@ const createBumpUnsignedTx = async ({
     currentTipGasPrice,
     eip1559Enabled,
   })
-  const gasPrice = bumpedGasPrice
-  const tipGasPrice = bumpedTipGasPrice
-  const data = replacedTokenTx
-    ? asset.contract.transfer.build(toAddress.toLowerCase(), coinAmount.toBaseString())
-    : replacedTx.data.data || '0x'
-
-  if (nonce === undefined) {
-    throw new Error(`Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`)
-  }
 
-  // If we have evaluated a bump transaction and the `providedNonce` differs
-  // from the `bumpNonce`, we've encountered a conflict and cannot respect
-  // the caller's request.
-  if (typeof nonce === 'number' && typeof providedNonce === 'number' && nonce !== providedNonce) {
-    throw new ErrorWrapper.EthLikeError({
-      message: new Error('incorrect nonce for replacement transaction'),
-      reason: ErrorWrapper.reasons.bumpTxFailed,
-      hint: 'providedNonce',
+  const { resolvedGasPrice: gasPrice, resolvedTipGasPrice: tipGasPrice } =
+    resolveTxFactoryGasPrices({
+      feeData,
+      gasPrice: bumpedGasPrice,
+      tipGasPrice: bumpedTipGasPrice,
     })
-  }
 
   return createUnsignedTxWithFees({
+    ...resolvedTxAttributes,
     asset,
     chainId,
-    to: txToAddress,
-    value,
-    data,
     gasLimit,
     gasPrice,
     tipGasPrice,
-    nonce,
     bumpTxId,
-    coinAmount,
-    fromAddress,
-    toAddress,
     eip1559Enabled,
   })
 }
@@ -220,33 +274,35 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     fromAddress: providedFromAddress, // wallet from address
     toAddress: providedToAddress, // user's to address, not the token or the dex contract
     txInput: providedTxInput, // Provided when swapping via a DEX contract
+    txType = TX_TYPE_TRANSFER, // Defines what kind of transaction is being performed.
     gasLimit: providedGasLimit, // Provided by exchange when known
     amount: providedAmount, // The NU amount to be sent, to be included in the tx value or tx input
     nonce: providedNonce,
     tipGasPrice: providedTipGasPrice,
     gasPrice: providedGasPrice,
     bip70,
-    customFee,
+    customFee: providedCustomFee,
     isSendAll,
     bumpTxId,
   }) => {
     assert(asset, 'asset is required')
     assert(walletAccount, 'walletAccount is required')
+    assert(isValidTxType(txType), 'invalid txType')
 
     const feeData = await assetClientInterface.getFeeConfig({ assetName: asset.baseAsset.name })
 
-    const fromAddress =
-      providedFromAddress ??
-      (await assetClientInterface.getReceiveAddress({
-        assetName: asset.baseAsset.name,
-        walletAccount,
-      }))
-
     const baseAssetTxLog = await assetClientInterface.getTxLog({
       assetName: asset.baseAsset.name,
       walletAccount,
     })
 
+    const fromAddress = await resolveTxFromAddress({
+      asset,
+      assetClientInterface,
+      fromAddress: providedFromAddress,
+      walletAccount,
+    })
+
     if (bumpTxId) {
       return createBumpUnsignedTx({
         chainId,
@@ -258,62 +314,20 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
         walletAccount,
         feeData,
         nonce: providedNonce,
+        txType,
       })
     }
 
-    const toAddress = providedToAddress || ARBITRARY_ADDRESS
     const {
-      gasPrice: maybeGasPrice,
-      feeData: { tipGasPrice: maybeTipGasPrice, eip1559Enabled },
-    } = getFeeFactoryGasPrices({ customFee, feeData })
-
-    const isToken = isEthereumLikeToken(asset)
-
-    const resolvedGasPrice = providedGasPrice ?? maybeGasPrice
-
-    // When sending a main asset, the transaction (tx) 'to' address is the receiver's address. No tx input is provided.
-    // When sending a token, the tx 'to' address is the asset.contract?.address. No tx input is provided; it's resolved locally.
-    // When DEX swapping a main asset, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
-    // When DEX swapping a token, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
-    // When CEX swapping a main asset, the exchange may provide a txInput and an address. Use this address as the tx 'to' address.
-    // When CEX swapping a token, the exchange may provide a txInput but not an address. In this case, the tx 'to' address is the token address.
-
-    const txToAddress =
-      isToken && !providedTxInput
-        ? asset.contract.address
-        : providedToAddress || asset.contract?.address || ARBITRARY_ADDRESS
-
-    const isContractToAddress = await isContractAddressCached({ asset, address: txToAddress })
-
-    // HACK: We cannot ensure the no dust invariant for `isSendAll`
-    //       transactions to contract addresses, since we may be
-    //       performing a raw token transaction and the parameter
-    //       applies to the token and not the native amount.
-    //
-    //       Contracts have nondeterministic gas most of the time
-    //       versus estimations, anyway.
-    const isSendAllBaseAsset = isSendAll && !isToken && !isContractToAddress
-
-    // For native send all transactions, we have to make sure that
-    // the `tipGasPrice` is equal to the `gasPrice`, since this is
-    // effectively like saying that the `maxFeePerGas` is equal
-    // to the `maxPriorityFeePerGas`. We do this so that for a
-    // 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.
-    const tipGasPrice =
-      providedTipGasPrice ??
-      (eip1559Enabled && isSendAllBaseAsset ? resolvedGasPrice : maybeTipGasPrice)
-
-    const gasPrice = eip1559Enabled
-      ? ensureSaneEip1559GasPriceForTipGasPrice({
-          gasPrice: resolvedGasPrice,
-          tipGasPrice,
-        })
-      : resolvedGasPrice
-
-    const nonce =
-      providedNonce ?? (await asset.baseAsset.getNonce({ asset, fromAddress, walletAccount }))
+      eip1559Enabled,
+      resolvedGasPrice: gasPrice,
+      resolvedTipGasPrice: tipGasPrice,
+    } = resolveTxFactoryGasPrices({
+      customFee: providedCustomFee,
+      feeData,
+      gasPrice: providedGasPrice,
+      tipGasPrice: providedTipGasPrice,
+    })
 
     if (nft) {
       const {
@@ -327,55 +341,81 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
         toAddress: providedToAddress,
       })
 
-      const value = asset.baseAsset.currency.ZERO
+      const resolvedTxAttributes = await resolveTxAttributesByTxType({
+        asset: asset.baseAsset,
+        assetClientInterface,
+        fromAddress,
+        nonce: providedNonce,
+        txInput,
+        toAddress: providedToAddress,
+        txToAddress,
+        txType,
+        walletAccount,
+      })
 
       return createUnsignedTxWithFees({
+        ...resolvedTxAttributes,
         chainId,
         asset,
-        to: txToAddress,
-        value,
-        data: txInput,
         gasLimit,
         gasPrice,
         tipGasPrice,
-        nonce,
-        coinAmount: value,
-        fromAddress,
-        toAddress,
         eip1559Enabled,
       })
     }
 
-    const amount = providedAmount ?? asset.currency.ZERO
+    const resolvedTxAttributes = await resolveTxAttributesByTxType({
+      asset,
+      assetClientInterface,
+      amount: providedAmount,
+      fromAddress,
+      nonce: providedNonce,
+      txInput: providedTxInput,
+      toAddress: providedToAddress,
+      txType,
+      walletAccount,
+    })
 
-    const value = isToken ? asset.baseAsset.currency.ZERO : amount
-    const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
+    // TODO: `gasLimit` should become `txGasLimit` and returned
+    //       by `resolveTxAttributesByTxType`.
     const gasLimit =
       providedGasLimit ??
       (await fetchGasLimit({
         asset,
         feeData,
         fromAddress,
-        toAddress: providedToAddress,
-        txInput: providedTxInput,
-        contractAddress: txToAddress,
+        toAddress: resolvedTxAttributes.toAddress,
+        txInput: resolvedTxAttributes.txInput,
+        contractAddress: resolvedTxAttributes.txToAddress,
         bip70,
-        amount,
+        amount: resolvedTxAttributes.amount,
+        txType,
       }))
 
+    // HACK: We cannot ensure the no dust invariant for `isSendAll`
+    //       transactions to contract addresses, since we may be
+    //       performing a raw token transaction and the parameter
+    //       applies to the token and not the native amount.
+    //
+    //       Contracts have nondeterministic gas most of the time
+    //       versus estimations, anyway.
+    const isSendAllBaseAsset =
+      isSendAll && !isEthereumLikeToken(asset) && !resolvedTxAttributes.isContractTxToAddress
+
     return createUnsignedTxWithFees({
+      ...resolvedTxAttributes,
       asset,
       chainId,
-      to: txToAddress,
-      value,
-      data: txInput,
       gasLimit,
       gasPrice,
-      tipGasPrice,
-      nonce,
-      coinAmount: amount,
-      fromAddress,
-      toAddress,
+      // For native send all transactions, we have to make sure that
+      // the `tipGasPrice` is equal to the `gasPrice`, since this is
+      // effectively like saying that the `maxFeePerGas` is equal
+      // to the `maxPriorityFeePerGas`. We do this so that for a
+      // 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,
       eip1559Enabled,
     })
   }

package/src/tx-log/get-optimistic-txlog-effects.js

@@ -1,3 +1,4 @@
+import { SynchronizedTime } from '@exodus/basic-utils'
 import NumberUnit from '@exodus/currency'
 import { isEthereumLikeToken, parseUnsignedTx } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
@@ -33,6 +34,7 @@ export const getOptimisticTxLogEffects = async ({
   asset,
   assetClientInterface,
   confirmations = 0,
+  date = SynchronizedTime.now(),
   fromAddress,
   txId,
   unsignedTx,
@@ -49,7 +51,7 @@ export const getOptimisticTxLogEffects = async ({
   // this converts an transactionBuffer to values we can use when creating the tx logs
   const parsedTx = parseUnsignedTx({ asset, unsignedTx })
 
-  const { nonce } = parsedTx
+  const { nonce, to } = parsedTx
   assert(Number.isInteger(nonce), 'expected integer nonce')
 
   const amount = parsedTx.amount || asset.currency.ZERO
@@ -66,13 +68,12 @@ export const getOptimisticTxLogEffects = async ({
   const gasLimit = parsedTx.gasLimit
   assert(Number.isInteger(gasLimit), 'expected integer gasLimit')
 
-  const toAddress = parsedTx.to
-  assert(typeof toAddress === 'string', 'expected string toAddress')
+  if (to) assert(typeof to === 'string', 'expected string toAddress')
 
   const data = parsedTx.data
   const methodId = data ? bufferToHex(data).slice(0, 10) : undefined
 
-  const selfSend = fromAddress.toLowerCase() === toAddress.toLowerCase()
+  const selfSend = fromAddress.toLowerCase() === to?.toLowerCase()
 
   const baseAsset = asset.baseAsset
 
@@ -92,10 +93,11 @@ export const getOptimisticTxLogEffects = async ({
 
   const sharedProps = {
     confirmations,
+    date,
     feeAmount,
     feeCoinName: asset.feeAsset.name,
     selfSend,
-    to: toAddress,
+    to,
     txId,
     data: {
       gasLimit,

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

@@ -3,8 +3,8 @@ import assert from 'minimalistic-assert'
 
 import * as ErrorWrapper from '../error-wrapper.js'
 import { transactionExists } from '../eth-like-util.js'
-import { ARBITRARY_ADDRESS } from '../gas-estimation.js'
 import { getOptimisticTxLogEffects } from '../tx-log/index.js'
+import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
 
 const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
@@ -40,13 +40,13 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     const { unsignedTx } = await resolveUnsignedTx()
 
     const parsedTx = parseUnsignedTx({ asset, unsignedTx })
-    const toAddress = parsedTx.to
 
     // unknown data from buffer...
+    const to = parsedTx.to
     const fromAddress = unsignedTx.txMeta.fromAddress
 
     assert(
-      toAddress.toLowerCase() !== ARBITRARY_ADDRESS,
+      to?.toLowerCase() !== ARBITRARY_ADDRESS,
       `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
 
@@ -140,7 +140,6 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       walletAccount,
     })
 
-    // NOTE: `optimisticTxLogEffects` **must** be written sequentially.
     for (const optimisticTxLogEffect of optimisticTxLogEffects) {
       await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
     }

package/src/tx-type/index.js

@@ -0,0 +1,236 @@
+import NumberUnit from '@exodus/currency'
+import { isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import assert from 'minimalistic-assert'
+
+import { isContractAddressCached } from '../eth-like-util.js'
+
+export const TX_TYPE_TRANSFER = 'transfer'
+
+const VALID_TX_TYPES = new Set([TX_TYPE_TRANSFER])
+
+export const isValidTxType = (txType) => VALID_TX_TYPES.has(txType)
+
+// TODO: Remove this.
+// HACK: If a recipient address is not defined, we usually fall back to
+//       default address so gas estimation can still complete successfully
+//       without knowledge of which accounts are involved.
+//
+//       However, we must be careful to select addresses which are unlikely
+//       to have existing obligations, such as popular dead addresses or the
+//       reserved addresses of precompiles, since these can influence gas
+//       estimation.
+//
+//       Here, we use an address which is mostly all `1`s to make sure we can
+//       exaggerate the worst-case calldata cost (which is priced per high bit)
+//       whilst being unlikely to have any token balances.
+//
+//       Unfortunately, we can't use `0xffffffffffffffffffffffffffffffffffffffff`,
+//       since this address is a whale.
+export const ARBITRARY_ADDRESS = '0xfffFfFfFfFfFFFFFfeFfFFFffFffFFFFfFFFFFFF'.toLowerCase()
+
+export const assertCriticalTxAttributes = (criticalTxAttributes) => {
+  const { amount, toAddress, txInput, txToAddress, txType, txValue } = criticalTxAttributes
+
+  assert(amount instanceof NumberUnit, 'expected NumberUnit amount')
+  assert(typeof toAddress === 'string', 'expected string toAddress')
+  assert(
+    typeof txInput === 'string' && txInput.startsWith('0x', 'expected hexadecimal string txInput')
+  )
+  assert(typeof txToAddress === 'string', 'expected string txToAddress')
+  assert(isValidTxType(txType), 'expected valid txType')
+  assert(txValue instanceof NumberUnit, 'expected NumberUnit txValue')
+
+  return criticalTxAttributes
+}
+
+export const assertTxAttributes = (txAttributes) => {
+  // TODO: Note that the distinction between "critical" and "non-critical"
+  //       only exists to satisfy `fetchGasLimit` needing to know some props.
+  //       Once we encapsulate `gasLimit`, all properties will be critical.
+  const {
+    /* critical */
+    amount,
+    toAddress,
+    txInput,
+    txToAddress,
+    txType,
+    txValue,
+    /* non-critical */
+    fromAddress,
+    nonce,
+    isContractTxToAddress,
+  } = txAttributes
+
+  assertCriticalTxAttributes({ amount, toAddress, txInput, txToAddress, txType, txValue })
+
+  assert(typeof fromAddress === 'string', 'expected fromAddress')
+  assert(Number.isInteger(nonce), 'expected integer nonce')
+  assert(typeof isContractTxToAddress === 'boolean', 'expected boolean isContractTxToAddress')
+
+  return txAttributes
+}
+
+const createResolvedTxAttributes = async ({
+  amount,
+  asset,
+  fromAddress,
+  nonce,
+  toAddress,
+  txInput,
+  txToAddress,
+  txValue,
+  txType,
+}) =>
+  assertTxAttributes({
+    amount,
+    fromAddress,
+    nonce,
+    toAddress,
+    txInput,
+    txToAddress,
+    txValue,
+    txType,
+    isContractTxToAddress: await isContractAddressCached({ asset, address: txToAddress }),
+  })
+
+export const resolveTxFromAddress = async ({
+  asset,
+  assetClientInterface,
+  fromAddress: providedFromAddress,
+  walletAccount,
+}) => {
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(walletAccount, 'expected walletAccount')
+
+  if (providedFromAddress) return providedFromAddress
+
+  return assetClientInterface.getReceiveAddress({
+    assetName: asset.baseAsset.name,
+    walletAccount,
+  })
+}
+
+const resolveTxNonce = async ({ asset, fromAddress, nonce: providedNonce, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(typeof fromAddress === 'string', 'expected string fromAddress')
+  assert(walletAccount, 'expected walletAccount')
+
+  if (Number.isInteger(providedNonce)) return providedNonce
+
+  return asset.baseAsset.getNonce({ asset, fromAddress, walletAccount })
+}
+
+const resolveTxInput = ({ asset, toAddress, amount, txInput: providedTxInput }) => {
+  assert(asset, 'expected asset')
+  assert(typeof toAddress === 'string', 'expected string toAddress')
+  assert(amount instanceof NumberUnit, 'expected NumberUnit amount')
+
+  if (providedTxInput) return bufferToHex(providedTxInput)
+
+  if (!isEthereumLikeToken(asset)) return '0x'
+
+  return bufferToHex(asset.contract.transfer.build(toAddress.toLowerCase(), amount?.toBaseString()))
+}
+
+export const resolveCriticalTxAttributes = ({
+  asset,
+  amount: providedAmount,
+  toAddress: providedToAddress,
+  txToAddress: providedTxToAddress,
+  txInput: providedTxInput,
+  txType,
+}) => {
+  assert(asset, 'expected asset')
+  assert(isValidTxType(txType), 'expected valid txType')
+
+  const amount = providedAmount ?? asset.currency.ZERO
+  assert(amount instanceof NumberUnit, 'expected providedAmount')
+  assert(txType === TX_TYPE_TRANSFER, 'expected TX_TYPE_TRANSFER')
+
+  // HACK: If a `toAddress` hasn't been defined, then we
+  //       fall back to the `ARBITRARY_ADDRESS`. Note that
+  //       this should only be used to help determine the
+  //       fee of a transaction where we don't yet know the
+  //       intended recipient. Attempts to send to this
+  //       sentinel address will ultimately `throw`.
+  const toAddress = providedToAddress || ARBITRARY_ADDRESS
+  const txValue = isEthereumLikeToken(asset) ? asset.baseAsset.currency.ZERO : amount
+  const txInput = resolveTxInput({ amount, asset, txInput: providedTxInput, toAddress })
+
+  const baseProps = {
+    amount,
+    toAddress,
+    txInput,
+    txType,
+    txValue,
+  }
+
+  // When CEX swapping a main asset, the exchange may provide a txInput and an address. Use this address as the tx 'to' address.
+  // When DEX swapping a main asset, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
+  // When sending a main asset, the transaction (tx) 'to' address is the receiver's address. No tx input is provided.
+  if (!isEthereumLikeToken(asset)) {
+    return assertCriticalTxAttributes({
+      ...baseProps,
+      txToAddress: providedTxToAddress || toAddress,
+    })
+  }
+
+  if (providedTxInput) {
+    // When CEX swapping a token, the exchange may provide a txInput but not an address. In this case, the tx 'to' address is the token address.
+    // When DEX swapping a token, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
+    const txToAddress = providedTxToAddress || providedToAddress || asset.contract?.address
+    return assertCriticalTxAttributes({ ...baseProps, txToAddress })
+  }
+
+  // When sending a token, the tx 'to' address is the asset.contract?.address. No tx input is provided; it's resolved locally.
+  const txToAddress = asset.contract?.address
+  return assertCriticalTxAttributes({ ...baseProps, txToAddress })
+}
+
+// Normalizes the properties of transactions that can
+// vary depending upon the `txType` and `asset` to
+// ensure these evaluate consistently.
+export const resolveTxAttributesByTxType = async ({
+  asset,
+  assetClientInterface,
+  amount: providedAmount,
+  fromAddress: providedFromAddress,
+  nonce: providedNonce,
+  txInput: providedTxInput,
+  txToAddress: providedTxToAddress,
+  toAddress: providedToAddress,
+  txType,
+  walletAccount,
+}) => {
+  assert(isValidTxType(txType), 'expected valid txType')
+
+  const fromAddress = await resolveTxFromAddress({
+    asset,
+    assetClientInterface,
+    fromAddress: providedFromAddress,
+    walletAccount,
+  })
+
+  const nonce = await resolveTxNonce({
+    asset,
+    fromAddress,
+    nonce: providedNonce,
+    walletAccount,
+  })
+
+  return createResolvedTxAttributes({
+    asset,
+    fromAddress,
+    nonce,
+    ...resolveCriticalTxAttributes({
+      asset,
+      amount: providedAmount,
+      toAddress: providedToAddress,
+      txInput: providedTxInput,
+      txToAddress: providedTxToAddress,
+      txType,
+    }),
+  })
+}