@exodus/ethereum-api 8.36.0 → 8.38.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.38.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.37.0...@exodus/ethereum-api@8.38.0) (2025-06-17)
+
+
+### Features
+
+
+* feat: clarity basemainnet (#5876)
+
+* feat: enable evm transaction privacy (#5869)
+
+* feat: remove eth sepolia and goerli (#5885)
+
+
+
+## [8.37.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.36.0...@exodus/ethereum-api@8.37.0) (2025-06-12)
+
+
+### Features
+
+
+* feat: remote config feeData.gasLimits (#5830)
+
+
+
 ## [8.36.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.35.1...@exodus/ethereum-api@8.36.0) (2025-06-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.36.0",
+  "version": "8.38.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",
@@ -52,8 +52,6 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/bsc-meta": "^2.1.2",
     "@exodus/ethereumarbone-meta": "^2.0.3",
-    "@exodus/ethereumgoerli-meta": "^2.0.1",
-    "@exodus/ethereumsepolia-meta": "^2.0.1",
     "@exodus/fantommainnet-meta": "^2.0.2",
     "@exodus/rootstock-meta": "^2.0.3"
   },
@@ -64,5 +62,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "2172464a34a03cb2c2401f80db89d4609cb0528f"
+  "gitHead": "7150173679bc6f43d40c151728ae5f910bc52d88"
 }

package/src/create-asset-utils.js

@@ -0,0 +1,76 @@
+import assert from 'minimalistic-assert'
+
+import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
+
+// Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
+// to use for a given config.
+export const resolveMonitorSettings = (
+  {
+    asset,
+    configWithOverrides,
+    defaultMonitorInterval,
+    defaultMonitorType,
+    defaultServerUrl,
+  } = Object.create(null)
+) => {
+  assert(asset, 'expected asset')
+  assert(
+    ValidMonitorTypes.includes(defaultMonitorType),
+    `defaultMonitorType ${defaultMonitorType} for ${asset.name} is invalid.`
+  )
+  assert(defaultServerUrl, `expected default serverUrl for ${asset.name}`)
+
+  const overrideMonitorType = configWithOverrides?.monitorType
+  const overrideServerUrl = configWithOverrides?.serverUrl
+  const overrideMonitorInterval = configWithOverrides?.monitorInterval
+
+  const defaultResolution = {
+    // NOTE: Regardless of the `monitorType`, the `monitorInterval`
+    //       will be respected.
+    monitorInterval: overrideMonitorInterval ?? defaultMonitorInterval,
+    monitorType: defaultMonitorType,
+    serverUrl: defaultServerUrl,
+  }
+
+  if (!overrideMonitorType && overrideServerUrl) {
+    console.warn(
+      `Received an \`overrideServerUrl\`, but not the \`monitorType\` for ${asset.name}. Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`
+    )
+    return defaultResolution
+  }
+
+  // If we don't attempt to override the `monitorType`, we resort
+  // to the default configuration.
+  if (!overrideMonitorType) return defaultResolution
+
+  if (!ValidMonitorTypes.includes(overrideMonitorType)) {
+    console.warn(
+      `"${overrideMonitorType}" is not a valid \`MonitorType\`. Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`
+    )
+    return defaultResolution
+  }
+
+  // Permit the `monitorType` and `serverUrl` to be overrided.
+  return { ...defaultResolution, monitorType: overrideMonitorType, serverUrl: overrideServerUrl }
+}
+
+export const createBroadcastTxFactory = ({ assetName, server, privacyRpcUrl }) => {
+  assert(server, 'expected server')
+
+  const defaultResult = {
+    broadcastTx: (...args) => server.sendRawTransaction(...args),
+  }
+
+  if (!privacyRpcUrl) return defaultResult
+
+  const privacyServer = createEvmServer({
+    assetName,
+    serverUrl: privacyRpcUrl,
+    monitorType: 'no-history',
+  })
+
+  return {
+    ...defaultResult,
+    broadcastPrivateTx: (...args) => privacyServer.sendRawTransaction(...args),
+  }
+}

package/src/create-asset.js

@@ -22,9 +22,10 @@ import assert from 'minimalistic-assert'
 import ms from 'ms'
 
 import { addressHasHistoryFactory } from './address-has-history.js'
+import { createBroadcastTxFactory, resolveMonitorSettings } from './create-asset-utils.js'
 import { createTokenFactory } from './create-token-factory.js'
 import { createCustomFeesApi } from './custom-fees.js'
-import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
+import { createEvmServer } from './exodus-eth-server/index.js'
 import { createFeeData } from './fee-data-factory.js'
 import { createGetBalanceForAddress } from './get-balance-for-address.js'
 import { getBalancesFactory } from './get-balances.js'
@@ -57,10 +58,10 @@ export const createAssetFactory = ({
   isMaxFeeAsset = false,
   isTestnet = false,
   l1GasOracleAddress, // l1 extra fee for base and optostakingConfiguration = {},
-  monitorInterval,
-  monitorType = 'magnifier',
+  monitorInterval: defaultMonitorInterval,
+  monitorType: defaultMonitorType = 'magnifier',
   nfts: defaultNfts = false,
-  serverUrl,
+  serverUrl: defaultServerUrl,
   stakingConfiguration = {},
   useEip1191ChainIdChecksum = false,
   forceGasLimitEstimation = false,
@@ -69,7 +70,7 @@ export const createAssetFactory = ({
 }) => {
   assert(assetsList, 'assetsList is required')
   assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
-  assert(serverUrl, 'serverUrl is required')
+  assert(defaultServerUrl, 'serverUrl is required')
   assert(confirmationsNumber, 'confirmationsNumber is required')
 
   const base = assetsList.find((asset) => asset.name === asset.baseAssetName)
@@ -98,41 +99,32 @@ export const createAssetFactory = ({
   ) => {
     const assets = connectAssetsList(assetsList)
 
+    const configWithOverrides = { ...defaultConfig, ...config }
+
     const {
       allowMetaMaskCompat,
       supportsStaking,
       nfts,
       customTokens,
       supportsCustomFees,
-      monitorType: overrideMonitorType,
-      serverUrl: overrideServerUrl,
-      monitorInterval: overrideMonitorInterval,
       useAbsoluteBalanceAndNonce: overrideUseAbsoluteBalanceAndNonce,
-    } = {
-      ...defaultConfig,
-      ...config,
-    }
+      privacyRpcUrl,
+    } = configWithOverrides
 
     const asset = assets[base.name]
 
-    if (overrideMonitorType) {
-      if (!ValidMonitorTypes.includes(overrideMonitorType) || !overrideServerUrl) {
-        console.warn('Invalid config for overrideMonitorType or overrideServerUrl', {
-          monitorType: overrideMonitorType,
-          serverUrl: overrideServerUrl,
-        })
-      } else {
-        monitorType = overrideMonitorType
-        serverUrl = overrideServerUrl
-        monitorInterval = overrideMonitorInterval || monitorInterval
-      }
-    }
+    const { monitorType, serverUrl, monitorInterval } = resolveMonitorSettings({
+      asset,
+      configWithOverrides,
+      defaultMonitorInterval,
+      defaultMonitorType,
+      defaultServerUrl,
+    })
 
     if (overrideUseAbsoluteBalanceAndNonce !== undefined) {
       useAbsoluteBalanceAndNonce = overrideUseAbsoluteBalanceAndNonce
     }
 
-    monitorType = overrideMonitorType || monitorType
     const server = createEvmServer({ assetName: asset.name, serverUrl, monitorType })
 
     const gasLimit = 21e3 // 21 KGas, enough only for sending ether to normal address
@@ -274,10 +266,15 @@ export const createAssetFactory = ({
       ? getL1GetFeeFactory({ asset, originalGetFee })
       : originalGetFee
 
+    const { broadcastTx, broadcastPrivateTx } = createBroadcastTxFactory({
+      assetName: asset.name,
+      server,
+      privacyRpcUrl,
+    })
+
     const api = {
-      getActivityTxs,
       addressHasHistory,
-      broadcastTx: (...args) => server.sendRawTransaction(...args),
+      broadcastTx,
       createAccountState: () => accountStateClass,
       createFeeMonitor,
       createHistoryMonitor,
@@ -286,6 +283,7 @@ export const createAssetFactory = ({
       customFees: createCustomFeesApi({ baseAsset: asset }),
       defaultAddressPath,
       features,
+      getActivityTxs,
       getBalances,
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
       getConfirmationsNumber: () => confirmationsNumber,
@@ -327,6 +325,7 @@ export const createAssetFactory = ({
       chainId,
       monitorType,
       estimateL1DataFee,
+      broadcastPrivateTx,
       forceGasLimitEstimation,
       server,
       ...(erc20FuelBuffer && { erc20FuelBuffer }),

package/src/exodus-eth-server/clarity-v2.js

@@ -2,6 +2,33 @@ import { retry } from '@exodus/simple-retry'
 
 import ClarityServer from './clarity.js'
 
+export const encodeCursor = (blockNumberBigInt, isLegacy = false) => {
+  if (typeof blockNumberBigInt !== 'bigint') throw new Error('expected bigint')
+
+  if (isLegacy) {
+    const cursor = Buffer.alloc(26)
+    cursor.writeBigInt64LE(blockNumberBigInt, 10)
+    return cursor
+  }
+
+  const cursor = Buffer.alloc(8)
+  cursor.writeBigUInt64LE(blockNumberBigInt, 0)
+  return cursor
+}
+
+export const decodeCursor = (cursor) => {
+  if (Buffer.isBuffer(cursor)) {
+    // New format: buffer containing only the block number
+    if (cursor.length === 8) return { blockNumber: cursor.readBigUInt64LE(0) }
+
+    // Old format: buffer with length 26
+    if (cursor.length === 26) return { blockNumber: cursor.readBigInt64LE(10) }
+  }
+
+  // Doesn't match any known format, return default
+  return { blockNumber: BigInt(0) }
+}
+
 const getTextFromResponse = async (response) => {
   try {
     const responseBody = await response.text()
@@ -44,18 +71,25 @@ export default class ClarityServerV2 extends ClarityServer {
     this.updateBaseApiPath()
   }
 
+  getTransactionsAtBlockNumber = async ({ address, blockNumber, withInput = true }) => {
+    const url = new URL(`${this.baseApiPath}/addresses/${encodeURIComponent(address)}/transactions`)
+    url.searchParams.set('cursor', blockNumber)
+    url.searchParams.set('withInput', Boolean(withInput).toString())
+    return fetchJsonRetry(url)
+  }
+
   async getAllTransactions({ address, cursor }) {
-    let { blockNumber } = this.#decodeCursor(cursor)
+    let { blockNumber } = decodeCursor(cursor)
     blockNumber = blockNumber.toString()
 
     let transactions = []
 
     while (true) {
-      const url = new URL(`${this.baseApiPath}/addresses/${address}/transactions`)
-      url.searchParams.set('cursor', blockNumber)
-      url.searchParams.set('withInput', 'true')
-
-      const { transactions: txs, cursor: nextBlockNumber } = await fetchJsonRetry(url)
+      const { transactions: txs, cursor: nextBlockNumber } =
+        await this.getTransactionsAtBlockNumber({
+          address,
+          blockNumber,
+        })
 
       if (txs.length === 0) {
         // fetch until no more new transactions
@@ -91,19 +125,6 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
-  #decodeCursor(cursor) {
-    if (Buffer.isBuffer(cursor)) {
-      // New format: buffer containing only the block number
-      if (cursor.length === 8) return { blockNumber: cursor.readBigUInt64LE(0) }
-
-      // Old format: buffer with length 26
-      if (cursor.length === 26) return { blockNumber: cursor.readBigInt64LE(10) }
-    }
-
-    // Doesn't match any known format, return default
-    return { blockNumber: BigInt(0) }
-  }
-
   async sendHttpRequest({ path, method, body }) {
     const url = new URL(`${this.baseApiPath}${path}`)
     const fetchOptions = {

package/src/gas-estimation.js

@@ -1,28 +1,50 @@
 import { currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
 import { bufferToHex, toBuffer } from '@exodus/ethereumjs/util'
 
-import { estimateGas, isContractAddressCached } from './eth-like-util.js'
+import { estimateGas, isContractAddressCached, isForwarderContractCached } from './eth-like-util.js'
 
-export const EXTRA_PERCENTAGE = 29
+export const DEFAULT_GAS_LIMIT_MULTIPLIER = 1.29
 
 // 16 gas per non-zero byte (4 gas per zero byte) of "transaction input data"
 const GAS_PER_NON_ZERO_BYTE = 16
 
 export const DEFAULT_CONTRACT_GAS_LIMIT = 1e6
 
+// 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 = ({ estimatedGasLimit, extraPercentage = EXTRA_PERCENTAGE }) =>
-  Number((BigInt(estimatedGasLimit) * BigInt(100 + extraPercentage)) / BigInt(100))
-
-const hardcodedGasLimits = new Map([
-  ['amp', 151_000],
-  ['tetherusd', 70_000],
-  ['usdcoin', 70_000],
-  ['snx', 220_000],
-  ['geminidollar', 75_000],
-  ['aave', 250_000],
-])
+export const scaleGasLimitEstimate = ({
+  estimatedGasLimit,
+  gasLimitMultiplier = DEFAULT_GAS_LIMIT_MULTIPLIER,
+}) => {
+  const gasLimit = parseInt(estimatedGasLimit)
+  if (!Number.isInteger(gasLimit)) {
+    throw new TypeError('Invalid scaleGasLimitEstimate ' + estimatedGasLimit)
+  }
+
+  const multiplier = parseFloat(gasLimitMultiplier)
+  if (Number.isNaN(multiplier)) {
+    throw new TypeError('Invalid gasLimitMultiplier ' + gasLimitMultiplier)
+  }
+
+  return Math.floor(gasLimit * multiplier)
+}
 
 // Starting with geth v1.9.14, if gasPrice is set for eth_estimateGas call, the call allowance will
 // be calculated with account's balance divided by gasPrice. If user's balance is too low,
@@ -34,14 +56,8 @@ export async function estimateGasLimit(
   toAddress,
   amount,
   data,
-  gasPrice = '0x',
-  extraPercentage
+  gasPrice = '0x'
 ) {
-  // move this to remote config
-  if (hardcodedGasLimits.has(asset.name)) {
-    return hardcodedGasLimits.get(asset.name)
-  }
-
   const opts = {
     from: fromAddress,
     to: toAddress,
@@ -51,62 +67,98 @@ export async function estimateGasLimit(
   }
 
   const estimatedGas = await estimateGas({ asset, ...opts })
+  return Number(BigInt(estimatedGas))
+}
 
-  return scaleGasLimitEstimate({
-    estimatedGasLimit: BigInt(estimatedGas),
-    extraPercentage,
-  })
+export async function resolveGasLimitMultiplier({ asset, feeData, toAddress, fromAddress }) {
+  const gasLimitMultiplierWhenUnknownAddress =
+    feeData?.gasLimits?.[asset.name]?.gasLimitMultiplierWhenUnknownAddress
+
+  if (gasLimitMultiplierWhenUnknownAddress && (!fromAddress || !toAddress)) {
+    return gasLimitMultiplierWhenUnknownAddress
+  }
+
+  const gasLimitMultiplier = feeData?.gasLimits?.[asset.name]?.gasLimitMultiplier
+
+  if (gasLimitMultiplier) {
+    return gasLimitMultiplier
+  }
+
+  if (asset.baseAsset.estimateL1DataFee) {
+    return 2
+  }
+
+  const isToken = asset.name !== asset.baseAsset.name
+
+  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
+  const hasForwarderContract =
+    !isToken && toAddress ? await isForwarderContractCached({ asset, address: toAddress }) : false
+
+  if (hasForwarderContract) {
+    return 1
+  }
+
+  return DEFAULT_GAS_LIMIT_MULTIPLIER
 }
 
 export function resolveDefaultTxInput({ asset, toAddress, amount }) {
   return isEthereumLikeToken(asset)
-    ? bufferToHex(asset.contract.transfer.build(toAddress.toLowerCase(), amount.toBaseString()))
+    ? bufferToHex(asset.contract.transfer.build(toAddress.toLowerCase(), amount?.toBaseString()))
     : '0x'
 }
 
 export async function fetchGasLimit({
   asset,
-  fromAddress,
-  toAddress,
+  feeData,
+  fromAddress: providedFromAddress,
+  toAddress: providedToAddress,
   txInput: providedTxInput,
-  amount,
+  amount: providedAmount,
   bip70,
   throwOnError = true,
-  extraPercentage,
 }) {
   if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice)
     return asset.name === 'ethereum' ? 65_000 : 130_000 // from on chain stats https://dune.xyz/queries/189123
 
-  if (!amount) amount = asset.currency.ZERO
+  const fixedGasLimit = feeData?.gasLimits?.[asset.name]?.fixedGasLimit
+  if (fixedGasLimit) {
+    return fixedGasLimit
+  }
 
+  const amount = providedAmount ?? asset.currency.ZERO
+  const fromAddress = providedFromAddress ?? ARBITRARY_ADDRESS
+  const toAddress = providedToAddress ?? ARBITRARY_ADDRESS
   const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
 
   const defaultGasLimit = () => asset.gasLimit + GAS_PER_NON_ZERO_BYTE * toBuffer(txInput).length
 
   const isContract = await isContractAddressCached({ asset, address: toAddress })
 
-  if (isEthereumLikeToken(asset)) {
-    amount = asset.baseAsset.currency.ZERO
-    toAddress = asset.contract.address
-  } else if (!isContract && !asset.forceGasLimitEstimation) {
+  const isToken = isEthereumLikeToken(asset)
+  if (!isToken && !isContract && !asset.forceGasLimitEstimation) {
     return defaultGasLimit()
   }
 
-  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
-  // Since geth v1.9.14 estimateGas will throw if user does not have enough ETH.
-  // If gasPrice is set to zero, estimateGas will make the expected estimation.
-  const gasPrice = bufferToHex(currency2buffer(asset.baseAsset.currency.ZERO))
+  const gasLimitMultiplier = await resolveGasLimitMultiplier({
+    asset,
+    feeData,
+    fromAddress: providedFromAddress,
+    toAddress: providedToAddress,
+  })
+
+  const txToAddress = isToken ? asset.contract.address : toAddress
+  const txAmount = isToken ? asset.baseAsset.currency.ZERO : amount
 
   try {
-    return await estimateGasLimit(
+    const estimatedGasLimit = await estimateGasLimit(
       asset,
       fromAddress,
-      toAddress,
-      amount,
-      txInput,
-      gasPrice,
-      extraPercentage
+      txToAddress,
+      txAmount,
+      txInput
     )
+
+    return scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
   } catch (err) {
     if (throwOnError) throw err
 

package/src/get-balances.js

@@ -18,7 +18,9 @@ export const getAbsoluteBalance = ({ asset, txLog }) => {
   let balance = asset.currency.ZERO
   let hasAbsoluteBalance = false
 
-  for (const tx of txLog.reverse()) {
+  const reversedTxLog = txLog.reverse()
+
+  for (const tx of reversedTxLog) {
     if (tx.data.balanceChange) {
       hasAbsoluteBalance = true
       balance = balance.add(asset.currency.baseUnit(tx.data.balanceChange.to))

package/src/get-fee-async.js

@@ -1,53 +1,9 @@
 import assert from 'minimalistic-assert'
 
-import { isForwarderContractCached } from './eth-like-util.js'
-import { EXTRA_PERCENTAGE, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
+import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
 import { getFeeFactory } from './get-fee.js'
 import { getNftArguments } from './nft-utils.js'
 
-const UNKNOWN_ADDRESS_EXTRA_PERCENTAGE = {
-  usdt_bsc_ddedf0f8: 80,
-}
-
-export async function resolveExtraPercentage({ asset, fromAddress, toAddress }) {
-  if (asset.baseAsset.estimateL1DataFee) {
-    return 100
-  }
-
-  const isToken = asset.name !== asset.baseAsset.name
-
-  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
-  const hasForwarderContract =
-    !isToken && toAddress ? await isForwarderContractCached({ asset, address: toAddress }) : false
-
-  if (hasForwarderContract) {
-    return 0
-  }
-
-  if (!fromAddress || !toAddress) {
-    return UNKNOWN_ADDRESS_EXTRA_PERCENTAGE[asset.name] ?? EXTRA_PERCENTAGE
-  }
-
-  return EXTRA_PERCENTAGE
-}
-
-// 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.
-const ARBITRARY_ADDRESS = '0xfffFfFfFfFfFFFFFfeFfFFFffFffFFFFfFFFFFFF'.toLowerCase()
-
 const getFeeAsyncFactory = ({
   assetClientInterface,
   gasLimit: defaultGasLimit,
@@ -59,42 +15,35 @@ const getFeeAsyncFactory = ({
   return async ({
     nft,
     asset,
+    // provided are values from the UI or other services, they could be undefined
     fromAddress: providedFromAddress,
     toAddress: providedToAddress,
-    amount,
+    amount: providedAmount,
+    txInput: providedTxInput,
+    gasLimit: providedGasLimit,
     bip70,
-    txInput: txInputPram,
-    isExchange,
     customFee,
-    gasLimit: providedGasLimit,
     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 })
       }
 
-      if (!amount) amount = asset.currency.ZERO
-      const txInput = txInputPram || resolveDefaultTxInput({ asset, toAddress, amount })
+      const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
       if (providedGasLimit) return { gasLimit: providedGasLimit, txInput }
 
-      const extraPercentage = await resolveExtraPercentage({
+      const gasLimit = await fetchGasLimit({
         asset,
         fromAddress: providedFromAddress,
         toAddress: providedToAddress,
-      })
-
-      const gasLimit = await fetchGasLimit({
-        asset,
-        fromAddress,
-        toAddress,
         txInput,
         amount,
         bip70,
-        extraPercentage,
+        feeData,
       })
       return { gasLimit, txInput }
     }
@@ -105,7 +54,6 @@ const getFeeAsyncFactory = ({
       asset,
       feeData,
       gasLimit,
-      isExchange,
       amount,
       customFee,
     })

package/src/get-fee.js

@@ -41,7 +41,7 @@ export const getFeeFactoryGasPrices = ({ customFee, feeData }) => {
 
 export const getFeeFactory =
   ({ gasLimit: defaultGasLimit }) =>
-  ({ asset, feeData, customFee, gasLimit: providedGasLimit, isExchange, amount }) => {
+  ({ asset, feeData, customFee, gasLimit: providedGasLimit, amount }) => {
     const {
       feeData: { tipGasPrice, eip1559Enabled },
       gasPrice,

package/src/index.js

@@ -21,8 +21,8 @@ export {
 } from './eth-like-util.js'
 
 export {
-  EXTRA_PERCENTAGE,
   DEFAULT_CONTRACT_GAS_LIMIT,
+  DEFAULT_GAS_LIMIT_MULTIPLIER,
   estimateGasLimit,
   resolveDefaultTxInput,
   fetchGasLimit,

package/src/staking/ethereum/service.js

@@ -1,4 +1,4 @@
-import { estimateGasLimit } from '../../gas-estimation.js'
+import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
 import { amountToCurrency, DISABLE_BALANCE_CHECKS, resolveFeeData } from '../utils/index.js'
@@ -368,8 +368,10 @@ export function createEthereumStakingService({
       DISABLE_BALANCE_CHECKS
     )
 
+    const scaledGasLimit = scaleGasLimitEstimate({ estimatedGasLimit })
+
     const gasLimit = Math.max(
-      estimatedGasLimit + EXTRA_GAS_LIMIT,
+      scaledGasLimit + EXTRA_GAS_LIMIT,
 
       // For delgation transactions, we enforce an empirical
       // `MINIMUM_DELEGATE_GAS_LIMIT`, since the majority of

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

@@ -48,6 +48,7 @@ const getFeeInfo = async function getFeeInfo({
       toAddress,
       amount,
       txInput,
+      feeData,
       throwOnError: false,
     }))
 

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

@@ -28,9 +28,11 @@ export const resolveNonce = async ({
 export const getNonceFromTxLog = ({ txLog, useAbsoluteNonce }) => {
   let absoluteNonce = 0
   if (useAbsoluteNonce) {
-    for (const tx of txLog.reverse()) {
+    const reversedTxLog = txLog.reverse()
+    for (const tx of reversedTxLog) {
       if (tx.data.nonceChange) {
         absoluteNonce = parseInt(tx.data.nonceChange.to, 10)
+        break
       }
     }
   }