@exodus/ethereum-api 8.42.2 → 8.43.1

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.43.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.43.0...@exodus/ethereum-api@8.43.1) (2025-07-17)
+
+**Note:** Version bump only for package @exodus/ethereum-api
+
+
+
+
+
+## [8.43.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.42.2...@exodus/ethereum-api@8.43.0) (2025-07-14)
+
+
+### Features
+
+
+* feat: tx send split, tx-create (#5854)
+
+
+
 ## [8.42.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.42.1...@exodus/ethereum-api@8.42.2) (2025-07-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.42.2",
+  "version": "8.43.1",
   "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",
@@ -28,7 +28,7 @@
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.13",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.15.1",
+    "@exodus/ethereum-lib": "^5.16.0",
     "@exodus/ethereum-meta": "^2.5.0",
     "@exodus/ethereumholesky-meta": "^2.0.2",
     "@exodus/ethereumjs": "^1.0.0",
@@ -63,5 +63,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "b719d7ad24ba1be671d286e2859afc22ab3b7255"
+  "gitHead": "ef192865e8886dedb72c280a1b252ff177e20067"
 }

package/src/create-asset-utils.js

@@ -60,6 +60,16 @@ export const resolveMonitorSettings = (
   return { ...defaultResolution, monitorType: overrideMonitorType, serverUrl: overrideServerUrl }
 }
 
+const stringifyPrivateTx = (tx) => {
+  assert(tx, 'expected tx')
+  if (tx instanceof Uint8Array) return `0x${Buffer.from(tx).toString('hex')}`
+
+  assert(typeof tx === 'string', 'expected string')
+  if (tx.startsWith('0x')) return tx
+
+  return `0x${tx}`
+}
+
 const broadcastPrivateBundleFactory =
   ({ privacyServer }) =>
   async ({ txs }) => {
@@ -69,7 +79,7 @@ const broadcastPrivateBundleFactory =
     await privacyServer.sendRequest(
       privacyServer.buildRequest({
         method: 'eth_sendBundle',
-        params: [{ txs }],
+        params: [{ txs: txs.map((tx) => stringifyPrivateTx(tx)) }],
       })
     )
   }
@@ -157,7 +167,7 @@ export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNon
   assert(assetClientInterface, 'expected assetClientInterface')
   assert(typeof useAbsoluteBalanceAndNonce === 'boolean', 'expected useAbsoluteBalanceAndNonce')
 
-  const getNonce = async ({ asset, fromAddress, walletAccount }) => {
+  const getNonce = async ({ asset, fromAddress, walletAccount, triedNonce, forceFromNode }) => {
     assert(asset, 'expected asset')
     assert(typeof fromAddress === 'string', 'expected fromAddress')
     assert(walletAccount, 'expected walletAccount')
@@ -171,6 +181,8 @@ export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNon
       asset,
       fromAddress,
       txLog,
+      triedNonce,
+      forceFromNode,
       // For assets where we'll fall back to querying the coin node, we
       // search for pending transactions. For base assets with history,
       // we'll fall back to the `TxLog` since this also has a knowledge

package/src/create-asset.js

@@ -37,6 +37,7 @@ import getFeeAsyncFactory from './get-fee-async.js'
 import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
 import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
 import { createStakingApi } from './staking-api.js'
+import { createTxFactory } from './tx-create.js'
 import { txSendFactory } from './tx-send/index.js'
 import { createWeb3API } from './web3/index.js'
 
@@ -221,10 +222,15 @@ export const createAssetFactory = ({
 
     const createUnsignedTx = createUnsignedTxFactory({ chainId })
 
+    const createTx = createTxFactory({
+      chainId,
+      assetClientInterface,
+      useAbsoluteNonce: useAbsoluteBalanceAndNonce,
+    })
+
     const sendTx = txSendFactory({
       assetClientInterface,
-      createUnsignedTx,
-      useAbsoluteBalanceAndNonce,
+      createTx,
     })
 
     const estimateL1DataFee = l1GasOracleAddress
@@ -246,6 +252,7 @@ export const createAssetFactory = ({
       createFeeMonitor,
       createHistoryMonitor,
       createToken,
+      createTx,
       createUnsignedTx,
       customFees: createCustomFeesApi({ baseAsset: asset }),
       defaultAddressPath,
@@ -255,7 +262,7 @@ export const createAssetFactory = ({
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
       getConfirmationsNumber: () => confirmationsNumber,
       getDefaultAddressPath: () => defaultAddressPath,
-      getFeeAsync: getFeeAsyncFactory({ assetClientInterface, gasLimit, createUnsignedTx }),
+      getFeeAsync: getFeeAsyncFactory({ assetClientInterface, gasLimit, createTx }),
       getFee,
       getFeeData: () => feeData,
       getKeyIdentifier: createGetKeyIdentifier({

package/src/gas-estimation.js

@@ -114,6 +114,7 @@ export async function fetchGasLimit({
   toAddress: providedToAddress,
   txInput: providedTxInput,
   amount: providedAmount,
+  contractAddress,
   bip70,
   throwOnError = true,
 }) {
@@ -146,7 +147,7 @@ export async function fetchGasLimit({
     toAddress: providedToAddress,
   })
 
-  const txToAddress = isToken ? asset.contract.address : toAddress
+  const txToAddress = contractAddress ?? (isToken ? asset.contract.address : toAddress)
   const txAmount = isToken ? asset.baseAsset.currency.ZERO : amount
 
   try {

package/src/get-fee-async.js

@@ -1,89 +1,21 @@
 import assert from 'minimalistic-assert'
 
-import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
-import { getFeeFactory } from './get-fee.js'
-import { getNftArguments } from './nft-utils.js'
+import { getExtraFeeData } from './get-fee.js'
 
-const getFeeAsyncFactory = ({
-  assetClientInterface,
-  gasLimit: defaultGasLimit,
-  createUnsignedTx,
-}) => {
+const getFeeAsyncFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createUnsignedTx, 'createUnsignedTx is required')
-  const getFee = getFeeFactory({ gasLimit: defaultGasLimit })
-  return async ({
-    nft,
-    asset,
-    // provided are values from the UI or other services, they could be undefined
-    fromAddress: providedFromAddress,
-    toAddress: providedToAddress,
-    amount: providedAmount,
-    txInput: providedTxInput,
-    gasLimit: providedGasLimit,
-    bip70,
-    customFee,
-    feeData,
-  }) => {
-    const fromAddress = providedFromAddress || ARBITRARY_ADDRESS // sending from a random address
-    const toAddress = providedToAddress || ARBITRARY_ADDRESS // sending to a random address,
-    const amount = providedAmount ?? asset.currency.ZERO
-    const resolveGasLimit = async () => {
-      if (nft) {
-        return getNftArguments({ asset, nft, fromAddress, toAddress })
-      }
-
-      const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
-      if (providedGasLimit) return { gasLimit: providedGasLimit, txInput }
-
-      const gasLimit = await fetchGasLimit({
-        asset,
-        fromAddress: providedFromAddress,
-        toAddress: providedToAddress,
-        txInput,
-        amount,
-        bip70,
-        feeData,
-      })
-      return { gasLimit, txInput }
-    }
-
-    const { txInput, gasLimit, contractAddress } = await resolveGasLimit()
-
-    const { fee, gasPrice, ...rest } = getFee({
-      asset,
-      feeData,
-      gasLimit,
-      amount,
-      customFee,
-    })
-
-    const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-      ? await asset.baseAsset.estimateL1DataFee({
-          unsignedTx: createUnsignedTx({
-            asset,
-            address: contractAddress || toAddress,
-            fromAddress,
-            amount,
-            nonce: 0,
-            txInput,
-            gasPrice,
-            gasLimit,
-          }),
-        })
-      : undefined
-
-    const l1DataFee = optimismL1DataFee
-      ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-      : asset.baseAsset.currency.ZERO
-
+  assert(createTx, 'createTx is required')
+
+  return async (params) => {
+    const { asset } = params
+    const { unsignedTx } = params.unsignedTx ? params : await createTx(params)
+    const fee = asset.feeAsset.currency.parse(unsignedTx.txMeta.fee)
+    const coinAmount = asset.currency.parse(unsignedTx.txMeta.amount)
+    const extraFeeData = getExtraFeeData({ asset, amount: coinAmount })
     return {
-      fee: fee.add(l1DataFee),
-      // TODO: Should this be `l1DataFee`?
-      optimismL1DataFee,
-      gasLimit,
-      gasPrice,
-      ...rest,
+      fee,
+      extraFeeData,
+      unsignedTx,
     }
   }
 }

package/src/get-fee.js

@@ -11,7 +11,7 @@ const taxes = {
   paxgold: 0.0002,
 }
 
-const getExtraFeeData = ({ asset, amount }) => {
+export const getExtraFeeData = ({ asset, amount }) => {
   const tax = taxes[asset.name]
   if (!amount || !tax || amount.isZero) {
     return {}

package/src/index.js

@@ -83,9 +83,7 @@ export {
 
 export { reasons as errorReasons, withErrorReason, EthLikeError } from './error-wrapper.js'
 
-// TODO: `getFeeInfo` is not consumed by third parties and should
-//        be considered an internal API.
-export { txSendFactory, getFeeInfo } from './tx-send/index.js'
+export { txSendFactory } from './tx-send/index.js'
 
 export { createAssetFactory } from './create-asset.js'
 

package/src/tx-create.js

@@ -0,0 +1,340 @@
+import { calculateBumpedGasPrice, currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
+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 { getFeeFactoryGasPrices } from './get-fee.js'
+import { getNftArguments } from './nft-utils.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
+}) {
+  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')
+
+  const ethjsTx = createEthereumJsTx({
+    txData: {
+      nonce,
+      gasPrice: currency2buffer(gasPrice),
+      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
+      gasLimit,
+      to,
+      value: currency2buffer(value),
+      data,
+      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)
+
+  const unsignedTx = {
+    txData: { transactionBuffer, chainId },
+    txMeta: {
+      bumpTxId,
+      eip1559Enabled,
+      fromAddress,
+      toAddress,
+      amount: coinAmount.toDefaultString({ unit: true }),
+      fee: fee.toDefaultString({ unit: true }),
+    },
+  }
+  return { unsignedTx }
+}
+
+const createBumpUnsignedTx = async ({
+  fromAddress,
+  chainId,
+  asset,
+  bumpTxId,
+  baseAssetTxLog,
+  assetClientInterface,
+  walletAccount,
+  feeData,
+  nonce: providedNonce,
+}) => {
+  const baseAsset = asset.baseAsset
+  const replacedTx = baseAssetTxLog.get(bumpTxId)
+  const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
+  if (!replacedTx || !replacedTx.pending) {
+    throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
+  }
+
+  let replacedTokenTx
+  if (replacedTx.tokens.length > 0) {
+    const [tokenAssetName] = replacedTx.tokens
+    const tokenTxSet = await assetClientInterface.getTxLog({
+      assetName: tokenAssetName,
+      walletAccount,
+    })
+    replacedTokenTx = tokenTxSet.get(bumpTxId)
+
+    if (replacedTokenTx) {
+      // Attempt to overwrite the asset to reflect the fact that
+      // we're performing a token transaction.
+      asset = assets[tokenAssetName]
+      if (!asset) {
+        throw new Error(
+          `unable to find ${tokenAssetName} during token bump transaction: asset was not available in assetsForNetwork`
+        )
+      }
+    }
+  }
+
+  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 value = isToken ? baseAsset.currency.ZERO : coinAmount
+
+  const {
+    gasPrice: currentGasPrice,
+    baseFeePerGas: currentBaseFee,
+    eip1559Enabled,
+    tipGasPrice: currentTipGasPrice,
+  } = feeData
+  const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
+    baseAsset,
+    tx: replacedTx,
+    currentGasPrice,
+    currentBaseFee,
+    currentTipGasPrice,
+    eip1559Enabled,
+  })
+  const gasPrice = bumpedGasPrice
+  const tipGasPrice = bumpedTipGasPrice
+  const nonce = replacedTx.data.nonce
+  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',
+    })
+
+  return createUnsignedTxWithFees({
+    asset,
+    chainId,
+    to: txToAddress,
+    value,
+    data,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    bumpTxId,
+    coinAmount,
+    fromAddress,
+    toAddress,
+    eip1559Enabled,
+  })
+}
+
+export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonce }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(typeof chainId === 'number', 'chainId is required')
+  return async ({
+    asset,
+    walletAccount,
+    feeData,
+    nft, // when sending nfts
+    fromAddress: providedFromAddress, // wallet from address
+    toAddress: providedToAddress, // user's to address, not the token or the dex contract
+    contractAddress: providedContractAddress, // Provided when swapping a token via the DEX contract, not via the token's contract
+    txInput: providedTxInput, // Provided when swapping via a DEX contract
+    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,
+    isExchange,
+    customFee,
+    isSendAll,
+    bumpTxId,
+    keepTxInput, // @deprecated this flag is used by swaps when swapping a token via DEX. The asset is token but the tx TO address is not the token address. Update swap to use `contractAddress`
+  }) => {
+    assert(asset, 'asset is required')
+    assert(feeData, 'feeData is required')
+    const fromAddress = providedFromAddress || ARBITRARY_ADDRESS
+
+    const baseAssetTxLog = await assetClientInterface.getTxLog({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+
+    if (bumpTxId) {
+      return createBumpUnsignedTx({
+        chainId,
+        asset,
+        fromAddress,
+        bumpTxId,
+        baseAssetTxLog,
+        assetClientInterface,
+        walletAccount,
+        feeData,
+        nonce: providedNonce,
+      })
+    }
+
+    const toAddress = providedToAddress || ARBITRARY_ADDRESS
+    const {
+      gasPrice: maybeGasPrice,
+      feeData: { tipGasPrice: maybeTipGasPrice, eip1559Enabled },
+    } = getFeeFactoryGasPrices({ customFee, feeData })
+
+    const isToken = isEthereumLikeToken(asset)
+
+    const resolvedGasPrice = providedGasPrice ?? maybeGasPrice
+
+    const txToAddress =
+      providedContractAddress ?? (isToken && !keepTxInput ? asset.contract.address : toAddress)
+
+    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 }))
+
+    if (nft) {
+      const {
+        contractAddress: txToAddress,
+        gasLimit,
+        txInput,
+      } = await getNftArguments({
+        asset,
+        nft,
+        fromAddress,
+        toAddress: providedToAddress,
+      })
+
+      const value = asset.baseAsset.currency.ZERO
+
+      return createUnsignedTxWithFees({
+        chainId,
+        asset,
+        to: txToAddress,
+        value,
+        data: txInput,
+        gasLimit,
+        gasPrice,
+        tipGasPrice,
+        nonce,
+        coinAmount: value,
+        fromAddress,
+        toAddress,
+        eip1559Enabled,
+      })
+    }
+
+    const amount = providedAmount ?? asset.currency.ZERO
+
+    const value = isToken ? asset.baseAsset.currency.ZERO : amount
+    const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
+    const gasLimit =
+      providedGasLimit ??
+      (await fetchGasLimit({
+        asset,
+        feeData,
+        fromAddress: providedFromAddress,
+        toAddress: providedToAddress,
+        txInput: providedTxInput,
+        contractAddress: txToAddress,
+        bip70,
+        amount,
+      }))
+
+    return createUnsignedTxWithFees({
+      asset,
+      chainId,
+      to: txToAddress,
+      value,
+      data: txInput,
+      gasLimit,
+      gasPrice,
+      tipGasPrice,
+      nonce,
+      coinAmount: amount,
+      fromAddress,
+      toAddress,
+      eip1559Enabled,
+    })
+  }
+}

package/src/tx-send/index.js

@@ -1,2 +1 @@
 export { default as txSendFactory } from './tx-send.js'
-export { default as getFeeInfo } from './get-fee-info.js'

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

@@ -5,7 +5,7 @@ export const resolveNonce = async ({
   forceFromNode,
   fromAddress,
   providedNonce,
-  txLog,
+  txLog = [],
   triedNonce,
   tag = 'latest', // use 'pending' for unconfirmed txs
   useAbsoluteNonce,

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

@@ -1,230 +1,97 @@
-/* eslint-disable  @exodus/export-default/last */
-
-import { calculateBumpedGasPrice, isEthereumLikeToken, normalizeTxId } from '@exodus/ethereum-lib'
+import {
+  isEthereumLikeToken,
+  normalizeTxId,
+  parseUnsignedTx,
+  updateNonce,
+} from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import * as ErrorWrapper from '../error-wrapper.js'
-import { isContractAddressCached, transactionExists } from '../eth-like-util.js'
-import { getNftArguments } from '../nft-utils.js'
-import getFeeInfo from './get-fee-info.js'
-import { resolveNonce } from './nonce-utils.js'
-
-// Exodus enforces a strict invariant that `sendAll` transactions
-// must not leave any dust in the sender's account. Currently, the
-// assets library has the expectation that the client frontend
-// should calculate the precise amount to send, but due to the
-// sheer amount of variables involved when resolving a `gasPrice`,
-// this is a significant undertaking.
-//
-// Therefore, although clients try their very best to calculate
-// the correct amount, in cases this fails we can fall back to
-// the implementation defined here with a warning.
-// eslint-disable-next-line camelcase
-export const HACK_maybeRefineSendAllAmount = async ({
-  amount: providedAmount,
-  asset,
-  assetClientInterface,
-  walletAccount,
-  gasLimit,
-  gasPrice,
-}) => {
-  try {
-    const { name: assetName, estimateL1DataFee } = asset
-
-    // HACK: For the interim, we won't attempt to
-    //       reconcile transaction dust on L2s due
-    //       to the nondeterminism about the calldata
-    //       fee.
-    if (typeof estimateL1DataFee === 'function') return null
-
-    const [txLog, accountState] = await Promise.all([
-      assetClientInterface.getTxLog({
-        assetName,
-        walletAccount,
-      }),
-      assetClientInterface.getAccountState({
-        assetName,
-        walletAccount,
-      }),
-    ])
-
-    const { spendable } = await asset.api.getBalances({ asset, txLog, accountState })
-    const maxGasCost = gasPrice.mul(gasLimit)
-
-    if (maxGasCost.gt(spendable)) throw new Error('transaction gas cost exceeds spendable balance')
+import { transactionExists } from '../eth-like-util.js'
+import { ARBITRARY_ADDRESS } from '../gas-estimation.js'
 
-    const expectedSendAllAmount = spendable.sub(maxGasCost)
+const txSendFactory = ({ assetClientInterface, createTx }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(createTx, 'createTx is required')
 
-    // If the client attempted to send the correct
-    // amount, good job! You get a cookie!
-    if (providedAmount.equals(expectedSendAllAmount)) return null
+  async function signTx({ asset, unsignedTx, walletAccount }) {
+    const { rawTx, txId } = await assetClientInterface.signTransaction({
+      assetName: asset.baseAsset.name,
+      unsignedTx,
+      walletAccount,
+    })
 
-    // The client attempted to `sendAll` using the incorrect amount.
-    return expectedSendAllAmount
-  } catch (e) {
-    console.error('failed to refine send all amount', e)
-    return null
+    return { rawTx, txId: normalizeTxId(txId) }
   }
-}
-
-const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBalanceAndNonce }) => {
-  assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createUnsignedTx, 'createUnsignedTx is required')
-  return async ({ asset, walletAccount, address, amount, feeData: maybeFeeData, options = {} }) => {
-    const {
-      nft,
-      bumpTxId,
-      nonce: providedNonce,
-      customFee,
-      keepTxInput,
-      isSendAll,
-      isHardware,
-      isPrivate,
-    } = options
-    let { txInput, feeAmount: providedFeeAmount } = options // avoid let!
-
-    const feeOpts = {
-      gasPrice: options.gasPrice,
-      tipGasPrice: options.tipGasPrice,
-      gasLimit: options.gasLimit,
-    }
 
+  return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
     const assetName = asset.name
     const baseAsset = asset.baseAsset
 
-    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
-
-    const feeData =
-      maybeFeeData ||
-      (await assetClientInterface.getFeeData({
-        assetName: baseAsset.name,
-      }))
+    const resolveUnsignedTx = async () => {
+      if (providedUnsignedTx) {
+        return { unsignedTx: providedUnsignedTx }
+      }
 
-    const { eip1559Enabled } = feeData
+      const feeData =
+        legacyParams.feeData ??
+        (await assetClientInterface.getFeeData({
+          assetName: baseAsset.name,
+        }))
 
-    const fromAddress = await assetClientInterface.getReceiveAddress({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
+      const fromAddress =
+        legacyParams.fromAddress ??
+        (await assetClientInterface.getReceiveAddress({
+          assetName: baseAsset.name,
+          walletAccount,
+        }))
 
-    let contractAddress
-    if (nft) {
-      const nftArguments = await getNftArguments({ asset, nft, fromAddress, toAddress: address })
-      contractAddress = nftArguments.contractAddress
-      feeOpts.gasLimit = nftArguments.gasLimit
-      txInput = nftArguments.txInput
-      amount = asset.baseAsset.currency.ZERO
+      return createTx({
+        asset,
+        walletAccount,
+        feeData,
+        fromAddress,
+        toAddress: legacyParams.address,
+        ...legacyParams,
+        ...legacyParams.options,
+      })
     }
 
-    let bumpNonce
-
-    const baseAssetTxLog = await assetClientInterface.getTxLog({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
-
-    // `replacedTx` is always an ETH/ETC transaction (not a token)
-    let replacedTx, replacedTokenTx
-    if (bumpTxId) {
-      replacedTx = baseAssetTxLog.get(bumpTxId)
+    const { unsignedTx } = await resolveUnsignedTx()
 
-      if (!replacedTx || !replacedTx.pending) {
-        throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
-      }
+    // this converts an transactionBuffer to values we can use when creating the tx logs
+    const parsedTx = parseUnsignedTx({ asset, unsignedTx })
 
-      if (replacedTx.tokens.length > 0) {
-        const [tokenAssetName] = replacedTx.tokens
-        const tokenTxSet = await assetClientInterface.getTxLog({
-          assetName: tokenAssetName,
-          walletAccount,
-        })
-        replacedTokenTx = tokenTxSet.get(bumpTxId)
+    // the txMeta.fee may include implicit l1 fees
+    const feeAmount = unsignedTx.txMeta.fee
+      ? asset.feeAsset.currency.parse(unsignedTx.txMeta.fee)
+      : parsedTx.fee
 
-        if (replacedTokenTx) {
-          // Attempt to overwrite the asset to reflect the fact that
-          // we're performing a token transaction.
-          asset = assets[tokenAssetName]
-          if (!asset) {
-            console.warn(
-              `unable to find ${tokenAssetName} during token bump transaction: asset was not available in assetsForNetwork`
-            )
-          }
-        }
+    let nonce = parsedTx.nonce
 
-        // TODO: Should we `throw` if we can't find the asset?
-      }
-
-      address = (replacedTokenTx || replacedTx).to
-      amount = (replacedTokenTx || replacedTx).coinAmount.negate()
-      feeOpts.gasLimit = replacedTx.data.gasLimit
+    const tipGasPrice = parsedTx.tipGasPrice
+    const gasLimit = parsedTx.gasLimit
+    const amount = parsedTx.amount
+    const to = parsedTx.to
+    const eip1559Enabled = parsedTx.eip1559Enabled
 
-      const {
-        gasPrice: currentGasPrice,
-        baseFeePerGas: currentBaseFee,
-        tipGasPrice: currentTipGasPrice,
-      } = feeData
-      const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
-        baseAsset,
-        tx: replacedTx,
-        currentGasPrice,
-        currentBaseFee,
-        currentTipGasPrice,
-        eip1559Enabled,
-      })
-      feeOpts.gasPrice = bumpedGasPrice
-      feeOpts.tipGasPrice = bumpedTipGasPrice
-      bumpNonce = replacedTx.data.nonce
-      txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
-      if (bumpNonce === undefined) {
-        throw new Error(`Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`)
-      }
-    }
+    // unknown data from buffer...
+    const fromAddress = unsignedTx.txMeta.fromAddress
+    const selfSend = fromAddress === to
+    const replacedTxId = unsignedTx.txMeta.bumpTxId
 
-    // 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 bumpNonce === 'number' &&
-      typeof providedNonce === 'number' &&
-      bumpNonce !== providedNonce
+    assert(
+      to.toLowerCase() !== ARBITRARY_ADDRESS,
+      `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
-      throw new ErrorWrapper.EthLikeError({
-        message: new Error('incorrect nonce for replacement transaction'),
-        reason: ErrorWrapper.reasons.bumpTxFailed,
-        hint: 'providedNonce',
-      })
-
-    // Choose a nonce that compensates for transctions which are currently
-    // in pending; for example, when we send transactions at low gas which
-    // will be stored by `geth` for execution at a later point in time.
-    //
-    // When we are not intentionally bumping a transaction, users are
-    // appending a new transaction to the chain - therefore we should
-    // be mindful of nonces belonging to us which are currently pending.
-    const resolvedNonce =
-      providedNonce ??
-      bumpNonce ??
-      (await asset.baseAsset.getNonce({ asset, fromAddress, walletAccount }))
 
-    const createTxParams = {
-      assetClientInterface,
+    let { txId, rawTx } = await signTx({
       asset,
+      unsignedTx,
       walletAccount,
-      toAddress: contractAddress || address,
-      amount,
-      nonce: resolvedNonce,
-      fromAddress,
-      customFee,
-      feeOpts,
-      txInput,
-      keepTxInput,
-      isSendAll,
-      createUnsignedTx,
-      feeData,
-      providedFeeAmount,
-    }
+    })
 
-    let { txId, rawTx, nonce, gasLimit, tipGasPrice, feeAmount } = await createTx(createTxParams)
+    const isPrivate = Boolean(legacyParams?.options?.isPrivate)
 
     if (isPrivate && typeof baseAsset.broadcastPrivateTx !== 'function')
       throw new Error(
@@ -250,7 +117,7 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           reason: ErrorWrapper.reasons.insufficientFunds,
           hint: 'broadcastTx',
         })
-      } else if (bumpTxId) {
+      } else if (unsignedTx.txMeta.bumpTxId) {
         throw new ErrorWrapper.EthLikeError({
           message: err.message,
           reason: ErrorWrapper.reasons.bumpTxFailed,
@@ -262,18 +129,23 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           reason: ErrorWrapper.reasons.broadcastTxFailed,
           hint: 'otherErr:broadcastTx',
         })
-      } else if (nonceTooLowErr && !isHardware) {
+      } else if (nonceTooLowErr && !unsignedTx.txMeta.isHardware) {
         console.info('trying to send again...') // inject logger factory from platform
         // let's try to fix the nonce issue
-        nonce = await resolveNonce({
+        const newNonce = await asset.baseAsset.getNonce({
           asset,
           fromAddress,
-          providedNonce,
-          txLog: baseAssetTxLog,
+          walletAccount,
           triedNonce: nonce,
           forceFromNode: true,
         })
-        ;({ txId, rawTx } = await createTx({ ...createTxParams, nonce }))
+
+        unsignedTx.txData.transactionBuffer = updateNonce(
+          unsignedTx.txData.transactionBuffer,
+          newNonce
+        )
+        nonce = newNonce
+        ;({ txId, rawTx } = await signTx({ asset, unsignedTx, walletAccount }))
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))
@@ -296,7 +168,18 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
       }
     }
 
-    const selfSend = fromAddress === address
+    const txData = eip1559Enabled
+      ? {
+          gasLimit,
+          replacedTxId,
+          nonce,
+          ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : Object.create(null)),
+        }
+      : {
+          gasLimit,
+          replacedTxId,
+          nonce,
+        }
 
     await assetClientInterface.updateTxLogAndNotify({
       assetName: asset.name,
@@ -310,21 +193,12 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           feeAmount,
           feeCoinName: asset.feeAsset.name,
           selfSend,
-          to: address,
+          to,
           currencies: {
             [assetName]: asset.currency,
             [asset.feeAsset.name]: asset.feeAsset.currency,
           },
-          data: eip1559Enabled
-            ? {
-                gasLimit,
-                replacedTxId: bumpTxId,
-                nonce,
-                ...(tipGasPrice
-                  ? { tipGasPrice: tipGasPrice.toBaseString() }
-                  : Object.create(null)),
-              }
-            : { gasLimit, replacedTxId: bumpTxId, nonce },
+          data: txData,
         },
       ],
     })
@@ -342,20 +216,13 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
             feeAmount,
             feeCoinName: baseAsset.name,
             selfSend,
-            to: address,
+            to,
             token: asset.name,
             currencies: {
               [baseAsset.name]: baseAsset.currency,
               [asset.feeAsset.name]: asset.feeAsset.currency,
             },
-            data: eip1559Enabled
-              ? {
-                  gasLimit,
-                  replacedTxId: bumpTxId,
-                  nonce,
-                  ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : {}),
-                }
-              : { gasLimit, replacedTxId: bumpTxId, nonce },
+            data: txData,
           },
         ],
       })
@@ -365,146 +232,4 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
   }
 }
 
-const createTx = async ({
-  assetClientInterface,
-  asset,
-  walletAccount,
-  toAddress,
-  amount,
-  nonce,
-  txInput,
-  keepTxInput = false,
-  customFee,
-  isSendAll,
-  fromAddress,
-  feeOpts,
-  createUnsignedTx,
-  feeData,
-  providedFeeAmount,
-}) => {
-  assert(
-    nonce !== undefined && typeof nonce === 'number',
-    'Nonce must be provided when creating a tx'
-  )
-  const isToken = isEthereumLikeToken(asset)
-
-  if (txInput && isToken && !keepTxInput)
-    throw new Error(`Additional data for Ethereum Token (${asset.name}) is not allowed`)
-
-  txInput =
-    isToken && !keepTxInput
-      ? asset.contract.transfer.build(toAddress.toLowerCase(), amount.toBaseString())
-      : txInput
-
-  let { gasLimit, gasPrice, tipGasPrice, eip1559Enabled } = await getFeeInfo({
-    assetClientInterface,
-    asset,
-    fromAddress,
-    toAddress,
-    amount,
-    txInput,
-    feeOpts,
-    feeData,
-    customFee,
-  })
-
-  const isContractToAddress = await isContractAddressCached({ asset, address: toAddress })
-
-  // 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.
-  if (eip1559Enabled && isSendAllBaseAsset) {
-    // force consuming all gas
-    tipGasPrice = gasPrice
-  }
-
-  // HACK: If we are handling a send all transaction, we must ensure
-  //       the send all invariant is maintained before producing the
-  //       final transaction.
-  const maybeOverrideSendAllAmount =
-    isSendAllBaseAsset &&
-    (await HACK_maybeRefineSendAllAmount({
-      amount,
-      asset,
-      assetClientInterface,
-      walletAccount,
-      gasLimit,
-      gasPrice,
-    }))
-
-  if (maybeOverrideSendAllAmount) {
-    console.log(
-      `Attempted to execute a sendAll transaction with an amount of ${amount.toDefaultString({ unit: true })}, but this would fail to maintain the no dust invariant! Overriding with ${maybeOverrideSendAllAmount.toDefaultString({ unit: true })}.`
-    )
-    amount = maybeOverrideSendAllAmount
-  }
-
-  const unsignedTx = await createUnsignedTx({
-    asset,
-    walletAccount,
-    address: toAddress,
-    amount,
-    nonce,
-    txInput,
-    gasLimit,
-    gasPrice,
-    tipGasPrice,
-    fromAddress,
-    eip1559Enabled,
-  })
-
-  // TODO: move into createUnsignedTx()
-  if (keepTxInput && !isToken) {
-    unsignedTx.txData.to = toAddress
-  }
-
-  unsignedTx.txMeta.eip1559Enabled = eip1559Enabled
-
-  const resolveFee = async () => {
-    if (providedFeeAmount) {
-      return providedFeeAmount
-    }
-
-    const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-      ? await asset.baseAsset.estimateL1DataFee({
-          unsignedTx,
-        })
-      : undefined
-
-    const l1DataFee = optimismL1DataFee
-      ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-      : asset.baseAsset.currency.ZERO
-    return gasPrice.mul(gasLimit).add(l1DataFee)
-  }
-
-  const { txId, rawTx } = await assetClientInterface.signTransaction({
-    assetName: asset.baseAsset.name,
-    unsignedTx,
-    walletAccount,
-  })
-
-  return {
-    txId: normalizeTxId(txId),
-    rawTx,
-    nonce,
-    gasLimit,
-    gasPrice,
-    tipGasPrice,
-    feeAmount: await resolveFee(),
-  }
-}
-
 export default txSendFactory

package/src/tx-send/get-fee-info.js

@@ -1,58 +0,0 @@
-import { ensureSaneEip1559GasPriceForTipGasPrice } from '../fee-utils.js'
-import { fetchGasLimit } from '../gas-estimation.js'
-import { getFeeFactoryGasPrices } from '../get-fee.js'
-
-const getFeeInfo = async function getFeeInfo({
-  assetClientInterface,
-  asset,
-  fromAddress,
-  toAddress,
-  amount,
-  txInput,
-  feeOpts = {},
-  feeData,
-  customFee,
-}) {
-  // HACK: Previously, calls `getFeeInfo` were not provided a reference
-  //       to `feeData`. For backwards compatibility, we'll revert to
-  //       legacy behaviour.
-  // NOTE: This shouldn't actually be used outside of the `assets` repo;
-  //       this is done just for safety.
-  if (!feeData) {
-    console.warn('`getFeeInfo` was not explicitly passed a `feeData` object.')
-    const { name: assetName } = asset
-    feeData = await assetClientInterface.getFeeData({ assetName })
-  }
-
-  const {
-    gasPrice: gasPrice_,
-    feeData: { tipGasPrice: tipGasPrice_, eip1559Enabled },
-  } = getFeeFactoryGasPrices({ customFee, feeData })
-
-  const tipGasPrice = feeOpts.tipGasPrice || tipGasPrice_
-
-  const maybeGasPrice = feeOpts.gasPrice || gasPrice_
-
-  // HACK: If we've received an invalid combination of `tipGasPrice`
-  //       (maxPriorityFeePerGas) and `gasPrice` (maxFeePerGas), then
-  //       we must normalize these before returning.
-  const gasPrice = eip1559Enabled
-    ? ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice: maybeGasPrice, tipGasPrice })
-    : maybeGasPrice
-
-  const gasLimit =
-    feeOpts.gasLimit ||
-    (await fetchGasLimit({
-      asset,
-      fromAddress,
-      toAddress,
-      amount,
-      txInput,
-      feeData,
-      throwOnError: false,
-    }))
-
-  return { gasPrice, gasLimit, tipGasPrice, eip1559Enabled }
-}
-
-export default getFeeInfo