@exodus/ethereum-api 8.41.0-alpha.0 → 8.42.0

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.42.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.41.0...@exodus/ethereum-api@8.42.0) (2025-07-10)
+
+
+### Features
+
+
+* feat: rig `getNonce` to evm asset api (#6047)
+
+
+
 ## [8.41.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.40.1...@exodus/ethereum-api@8.41.0) (2025-07-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.41.0-alpha.0",
+  "version": "8.42.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -49,7 +49,7 @@
     "ws": "^6.1.0"
   },
   "devDependencies": {
-    "@exodus/assets-testing": "workspace:^",
+    "@exodus/assets-testing": "^1.0.0",
     "@exodus/bsc-meta": "^2.1.2",
     "@exodus/ethereumarbone-meta": "^2.0.3",
     "@exodus/fantommainnet-meta": "^2.0.2",
@@ -62,5 +62,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
-  }
+  },
+  "gitHead": "6bd56e57bee720ffef602f57421eae67e42e190c"
 }

package/src/allowance/index.js

@@ -1,3 +1,6 @@
+import { isNumberUnit } from '@exodus/currency'
+import assert from 'minimalistic-assert'
+
 import { getServer } from '../exodus-eth-server/index.js'
 import { fetchGasLimit } from '../gas-estimation.js'
 import { ALLOWANCE_TX_TIMEOUT, APPROVAL_GAS_LIMIT, ZERO_ALLOWANCE_ASSETS } from './constants.js'
@@ -27,6 +30,52 @@ export async function isSpendingApprovalRequired({
   return tokenAmount.gt(allowance)
 }
 
+export const buildApproveTx = async ({
+  spenderAddress,
+  asset,
+  feeData,
+  fromAddress,
+  approveAmount = asset.currency.ZERO,
+  gasLimit,
+  txInput,
+}) => {
+  assert(asset, 'expected asset')
+  assert(feeData, 'expected feeData')
+  assert(isNumberUnit(approveAmount), 'expected approveAmount')
+  assert(typeof spenderAddress === 'string', 'expected spenderAddress')
+
+  const baseAsset = asset.baseAsset
+  const toAddress = asset.contract.address
+
+  if (!txInput) txInput = asset.contract.approve.build(spenderAddress, approveAmount.toBaseString())
+
+  if (!gasLimit)
+    gasLimit = await fetchGasLimit({
+      asset: baseAsset,
+      amount: baseAsset.currency.ZERO,
+      toAddress,
+      txInput,
+      feeData,
+      isContract: true,
+      fromAddress,
+    })
+
+  return {
+    asset: baseAsset.name,
+    receiver: {
+      address: toAddress,
+      amount: baseAsset.currency.ZERO,
+    },
+    txInput,
+    gasPrice: feeData.gasPrice,
+    tipGasPrice: feeData.tipGasPrice,
+    gasLimit,
+    silent: true,
+    fromAddress,
+  }
+}
+
+// @deprecated use buildApproveTx instead
 export const createApprove =
   ({ sendTx }) =>
   async ({
@@ -36,43 +85,23 @@ export const createApprove =
     fromAddress,
     approveAmount,
     gasLimit,
-    txInput: preTxInput,
-    ...rest
+    txInput,
+    ...extras
   }) => {
-    const baseAsset = asset.baseAsset
-    const txInput =
-      preTxInput ?? asset.contract.approve.build(spenderAddress, approveAmount.toBaseString())
-
-    const toAddress = asset.contract.address
-    const gasLimitOptions = {
-      asset: baseAsset,
-      amount: baseAsset.currency.ZERO,
-      toAddress,
-      txInput,
+    const approveTx = await buildApproveTx({
+      spenderAddress,
+      asset,
       feeData,
-      isContract: true,
       fromAddress,
-    }
-
-    gasLimit = gasLimit || (await fetchGasLimit(gasLimitOptions))
-
-    const txData = await sendTx({
-      asset: baseAsset.name,
-      receiver: {
-        address: toAddress,
-        amount: baseAsset.currency.ZERO,
-      },
-      txInput,
-      gasPrice: feeData.gasPrice,
+      approveAmount,
       gasLimit,
-      silent: true,
-      fromAddress,
-      ...rest,
+      txInput,
     })
 
-    if (!txData || !txData.txId) {
+    const txData = await sendTx({ ...extras, ...approveTx })
+
+    if (!txData || !txData.txId)
       throw new Error(`Failed to approve ${asset.displayTicker} - ${spenderAddress}`)
-    }
 
     return txData
   }

package/src/create-asset-utils.js

@@ -6,6 +6,7 @@ import { createEthereumHooks } from './hooks/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
+import { resolveNonce } from './tx-send/nonce-utils.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -151,3 +152,33 @@ export const createHistoryMonitorFactory = ({
     return monitor
   }
 }
+
+export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNonce }) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(typeof useAbsoluteBalanceAndNonce === 'boolean', 'expected useAbsoluteBalanceAndNonce')
+
+  const getNonce = async ({ asset, fromAddress, walletAccount }) => {
+    assert(asset, 'expected asset')
+    assert(typeof fromAddress === 'string', 'expected fromAddress')
+    assert(walletAccount, 'expected walletAccount')
+
+    const txLog = await assetClientInterface.getTxLog({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+
+    return resolveNonce({
+      asset,
+      fromAddress,
+      txLog,
+      // 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
+      // of which transactions are currently in pending.
+      tag: 'pending',
+      useAbsoluteNonce: useAbsoluteBalanceAndNonce,
+    })
+  }
+
+  return { getNonce }
+}

package/src/create-asset.js

@@ -24,6 +24,7 @@ import { addressHasHistoryFactory } from './address-has-history.js'
 import {
   createHistoryMonitorFactory,
   createTransactionPrivacyFactory,
+  getNonceFactory,
   resolveMonitorSettings,
 } from './create-asset-utils.js'
 import { createTokenFactory } from './create-token-factory.js'
@@ -37,7 +38,6 @@ 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'
 
@@ -222,15 +222,10 @@ export const createAssetFactory = ({
 
     const createUnsignedTx = createUnsignedTxFactory({ chainId })
 
-    const createTx = createTxFactory({
-      chainId,
-      assetClientInterface,
-      useAbsoluteNonce: useAbsoluteBalanceAndNonce,
-    })
-
     const sendTx = txSendFactory({
       assetClientInterface,
-      createTx,
+      createUnsignedTx,
+      useAbsoluteBalanceAndNonce,
     })
 
     const estimateL1DataFee = l1GasOracleAddress
@@ -243,6 +238,8 @@ export const createAssetFactory = ({
       ? getL1GetFeeFactory({ asset, originalGetFee })
       : originalGetFee
 
+    const { getNonce } = getNonceFactory({ assetClientInterface, useAbsoluteBalanceAndNonce })
+
     const api = {
       addressHasHistory,
       broadcastTx: (...args) => server.sendRawTransaction(...args),
@@ -250,7 +247,6 @@ export const createAssetFactory = ({
       createFeeMonitor,
       createHistoryMonitor,
       createToken,
-      createTx,
       createUnsignedTx,
       customFees: createCustomFeesApi({ baseAsset: asset }),
       defaultAddressPath,
@@ -260,7 +256,7 @@ export const createAssetFactory = ({
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
       getConfirmationsNumber: () => confirmationsNumber,
       getDefaultAddressPath: () => defaultAddressPath,
-      getFeeAsync: getFeeAsyncFactory({ assetClientInterface, gasLimit, createTx }),
+      getFeeAsync: getFeeAsyncFactory({ assetClientInterface, gasLimit, createUnsignedTx }),
       getFee,
       getFeeData: () => feeData,
       getKeyIdentifier: createGetKeyIdentifier({
@@ -300,6 +296,7 @@ export const createAssetFactory = ({
       broadcastPrivateBundle,
       broadcastPrivateTx,
       forceGasLimitEstimation,
+      getNonce,
       privacyServer,
       server,
       ...(erc20FuelBuffer && { erc20FuelBuffer }),

package/src/gas-estimation.js

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

package/src/get-fee-async.js

@@ -1,21 +1,89 @@
 import assert from 'minimalistic-assert'
 
-import { getExtraFeeData } from './get-fee.js'
+import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
+import { getFeeFactory } from './get-fee.js'
+import { getNftArguments } from './nft-utils.js'
 
-const getFeeAsyncFactory = ({ assetClientInterface, createTx }) => {
+const getFeeAsyncFactory = ({
+  assetClientInterface,
+  gasLimit: defaultGasLimit,
+  createUnsignedTx,
+}) => {
   assert(assetClientInterface, 'assetClientInterface is required')
-  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 })
+  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
+
     return {
-      fee,
-      extraFeeData,
-      unsignedTx,
+      fee: fee.add(l1DataFee),
+      // TODO: Should this be `l1DataFee`?
+      optimismL1DataFee,
+      gasLimit,
+      gasPrice,
+      ...rest,
     }
   }
 }

package/src/get-fee.js

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

package/src/index.js

@@ -61,6 +61,7 @@ export {
   isZeroAllowanceAsset,
   getSpendingAllowance,
   isSpendingApprovalRequired,
+  buildApproveTx,
   createApprove,
   createApproveSpendingTokens,
   APPROVAL_GAS_LIMIT,
@@ -81,7 +82,9 @@ export {
 
 export { reasons as errorReasons, withErrorReason, EthLikeError } from './error-wrapper.js'
 
-export { txSendFactory } from './tx-send/index.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 { createAssetFactory } from './create-asset.js'
 

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

@@ -0,0 +1,58 @@
+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

package/src/tx-send/index.js

@@ -1 +1,2 @@
 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,